diff --git a/.gitignore b/.gitignore index 3bbc17c..b648614 100644 --- a/.gitignore +++ b/.gitignore @@ -39,4 +39,7 @@ nosetests.xml *.sublime-project *.sublime-workspace docs/_build/ +*.ipynb *.ipynb_checkpoints +.DS_Store +notebooks/ diff --git a/docs/source/api_EM1Dcode.rst b/docs/source/api_EM1Dcode.rst index 864b23c..57f03e3 100644 --- a/docs/source/api_EM1Dcode.rst +++ b/docs/source/api_EM1Dcode.rst @@ -14,68 +14,68 @@ Here, we used SimPEG's frame work so that we have following modules: EM1D problem ************ -.. autoclass:: simpegem1d.EM1D.EM1D - :show-inheritance: - :members: - :undoc-members: - :inherited-members: - -Computing reflection coefficients -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -.. automodule:: simpegem1d.RTEfun - :show-inheritance: - :members: - :undoc-members: - :inherited-members: - - -Digital filtering -^^^^^^^^^^^^^^^^^ - -.. automodule:: simpegem1d.DigFilter - :show-inheritance: - :members: - :undoc-members: - :inherited-members: - -Source Waveform -^^^^^^^^^^^^^^^^^^^^ - -.. automodule:: simpegem1d.Waveform - :show-inheritance: - :members: - :undoc-members: - :inherited-members: - -EM1D survey -*********** - -.. autoclass:: simpegem1d.BaseEM1D.BaseEM1DSurvey - :show-inheritance: - :members: - :inherited-members: - -Frequency domain survey -^^^^^^^^^^^^^^^^^^^^^^^ -.. autoclass:: simpegem1d.BaseEM1D.EM1DSurveyFD - :show-inheritance: - :members: - -Time domain survey -^^^^^^^^^^^^^^^^^^ -.. autoclass:: simpegem1d.BaseEM1D.EM1DSurveyTD - :show-inheritance: - :members: - - -EM1D analaytic solutions -************************ - -.. automodule:: simpegem1d.EM1DAnal - :show-inheritance: - :members: - :undoc-members: - :inherited-members: +.. .. autoclass:: simpegEM1D.EM1D.EM1D +.. :show-inheritance: +.. :members: +.. :undoc-members: +.. :inherited-members: + +.. Computing reflection coefficients +.. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. .. automodule:: simpegEM1D.RTEfun +.. :show-inheritance: +.. :members: +.. :undoc-members: +.. :inherited-members: + + +.. Digital filtering +.. ^^^^^^^^^^^^^^^^^ + +.. .. automodule:: simpegEM1D.DigFilter +.. :show-inheritance: +.. :members: +.. :undoc-members: +.. :inherited-members: + +.. Source Waveform +.. ^^^^^^^^^^^^^^^^^^^^ + +.. .. automodule:: simpegEM1D.Waveform +.. :show-inheritance: +.. :members: +.. :undoc-members: +.. :inherited-members: + +.. EM1D survey +.. *********** + +.. .. autoclass:: simpegEM1D.BaseEM1D.BaseEM1DSurvey +.. :show-inheritance: +.. :members: +.. :inherited-members: + +.. Frequency domain survey +.. ^^^^^^^^^^^^^^^^^^^^^^^ +.. .. autoclass:: simpegEM1D.BaseEM1D.EM1DSurveyFD +.. :show-inheritance: +.. :members: + +.. Time domain survey +.. ^^^^^^^^^^^^^^^^^^ +.. .. autoclass:: simpegEM1D.BaseEM1D.EM1DSurveyTD +.. :show-inheritance: +.. :members: + + +.. EM1D analaytic solutions +.. ************************ + +.. .. automodule:: simpegem1d.EM1DAnal +.. :show-inheritance: +.. :members: +.. :undoc-members: +.. :inherited-members: diff --git a/notebooks/examples/EM1DFM_forward.ipynb b/notebooks/examples/EM1DFM_forward.ipynb new file mode 100644 index 0000000..c23606d --- /dev/null +++ b/notebooks/examples/EM1DFM_forward.ipynb @@ -0,0 +1,440 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "from discretize import TensorMesh\n", + "from SimPEG import maps\n", + "from simpegEM1D.simulation import EM1DFMSimulation\n", + "from simpegEM1D.survey import EM1DSurveyFD\n", + "from simpegEM1D.sources import *\n", + "from simpegEM1D.receivers import *\n", + "from simpegEM1D import analytics\n", + "import numpy as np\n", + "import matplotlib\n", + "%pylab inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Set up for EM1D program" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step1: Generate mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.00000000e+00 -1.00000000e-01 -4.16227766e-01 -1.41622777e+00\n", + " -4.57850543e+00 -1.45785054e+01 -2.45785054e+01 -3.74940021e+01\n", + " -5.41750074e+01 -7.57193543e+01 -1.03544948e+02 -1.39483085e+02\n", + " -1.85898973e+02 -2.45847398e+02 -3.23273767e+02]\n", + "[ 0.1 0.31622777 1. 3.16227766 10. 10.\n", + " 12.91549665 16.68100537 21.5443469 27.82559402 35.93813664 46.41588834\n", + " 59.94842503 77.42636827]\n", + "[-0.00000000e+00 -1.00000000e-01 -4.16227766e-01 -1.41622777e+00\n", + " -4.57850543e+00 -1.45785054e+01 -2.45785054e+01 -3.74940021e+01\n", + " -5.41750074e+01 -7.57193543e+01 -1.03544948e+02 -1.39483085e+02\n", + " -1.85898973e+02 -2.45847398e+02 -3.23273767e+02]\n" + ] + } + ], + "source": [ + "nearthick = np.logspace(-1, 1, 5)\n", + "deepthick = np.logspace(1, 2, 10)\n", + "hx = np.r_[nearthick, deepthick]\n", + "mesh1D = TensorMesh([hx], [0.])\n", + "depth = -mesh1D.gridN[:-1]\n", + "LocSigZ = -mesh1D.gridCC\n", + "nlay = depth.size\n", + "topo = np.r_[0., 0., 0.]\n", + "print(depth)\n", + "print(-np.diff(depth))\n", + "print(-mesh1D.gridN[0:-1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step2: Set survey parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "rx_location = np.array([8., 0., 0.])\n", + "src_location = np.array([0., 0., 0.])\n", + "frequencies = np.logspace(-2, 8, 61)\n", + "I = 1.\n", + "a = 1.\n", + "field_type = \"secondary\" # \"total\", \"ppm\"\n", + "\n", + "# Receiver list\n", + "receiver_list = []\n", + "receiver_list.append(\n", + " HarmonicPointReceiver(\n", + " rx_location, frequencies, orientation=\"z\",\n", + " field_type=\"secondary\", component=\"real\"\n", + " )\n", + ")\n", + "receiver_list.append(\n", + " HarmonicPointReceiver(\n", + " rx_location, frequencies, orientation=\"z\",\n", + " field_type=\"secondary\", component=\"imag\"\n", + " )\n", + ")\n", + "\n", + "# Sources\n", + "source_list = [\n", + " HarmonicMagneticDipoleSource(\n", + " receiver_list=receiver_list, location=src_location, orientation=\"z\", I=I\n", + " )\n", + "]\n", + "\n", + "# source_list = [\n", + "# HarmonicHorizontalLoopSource(\n", + "# receiver_list=receiver_list, location=src_location, a=a, I=I\n", + "# )\n", + "# ]\n", + "\n", + "# Survey\n", + "FDsurvey = EM1DSurveyFD(source_list)\n", + "\n", + "Colesurvey = EM1DSurveyFD(source_list)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step3: Set mappings (Exponential and Cole-Cole maps)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exponential map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $$ m = log(\\sigma) $$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $$ M_{exp}(m) = e^{m}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cole-Cole map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$$ m(\\sigma_{\\infty}, \\eta, \\tau, c; \\omega) = \\sigma_{\\infty} - \\sigma_{\\infty}\\eta \\frac{1}{1+(1-\\eta)(\\imath\\omega\\tau)^c}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "sig_half = 1e-2\n", + "chi_half = 0.\n", + "Expmap = maps.ExpMap(mesh1D)\n", + "tau = np.ones(nlay, dtype=float)*1e-1\n", + "eta = np.ones(nlay, dtype=float)*0.5\n", + "c = np.ones(nlay, dtype=float)*0.88" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "m_1D = np.log(np.ones(nlay)*sig_half)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SAD I DIDN'T FIND IT\n", + "SAD I DIDN'T FIND IT\n", + "(122,)\n", + "[-5.46799058e-17 -1.16896402e-16 -2.50681887e-16 -5.38655317e-16\n", + " -1.15903476e-15 -2.49280581e-15 -5.35440132e-15 -1.14648491e-14\n", + " -2.43827071e-14 -5.11171297e-14 -1.04109185e-13 -2.01013662e-13\n", + " -3.58829149e-13 -6.06720506e-13 -1.06394230e-12 -1.88584081e-12\n", + " -3.33558439e-12 -5.90958825e-12 -1.04968251e-11 -1.86339180e-11\n", + " -3.30761887e-11 -5.87189264e-11 -1.04226195e-10 -1.84935729e-10\n", + " -3.27993936e-10 -5.81400117e-10 -1.02990773e-09 -1.82292821e-09\n", + " -3.22336302e-09 -5.69275377e-09 -1.00390953e-08 -1.76720061e-08\n", + " -3.10401974e-08 -5.43749881e-08 -9.49400531e-08 -1.65102293e-07\n", + " -2.85699664e-07 -4.91382245e-07 -8.38792464e-07 -1.41847289e-06\n", + " -2.37086483e-06 -3.90488430e-06 -6.31284960e-06 -9.96569115e-06\n", + " -1.52549352e-05 -2.24233036e-05 -3.12054975e-05 -4.02239115e-05\n", + " -4.62349237e-05 -4.37081555e-05 -2.58109982e-05 1.19223605e-05\n", + " 6.56056428e-05 1.19607359e-04 1.54009845e-04 1.62201830e-04\n", + " 1.57645995e-04 1.55099666e-04 1.55346211e-04 1.55438183e-04\n", + " 1.55423866e-04 -1.96234252e-12 -2.88032431e-12 -4.22773603e-12\n", + " -6.20546187e-12 -9.10835352e-12 -1.33691751e-11 -1.96230780e-11\n", + " -2.88021529e-11 -4.22739644e-11 -6.20442205e-11 -9.10528105e-11\n", + " -1.33607199e-10 -1.96026112e-10 -2.87606012e-10 -4.21978042e-10\n", + " -6.19036850e-10 -9.08050705e-10 -1.33179306e-09 -1.95296525e-09\n", + " -2.86329900e-09 -4.19693573e-09 -6.14991769e-09 -9.00846260e-09\n", + " -1.31899359e-08 -1.93020685e-08 -2.82282279e-08 -4.12496321e-08\n", + " -6.02194990e-08 -8.78093657e-08 -1.27854148e-07 -1.85829392e-07\n", + " -2.69500033e-07 -3.89781198e-07 -5.61840573e-07 -8.06433738e-07\n", + " -1.15137109e-06 -1.63281838e-06 -2.29574962e-06 -3.19217123e-06\n", + " -4.37453520e-06 -5.87985144e-06 -7.69730526e-06 -9.70911744e-06\n", + " -1.15928368e-05 -1.26783691e-05 -1.17757633e-05 -7.04803009e-06\n", + " 3.88605557e-06 2.32906067e-05 5.17274430e-05 8.56119100e-05\n", + " 1.15323668e-04 1.27189018e-04 1.12212357e-04 7.71012129e-05\n", + " 4.27991495e-05 2.42228201e-05 1.69490802e-05 1.20096985e-05\n", + " 8.12727627e-06 5.53589383e-06]\n" + ] + } + ], + "source": [ + "# Conductivity\n", + "simFD = EM1DFMSimulation(\n", + " survey=FDsurvey, depth=depth , sigmaMap=Expmap,\n", + " chi=np.zeros(nlay)\n", + ")\n", + "\n", + "# Hz = simFD.dpred(m_1D)\n", + "Hz = simFD.fields(m_1D)\n", + "print(np.shape(Hz))\n", + "print(Hz)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SAD I DIDN'T FIND IT\n", + "SAD I DIDN'T FIND IT\n", + "(122,)\n", + "[ 5.53757290e-15 1.13879984e-14 2.33869700e-14 4.80265611e-14\n", + " 9.85321185e-14 2.01925484e-13 4.13070866e-13 8.42699459e-13\n", + " 1.71187054e-12 3.45402835e-12 6.89324945e-12 1.35141956e-11\n", + " 2.57469873e-11 4.69381200e-11 8.03625965e-11 1.26323796e-10\n", + " 1.80484076e-10 2.34605771e-10 2.81668418e-10 3.17628539e-10\n", + " 3.40249353e-10 3.46382970e-10 3.29112985e-10 2.74424515e-10\n", + " 1.56052188e-10 -7.34649201e-11 -4.98587742e-10 -1.26861497e-09\n", + " -2.64647850e-09 -5.09387832e-09 -9.41909607e-09 -1.70321780e-08\n", + " -3.03824285e-08 -5.37019594e-08 -9.42554839e-08 -1.64411243e-07\n", + " -2.85008894e-07 -4.90700650e-07 -8.38131544e-07 -1.41784724e-06\n", + " -2.37029252e-06 -3.90438704e-06 -6.31245224e-06 -9.96542029e-06\n", + " -1.52548159e-05 -2.24233543e-05 -3.12057216e-05 -4.02242882e-05\n", + " -4.62353997e-05 -4.37086455e-05 -2.58114013e-05 1.19221248e-05\n", + " 6.56055912e-05 1.19607430e-04 1.54009937e-04 1.62201883e-04\n", + " 1.57646011e-04 1.55099671e-04 1.55346214e-04 1.55438184e-04\n", + " 1.55423867e-04 -9.82263144e-13 -1.44243389e-12 -2.11861458e-12\n", + " -3.11270526e-12 -4.57529619e-12 -6.72974845e-12 -9.90931818e-12\n", + " -1.46159963e-11 -2.16175922e-11 -3.21164614e-11 -4.80592236e-11\n", + " -7.27264954e-11 -1.11841532e-10 -1.75456456e-10 -2.80588017e-10\n", + " -4.53489970e-10 -7.29084498e-10 -1.15219144e-09 -1.78240651e-09\n", + " -2.70633190e-09 -4.05412480e-09 -6.01972956e-09 -8.88867071e-09\n", + " -1.30783931e-08 -1.91970525e-08 -2.81285629e-08 -4.11547143e-08\n", + " -6.01292914e-08 -8.77243958e-08 -1.27775521e-07 -1.85758825e-07\n", + " -2.69439907e-07 -3.89734624e-07 -5.61811467e-07 -8.06426882e-07\n", + " -1.15139217e-06 -1.63287394e-06 -2.29584692e-06 -3.19231789e-06\n", + " -4.37473857e-06 -5.88011751e-06 -7.69763704e-06 -9.70951271e-06\n", + " -1.15932852e-05 -1.26788492e-05 -1.17762397e-05 -7.04845415e-06\n", + " 3.88574150e-06 2.32904563e-05 5.17274855e-05 8.56121270e-05\n", + " 1.15323983e-04 1.27189320e-04 1.12212552e-04 7.71012871e-05\n", + " 4.27991566e-05 2.42228164e-05 1.69490808e-05 1.20096993e-05\n", + " 8.12727655e-06 5.53589397e-06]\n" + ] + } + ], + "source": [ + "# Frequency-dependent conductivity\n", + "simCole = EM1DFMSimulation(\n", + " survey=Colesurvey, depth=depth, sigmaMap=Expmap,\n", + " eta=eta, tau=tau, c=c,\n", + " chi=np.zeros(nlay)\n", + ")\n", + "\n", + "# HzCole = simCole.dpred(m_1D)\n", + "HzCole = simCole.fields(m_1D)\n", + "Hzanal = analytics.Hzanal(sig_half, frequencies, 8., 'secondary')\n", + "print(np.shape(HzCole))\n", + "print(HzCole)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "matplotlib.rcParams['font.size'] = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1, figsize = (8, 5))\n", + "ax.loglog(frequencies, np.abs(Hz[0:len(frequencies)]), 'b-')\n", + "ax.loglog(frequencies, np.abs(np.real(Hzanal)), 'bx')\n", + "ax.loglog(frequencies, np.abs(Hz[len(frequencies):]), 'r-')\n", + "ax.loglog(frequencies, np.abs(np.imag(Hzanal)), 'rx')\n", + "legend(('Real $H_{z}$', 'Real $H_{z \\ true}$', 'Imag $H_{z}$', 'Imag $H_{z \\ true}$'))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1, figsize = (8, 5))\n", + "ax.loglog(frequencies, np.abs(HzCole[0:len(frequencies)]), 'b-')\n", + "ax.loglog(frequencies, np.abs(np.real(Hzanal)), 'bx')\n", + "ax.loglog(frequencies, np.abs(HzCole[len(frequencies):]), 'r-')\n", + "ax.loglog(frequencies, np.abs(np.imag(Hzanal)), 'rx')\n", + "legend(('Real $H_{z}$', 'Real $H_{z \\ IP}$', 'Imag $H_{z}$', 'Imag $H_{z \\ IP}$'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/examples/EM1DFM_inversion_sigma_height.ipynb b/notebooks/examples/EM1DFM_inversion_sigma_height.ipynb new file mode 100644 index 0000000..def9243 --- /dev/null +++ b/notebooks/examples/EM1DFM_inversion_sigma_height.ipynb @@ -0,0 +1,391 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "from SimPEG import *\n", + "from discretize import TensorMesh\n", + "from simpegEM1D.simulation import EM1DFMSimulation\n", + "from simpegEM1D.survey import EM1DSurveyFD\n", + "from simpegEM1D.sources import *\n", + "from simpegEM1D.receivers import *\n", + "from simpegEM1D import analytics, Utils1D\n", + "from simpegEM1D.EM1DSimulation import *\n", + "from scipy.constants import mu_0\n", + "import numpy as np\n", + "%pylab inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "rx_location = np.array([7.86, 0., 100.+30.])\n", + "src_location = np.array([0., 0., 100.+30.])\n", + "rx_location2 = np.array([7.86, 0., 100.+35.])\n", + "src_location2 = np.array([0., 0., 100.+35.])\n", + "\n", + "frequency = np.array([382, 1822, 7970, 35920, 130100], dtype=float)\n", + "I = 1.\n", + "a = 1.\n", + "field_type = \"ppm\"\n", + "\n", + "# Receiver list\n", + "receiver_list = [\n", + " HarmonicPointReceiver(\n", + " rx_location, frequency, orientation=\"z\", field_type=field_type, component=\"real\"\n", + " )\n", + "]\n", + "receiver_list.append(\n", + " HarmonicPointReceiver(\n", + " rx_location, frequency, orientation=\"z\", field_type=field_type, component=\"imag\"\n", + " )\n", + ")\n", + "\n", + "\n", + "receiver_list2 = [\n", + " HarmonicPointReceiver(\n", + " rx_location2, frequency, orientation=\"z\", field_type=field_type, component=\"real\"\n", + " )\n", + "]\n", + "receiver_list2.append(\n", + " HarmonicPointReceiver(\n", + " rx_location2, frequency, orientation=\"z\", field_type=field_type, component=\"imag\"\n", + " )\n", + ")\n", + "\n", + "\n", + "# Sources\n", + "source_list = [\n", + " HarmonicMagneticDipoleSource(\n", + " receiver_list=receiver_list, location=src_location, orientation=\"z\", I=I\n", + " )\n", + "]\n", + "\n", + "source_list.append(\n", + " HarmonicMagneticDipoleSource(\n", + " receiver_list=receiver_list2, location=src_location2, orientation=\"z\", I=I\n", + " )\n", + ")\n", + "\n", + "\n", + "\n", + "# source_list = [\n", + "# HarmonicHorizontalLoopSource(\n", + "# receiver_list=receiver_list, location=src_location, a=a, I=I\n", + "# )\n", + "# ]\n", + "\n", + "# Survey\n", + "FDsurvey = EM1DSurveyFD(source_list)\n", + "nSrc = FDsurvey.nSrc" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sig_half = 1e-1\n", + "sig_blk = 1e0\n", + "\n", + "hz = get_vertical_discretization_frequency(frequency, sigma_background=sig_half)\n", + "mesh1D = set_mesh_1d(hz)\n", + "depth = -mesh1D.gridN[:-1]\n", + "LocSigZ = -mesh1D.gridCC\n", + "nlay = depth.size\n", + "topo = np.r_[0., 0., 100.]\n", + "\n", + "chi_half = 0.\n", + "wires = maps.Wires(('sigma', mesh1D.nC),('h', nSrc))\n", + "expmap = maps.ExpMap(mesh1D)\n", + "# expmap_h = Maps.ExpMap(nP=1)\n", + "sigmaMap = expmap * wires.sigma\n", + "# hMap = expmap_h*wires.h\n", + "sig = np.ones(mesh1D.nC)*sig_half\n", + "blk_ind = (-20>LocSigZ) & (-40]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots(1,1, figsize=(5, 8))\n", + "Utils1D.plotLayer(sig, mesh1D, showlayers=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (19,5) (20,5) ", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 4\u001b[0m )\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0md_true\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdpred\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm_true\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 7\u001b[0m \u001b[1;31m# d_p = FDsurvey.dpred(m_dx_p)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[1;31m# d_n = FDsurvey.dpred(m_dx_n)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Documents\\Repositories\\simpegEM1D\\simpegEM1D\\simulation.py\u001b[0m in \u001b[0;36mdpred\u001b[1;34m(self, m, f)\u001b[0m\n\u001b[0;32m 396\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mm\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 397\u001b[0m \u001b[0mm\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 398\u001b[1;33m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfields\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 399\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 400\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Documents\\Repositories\\simpegEM1D\\simpegEM1D\\simulation.py\u001b[0m in \u001b[0;36mfields\u001b[1;34m(self, m)\u001b[0m\n\u001b[0;32m 378\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 379\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mfields\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 380\u001b[1;33m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcompute_integral\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moutput_type\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'response'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 381\u001b[0m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprojectFields\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 382\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhstack\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Documents\\Repositories\\simpegEM1D\\simpegEM1D\\simulation.py\u001b[0m in \u001b[0;36mcompute_integral\u001b[1;34m(self, m, output_type)\u001b[0m\n\u001b[0;32m 245\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 246\u001b[0m \u001b[1;31m# Create globally, not for each receiver\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 247\u001b[1;33m \u001b[0msig\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msigma_cole\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfrequencies\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 248\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 249\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mHarmonicMagneticDipoleSource\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m|\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mTimeDomainMagneticDipoleSource\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\Documents\\Repositories\\simpegEM1D\\simpegEM1D\\simulation.py\u001b[0m in \u001b[0;36msigma_cole\u001b[1;34m(self, frequencies)\u001b[0m\n\u001b[0;32m 174\u001b[0m sigma_complex[:, :] = (\n\u001b[0;32m 175\u001b[0m \u001b[0msigma\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 176\u001b[1;33m \u001b[0msigma\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0meta\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0meta\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1j\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mw\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mtau\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 177\u001b[0m )\n\u001b[0;32m 178\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (19,5) (20,5) " + ] + } + ], + "source": [ + "sim = EM1DFMSimulation(\n", + " survey=FDsurvey, thicknesses=hz, sigmaMap=sigmaMap, hMap=wires.h,\n", + " chi= np.zeros(nlay)\n", + ")\n", + " \n", + "d_true = sim.dpred(m_true)\n", + "# d_p = FDsurvey.dpred(m_dx_p)\n", + "# d_n = FDsurvey.dpred(m_dx_n)\n", + "d_dh = sim.dpred(m_true_dh)\n", + "# J_h_diff = (d_p-d_n) / (dh)\n", + "# plt.plot(J_h_diff, 'k')\n", + "# plt.plot(prob.getJ_height(m_true), 'bx')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1,1, figsize = (7,5))\n", + "if nSrc == 1:\n", + " axes.plot(frequency, d_true[0:len(frequency)], 'k.-')\n", + " axes.plot(frequency, d_true[len(frequency):], 'b.-')\n", + " axes.plot(frequency, d_dh[0:len(frequency)], 'kx')\n", + " axes.plot(frequency, d_dh[len(frequency):], 'bx')\n", + "else:\n", + " axes.plot(frequency, d_true[0:len(frequency)], 'k.-')\n", + " axes.plot(frequency, d_true[len(frequency):2*len(frequency)], 'b.-')\n", + " axes.plot(frequency, d_dh[0:len(frequency)], 'kx')\n", + " axes.plot(frequency, d_dh[len(frequency):2*len(frequency)], 'bx')\n", + " \n", + "axes.set_xscale('log')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from SimPEG import regularization, data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "std = 0.07\n", + "floor = 0.\n", + "np.random.seed(1)\n", + "uncert = std*abs(d_true)+floor\n", + "noise = std*np.abs(d_true)*np.random.randn(len(d_true))\n", + "d_obs = d_true + noise\n", + "dataObj = data.Data(FDsurvey, dobs=d_obs, noise_floor=uncert)\n", + "\n", + "dmisfit = data_misfit.L2DataMisfit(dataObj, sim)\n", + "dmisfit.W = utils.sdiag(1/uncert)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "m0 = np.r_[np.log(np.ones_like(sig)*sig_half), 45.*np.ones(nSrc)]\n", + "\n", + "reg_sigma = regularization.Sparse(\n", + " mesh1D, mapping=wires.sigma, cell_weights=mesh1D.vol,\n", + " alpha_s = 0.01\n", + ")\n", + "p=0.\n", + "qx, qz = 1., 1.\n", + "reg_sigma.norms = np.c_[p, qx, qz, 0.]\n", + "IRLS = directives.Update_IRLS(\n", + " max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, \n", + " beta_tol=1e-2,\n", + " chifact_start = 1.\n", + ")\n", + "\n", + "mesh_h = TensorMesh([np.ones(nSrc)])\n", + "reg_h = regularization.Sparse(\n", + " mesh_h, mapping=wires.h, \n", + " alpha_s = 1.\n", + ")\n", + "reg = reg_sigma + reg_h\n", + "opt = optimization.ProjectedGNCG(maxIter = 40)\n", + "opt.maxIterLS = 5\n", + "invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)\n", + "beta = directives.BetaSchedule(coolingFactor=2, coolingRate=2)\n", + "betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", + "target = directives.TargetMisfit()\n", + "update_sense = directives.UpdateSensitivityWeights()\n", + "inv = inversion.BaseInversion(invProb, directiveList=[beta,betaest,target])\n", + "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS, betaest])\n", + "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS])\n", + "\n", + "# prob.counter = opt.counter = utils.Counter()\n", + "opt.LSshorten = 0.5\n", + "opt.remember('xc')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(np.shape(sim.getJ_sigma(m0)))\n", + "print(np.shape(sim.getJ_height(m0)))\n", + "print(sim.getJ_height(m0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mopt = inv.run(m0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print (wires.h*m0)\n", + "print (wires.h*mopt)\n", + "print (sim.h)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pylab inline\n", + "fig, ax = subplots(1,1, figsize=(5, 8))\n", + "Utils1D.plotLayer(sig, mesh1D, showlayers=False)\n", + "Utils1D.plotLayer(sigmaMap*mopt, mesh1D, showlayers=True, **{'color':'r'})\n", + "# Utils1D.plotLayer(sigmaMap*invProb.l2model, LocSigZ, showlayers=True,**{'color':'g'})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = subplots(1,1, figsize = (7,5))\n", + "if nSrc == 1:\n", + " axes.plot(frequency, d_true[0:len(frequency)], 'k.-')\n", + " axes.plot(frequency, d_true[len(frequency):], 'b.-')\n", + " axes.plot(frequency, d_obs[0:len(frequency)], 'kx')\n", + " axes.plot(frequency, d_obs[len(frequency):], 'bx')\n", + "else:\n", + " axes.plot(frequency, d_true[0:len(frequency)], 'k.-')\n", + " axes.plot(frequency, d_true[len(frequency):2*len(frequency)], 'b.-')\n", + " axes.plot(frequency, d_obs[0:len(frequency)], 'kx')\n", + " axes.plot(frequency, d_obs[len(frequency):2*len(frequency)], 'bx')\n", + "axes.set_xscale('log')\n", + "axes.set_xlabel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/examples/EM1DTM_forward.ipynb b/notebooks/examples/EM1DTM_forward.ipynb new file mode 100644 index 0000000..26a159c --- /dev/null +++ b/notebooks/examples/EM1DTM_forward.ipynb @@ -0,0 +1,288 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "from SimPEG import *\n", + "from simpegEM1D import (\n", + " Utils1D, get_vertical_discretization_time, \n", + " set_mesh_1d, skytem_HM_2015\n", + ")\n", + "from simpegEM1D.simulation import EM1DTMSimulation\n", + "from simpegEM1D.survey import EM1DSurveyTD\n", + "from simpegEM1D.sources import *\n", + "from simpegEM1D.receivers import *\n", + "from simpegEM1D import analytics\n", + "import numpy as np\n", + "from simpegEM1D import skytem_HM_2015\n", + "from simpegEM1D.supporting_functions.digital_filter import setFrequency, transFilt\n", + "from scipy.constants import mu_0\n", + "%pylab inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Set up for EM1D program\n", + "\n", + "## Step 1: Generate Mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "hz = np.array([10, 10, 10])\n", + "mesh1D = set_mesh_1d(hz)\n", + "depth = -mesh1D.gridN[:-1]\n", + "nlay = len(depth)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step2: Set survey parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "rx_location = np.array([10., 0., 0.])\n", + "src_location = np.array([0., 0., 0.])\n", + "times = np.logspace(-5, -2, 31)\n", + "I = 1.\n", + "a = 1.\n", + "\n", + "# Receiver list\n", + "receiver_list = []\n", + "receiver_list.append(\n", + " TimeDomainPointReceiver(\n", + " rx_location, times, orientation=\"z\", component=\"dhdt\"\n", + " )\n", + ")\n", + "\n", + "# Sources\n", + "source_list = [\n", + " TimeDomainMagneticDipoleSource(\n", + " receiver_list=receiver_list, location=src_location, orientation=\"z\", I=I\n", + " )\n", + "]\n", + "\n", + "# Survey\n", + "TDsurvey = EM1DSurveyTD(source_list)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Model and Mapping" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "sigma_half = 0.1\n", + "sigma = np.ones(hz.size) * sigma_half\n", + "\n", + "chi_half = 0.\n", + "Expmap = maps.ExpMap(mesh1D)\n", + "tau = np.ones(nlay, dtype=float)*1e-1\n", + "eta = np.ones(nlay, dtype=float)*0.5\n", + "c = np.ones(nlay, dtype=float)*0.88" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "m_1D = np.log(np.ones(nlay)*sigma_half)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(31,)\n", + "[-9.92937941e-07 -6.17689284e-07 -3.75646836e-07 -2.24602803e-07\n", + " -1.32533952e-07 -7.74092430e-08 -4.48521362e-08 -2.58254102e-08\n", + " -1.47968151e-08 -8.44500782e-09 -4.80503982e-09 -2.72731327e-09\n", + " -1.54502184e-09 -8.73921628e-10 -4.93729793e-10 -2.78671206e-10\n", + " -1.57167471e-10 -8.85864409e-11 -4.99075897e-11 -2.81067715e-11\n", + " -1.58245975e-11 -8.90718303e-12 -5.01227757e-12 -2.81979375e-12\n", + " -1.58599811e-12 -8.91901941e-13 -5.01544502e-13 -2.82042815e-13\n", + " -1.58628428e-13 -8.92263344e-14 -5.02034756e-14]\n" + ] + } + ], + "source": [ + "# Conductivity\n", + "simFD = EM1DTMSimulation(\n", + " mesh1D, survey=TDsurvey, sigmaMap=Expmap,\n", + " chi=np.zeros(nlay)\n", + ")\n", + "\n", + "\n", + "bz = simFD.fields(m_1D)\n", + "print(np.shape(bz))\n", + "print(bz)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def analytic_solution(r, t, sigma, dtype='h'):\n", + " \"\"\"\n", + " r: offset bewteen VMD soure and Bz receiver (m)\n", + " t: measured times\n", + " sigma: conductivity of the half-space earth\n", + " \"\"\"\n", + " wt, tbase, omega_int = setFrequency(t)\n", + " hz = analytics.Hzanal(sigma, omega_int/2/np.pi, r, 'secondary')\n", + " if dtype=='dhdt':\n", + " hz *= 1j*omega_int\n", + " # Treatment for inaccuracy in analytic solutions\n", + " ind = omega_int < 0.2\n", + " hz[ind] = 0.\n", + " hzTD, f0 = transFilt(hz, wt, tbase, omega_int, t)\n", + " return hzTD*mu_0" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(31,)\n", + "[-9.95161669e-07 -6.20841539e-07 -3.78810288e-07 -2.25799726e-07\n", + " -1.33069842e-07 -7.81387385e-08 -4.52134487e-08 -2.58631252e-08\n", + " -1.49306593e-08 -8.52817273e-09 -4.81590694e-09 -2.74810393e-09\n", + " -1.56156404e-09 -8.78911182e-10 -4.96400334e-10 -2.81652107e-10\n", + " -1.58467449e-10 -8.88078264e-11 -5.04022696e-11 -2.83868835e-11\n", + " -1.58432708e-11 -8.98129862e-12 -5.06659192e-12 -2.83415592e-12\n", + " -1.59650652e-12 -9.02328531e-13 -5.05958122e-13 -2.83365433e-13\n", + " -1.60468028e-13 -9.01946715e-14 -5.02429319e-14]\n" + ] + } + ], + "source": [ + "bz_analytic = analytic_solution(rx_location[0]-src_location[0], times, sigma_half, 'dhdt')\n", + "print(np.shape(bz_analytic))\n", + "print(bz_analytic)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = subplots(1,1, figsize = (7,5))\n", + "axes.loglog(times, np.abs(bz_analytic), '-')\n", + "axes.loglog(times, np.abs(bz), 'o')\n", + "axes.set_xscale('log')\n", + "axes.set_yscale('log')\n", + "axes.set_xlabel('Time (s)')\n", + "axes.set_ylabel('Bz (T)')\n", + "axes.legend((\"Analytic\", \"simpegEM1D\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/examples/EM1DTM_inversion_layers.ipynb b/notebooks/examples/EM1DTM_inversion_layers.ipynb new file mode 100644 index 0000000..650c8b0 --- /dev/null +++ b/notebooks/examples/EM1DTM_inversion_layers.ipynb @@ -0,0 +1,424 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "from SimPEG import *\n", + "from simpegEM1D.simulation import EM1DTMSimulation\n", + "from simpegEM1D.survey import EM1DSurveyTD\n", + "from simpegEM1D.sources import *\n", + "from simpegEM1D.receivers import *\n", + "from simpegEM1D import analytics, Utils1D\n", + "from simpegEM1D.EM1DSimulation import *\n", + "\n", + "from simpegEM1D import skytem_HM_2015\n", + "import numpy as np\n", + "%pylab inline\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "times = np.logspace(-5, -2, 31)\n", + "rx_location = np.array([0., 0., 100.+30.])\n", + "src_location = np.array([0., 0., 100.+30.])\n", + "\n", + "I = 1.\n", + "a = 13.\n", + "\n", + "wave_type = \"stepoff\"\n", + "\n", + "# Receiver list\n", + "receiver_list = [\n", + " TimeDomainPointReceiver(\n", + " rx_location, times, orientation=\"z\", component=\"dbdt\"\n", + " )\n", + "]\n", + "\n", + "source_list = [\n", + " TimeDomainHorizontalLoopSource(\n", + " receiver_list=receiver_list, location=src_location, a=a, I=I,\n", + " base_frequency = 25., use_lowpass_filter=False, high_cut_frequency=210*1e3\n", + " )\n", + "]\n", + "\n", + "\n", + "TDsurvey = EM1DSurveyTD(source_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sig_half = 1e-1\n", + "sig_blk = sig_half * 20.\n", + "chi_half = 0.\n", + "\n", + "hz = get_vertical_discretization_time(times, facter_tmax=0.5, factor_tmin=10., n_layer=19)\n", + "mesh1D = set_mesh_1d(hz)\n", + "depth = -mesh1D.gridN[:-1]\n", + "LocSigZ = -mesh1D.gridCC\n", + "nlay = depth.size\n", + "topo = np.r_[0., 0., 100.]\n", + "\n", + "sig = np.ones(nlay)*sig_half\n", + "blk_ind = (-30>LocSigZ) & (-70]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots(1,1, figsize=(5, 8))\n", + "Utils1D.plotLayer(sig, mesh1D, showlayers=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-4.33201110e-02 -3.74342148e-02 -3.21944429e-02 -2.74832496e-02\n", + " -2.31673558e-02 -1.91405535e-02 -1.53723456e-02 -1.19200707e-02\n", + " -8.89247606e-03 -6.39192125e-03 -4.46682573e-03 -3.09079433e-03\n", + " -2.17200300e-03 -1.58589851e-03 -1.21341381e-03 -9.65658351e-04\n", + " -7.88243222e-04 -6.52425842e-04 -5.44257515e-04 -4.57288388e-04\n", + " -3.88241761e-04 -3.34143659e-04 -2.91049718e-04 -2.54543505e-04\n", + " -2.21031500e-04 -1.88585636e-04 -1.56868139e-04 -1.26515469e-04\n", + " -9.85265155e-05 -7.38469377e-05 -5.31411525e-05]\n", + "Wall time: 51.1 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "sim = EM1DTMSimulation(\n", + " mesh1D, survey=TDsurvey, sigmaMap=expmap, verbose=False\n", + ")\n", + "sim.chi = np.zeros(nlay)\n", + "d_true = sim.dpred(m_true)\n", + "print(d_true)" + ] + }, + { + "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" + } + ], + "source": [ + "fig, axes = subplots(1,1, figsize = (7,5))\n", + "axes.plot(times, -d_true, '.-')\n", + "axes.set_xscale('log');\n", + "axes.set_yscale('log');" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(1)\n", + "std = 0.05\n", + "noise = std*abs(d_true)*np.random.randn(len(d_true))\n", + "d_obs = d_true + noise\n", + "floor = 0.\n", + "std = 0.07\n", + "uncert = abs(d_obs)*std+floor\n", + "dataObj = data.Data(TDsurvey, dobs=d_obs, noise_floor=uncert)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = subplots(1,1, figsize = (7,5))\n", + "axes.plot(times, -d_true, 'b.-')\n", + "axes.plot(times, -d_obs, 'r.-')\n", + "axes.set_xscale('log');\n", + "axes.set_yscale('log');" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "dmisfit = data_misfit.L2DataMisfit(dataObj, sim)\n", + "dmisfit.W = utils.sdiag(1/uncert)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "m0 = np.log(np.ones_like(sig)*sig_half)\n", + "d_0 = sim.dpred(m0)\n", + "# delta = prob.get_threshold(uncert)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "reg = regularization.Sparse(\n", + " mesh1D,\n", + " mapping=maps.IdentityMap(mesh1D),\n", + " alpha_s=1.,\n", + " alpha_x=1.\n", + ")\n", + "p = 0\n", + "qx, qz = 2., 2.\n", + "reg.norms = np.c_[p, qx, qz, 0.]\n", + "IRLS = directives.Update_IRLS(\n", + " max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2,\n", + " chifact_start = 1.\n", + ")\n", + "opt = optimization.ProjectedGNCG(maxIter = 25)\n", + "invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)\n", + "beta = directives.BetaSchedule(coolingFactor=2., coolingRate=1)\n", + "betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0)\n", + "target = directives.TargetMisfit()\n", + "# update_sense = Directives.UpdateSensitivityWeights(threshold=delta)\n", + "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS, betaest])\n", + "inv = inversion.BaseInversion(invProb, directiveList=[beta, betaest, target])\n", + "# prob.counter = opt.counter = Utils.Counter()\n", + "opt.LSshorten = 0.5\n", + "opt.remember('xc')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem will set Regularization.mref to m0.\n", + "\n", + " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same Solver and solverOpts as the problem***\n", + "model has any nan: 0\n", + "=============================== Projected GNCG ===============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + "x0 has any nan: 0\n", + " 0 4.37e-01 1.92e+03 0.00e+00 1.92e+03 8.80e+02 0 \n", + " 1 2.18e-01 2.63e+02 2.04e+02 3.07e+02 2.10e+02 0 \n", + " 2 1.09e-01 1.33e+02 2.90e+02 1.65e+02 1.62e+02 0 \n", + " 3 5.46e-02 1.03e+02 1.31e+02 1.10e+02 1.59e+02 0 \n", + " 4 2.73e-02 3.35e+01 2.74e+02 4.10e+01 1.11e+02 0 \n", + " 5 1.36e-02 1.82e+01 2.11e+02 2.11e+01 5.09e+01 0 \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 1.9163e+02\n", + "1 : |xc-x_last| = 6.4219e-01 <= tolX*(1+|x0|) = 1.1037e+00\n", + "0 : |proj(x-g)-x| = 5.0905e+01 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 5.0905e+01 <= 1e3*eps = 1.0000e-02\n", + "0 : maxIter = 25 <= iter = 6\n", + "------------------------- DONE! -------------------------\n", + "Wall time: 3.17 s\n" + ] + } + ], + "source": [ + "%%time\n", + "mopt = inv.run(m0)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# opt.counter.summary()\n", + "# xc = opt.recall('xc')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = subplots(1,1, figsize=(5, 8))\n", + "Utils1D.plotLayer(sig, mesh1D)\n", + "Utils1D.plotLayer(expmap*mopt, mesh1D, showlayers=False, **{'color':'r'})\n", + "# Utils1D.plotLayer(expmap*invProb.l2model, mesh1D, showlayers=False, **{'color':'b', 'lw':1.})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAEzCAYAAABZgfYmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de3RU1dnH8e8TwKKiSAteihesoIC3t5p4R4kihEJELCCKKBYBsWpVLqKCKLytoIJVtAjeqFXBeAUEhYqhiBdMUGuhVgWXVPACVIpapQru94/HvAkxgYTMzDkz8/uslRXm5MzwsE7jr/ucvZ9tIQRERETSXU7UBYiIiCSCAk1ERDKCAk1ERDKCAk1ERDKCAk1ERDKCAk1ERDJC/agL2JamTZuGFi1aRF2GiIjEyNKlS9eHEJpVPh7rQGvRogWlpaVRlyEiIjFiZquqOq5bjiIikhEUaCIikhFiGWhmVmhmUzdu3Bh1KSIikiZiGWghhNkhhIGNGzeOuhQREUkTsQw0ERGR2lKgiYhIRlCgiYhIRlCgiYhIRsjYQLv5Zigu3vpYcbEfFxGRzJOxgZaXB716lYdacbG/zsur+nwFoIhIeotloCViHVp+PhQVeYhdf71/Lyry41WpbQCKiEi8xDLQErUOLT8fBg+GsWP9e3VhVnZubQJQRETiJZaBlijPP++3DLt1gz/84Ye3FCurTQCKiEi8ZGygFRfD2WfDrrvCzJnw2WfQsSNcfDG8807175k8GUaN8u/bC0AREYmPjA20khJ4/HFYt87/PHIkHHAATJkCrVvDIYfAsGGwaBFs3lz+zKyoCMaMKb/9WFWoaQKJiEj8WAgh6hqqlZubGxK9H9o//wmzZ/vXCy/At9/Cj3/sYVdYCEOGwO67+7nFxR6Gw4dv/RkVwy8//4evRUQkecxsaQgh9wfHsy3QKvr8c5g/38Ntzhz417+gQQPo1MkD6owzoLp5KWUhNniw355UmImIpEZ1gZaxtxxrYvfdoUcP+OMf4ZNP/PbjZZfBX/8K558Pe+7pE0oeftjDryJNIBERiZesDrSK6teHdu1gwgT44AN45RX49a/h9dfhvPM83Lp3h+nT4YsvNIFERCRuFGhVyMmB446DiRNh1Sp46SWfHfnaa3DuufCTn0BBgY/Mhg/f9gQS0CQSEZFUUKBtR04OnHAC/P738OGH8OKL3j2kUSO/3bjXXvDgg74Y+7XXqv4MdSEREUm+WE4KMbNCoLBly5YD3nvvvajLqdKWLT5ye+ghvw355Ze+HOCii/z5W7NmW5+vSSQiIomRVpNCEtX6Kpnq1YOTT4apU+Hjj+G++6BJExg6FJo3h549fQbld9/5+ZpEIiKSXLEMtHTTqBH86lfw8suwbBlceqmPyDp1gp/9zBdqP/qoJpGIiCSTAi3BDj3UJ5OsWeMhdvDBMHo09O7t4XbUUTBjxrYnkYiISO3F8hlamWQvrE6VESPgo4+8M8maNR5yhYXeoeTaa6OuTkQkvVT3DK1+FMVkm3Hj/PvmzfDkkzB+vK9322cf70wyaFB5uy0REdkxuuWYQvXr+63G0lL485+hbVtfx7b//nDNNd6tREREdowCLQJm0KGD79dWWurb2owfDy1a+GhtxYqoKxQRST8KtIgdfbSvSXvnHbjgAu8r2aoVtG8PS5eWn6fOIiIi26ZAi4lWrXyvtg8+gHPO8UbJubnQubOvcVNnERGRbVOgxczee8Mjj8CsWb7b9sKF3n3kmGO8E0lV1CtSRESBFltdu8JVV8GmTXDssT6JpFUrX6T9n/9sfa56RYqIKNBiq+L2NCtXwv33e4f/0aN9Hdu0ad5PEryNVlnH/+uv1+7ZIpKdFGgxVDbCKiryEVlREVx5pe/Ptngx7LcfXHihP2NbsMDfo16RIpLtFGgxVFKy9QirbARWUgInnuibj06fDhs2+PT/rl3hgQfUK1JEslssW1+lw/YxcbBpE0yaBDfe6M/VCgt9RuSyZbrtKCKZS9vHZKCGDWHYMBgyBM48E5591ruPrF3rjZFLSqKuUEQkddTLMQPceKN/X77cn6317g1nnQV/+EO0dYmIpFIsR2iyYw491PdkGzcOnnnGX8+YATG8qywiknAKtAxTvz5cfTW88Qa0bOldR375SzU+FpHMp0DLUG3bwksvebeQuXN9tPbIIxqtiUjmUqBlsHr1fNLIm2/6Yuw+faB7d/j446grExFJPAVaFmjd2hdk33orzJvno7WHHtJoTUQyiwItS9Sr59P733zTA65vX+jWDT79NOrKREQSQ4GWZQ45BF58ESZM8IbHRx3lMyNFRNKdAi0LTZgAP/85LFkCO+8Mp5wCl1/uu2aLiKQrBVoWKttu5l//gtJSb3I8aZKP2CpvTSMiki4UaFmo4nYzEyfCihXeYeSFF+D44/21iEi6UaBlqcrbzdx/v/eCXLPGR2yzZkVdoYhI7SjQslTFDUTLtpvp1AmWLoWDDvIZkCNHlm8iKiISdwq0LFTVBqK9evnxFi28w0j//vDb30Lnzr5LduX91YqLvQuJiEhcKNCy0LY2EAXflubee+Gee+Avf4G77/bu/WWhVhaIeXnR1C8iUpVYbvBZJjc3N5SWlkZdRlYrKYEePeCjjzzorrzSb1Fq81ARiUpabfAp8ZGX58/V8vPhyy99EsnFFyvMRCR+FGiyXU2bwvDhPkIDuOUWmD8/2ppERCpToMl2FRf7vmpz5vhEkf/+F7p29dciInGhQJPtKptEcuqpcO21vmZtyxYYNAjWro26OhERl9JAM7MzzeweM5tpZh1T+XfLjhs+fOtnZhdeCDNnwmefwQknwMqV0dUmIlKmxoFmZveb2VozW1bpeIGZvWNmK8xsxLY+I4TwdAhhANAPOHuHKpZY6NoVFiyADRs81N54I+qKRCTb1WaENg0oqHjAzOoBdwGdgbbAOWbW1swON7NnKn3tWeGtI79/n6Sx44/3jUN/9CPv2L9gQdQViUg2q3GghRAWAZ9VOnwMsCKE8H4I4RtgBtAthPC3EELXSl9rzY0Hng0hvJ64f4ZEpU0beOUVOOAA7yoyY0bUFYlItqrrM7TmwIcVXq/+/lh1LgM6AD3M7OKqTjCzgWZWamal69atq2N5kgrNm8OiRXDccT4b8vbbo65IRLJRXQPNqjhWbeuREMIdIYSjQwgXhxDuruacqSGE3BBCbrNmzepYnqRKkyYwbx507w5XXAEjRkCMm9CISAaqa6CtBvar8Hpf4KM6fqakqZ13hmOO8Qkj48f7bMjNm9XIWERSo66BVgK0MrMDzWwnoDegnbSy2LHHwquvwgUXwB//CAUFamQsIqlRm2n704FXgEPMbLWZ9Q8hbAYuBeYBbwNFIYTldS3KzArNbOrGjRvr+lGSYmWd++fM8T8vWAD/8z9w8slRVyYimU7d9iUprr/eGxm3bw8LF/qI7b77oF69qCsTkXSnbvuSMhV3w162DPr189uPAwbAd99FXZ2IZKr6URcgmaXibtj5+f7Vqxf07QsPPAA5OTB1qn8XEUmkWP5nRc/Q0ld1u2EfeiiMHOm3HQcP1khNRBJPz9AkZUKA666Dm27yULvrLrCqVjKKiGxDdc/QdMtRUsbM91PbssXXpeXkwKRJCjURSQwFmqSUGYwb57ccb73VQ+322xVqIlJ3CjRJOTMfoW3ZArfd5lP5J05UqIlI3WhSiETCDCZMgBNPhN//HoYNK+/9qFZZIrIjYhloIYTZIYSBjRs3jroUSSIzGDMGGjb0cBsxAl54Qa2yRGTHxDLQJHuceqq3yWrY0EdlZ5yx9bR/EZGaUqBJ5E49FYYO9T//5z+wcmW09YhIelKgSeSKi+Huu+Haa6FBAxg4EJ58MuqqRCTdKNAkUhVbZf32t/D00z7r8eyz/WciIjUVy0DTLMfsUblV1i9+AY8/Dj/5iT9PW7o02vpEJH2o9ZXE0po1PqX/q69g8WI4+OCoKxKRuND2MZJWmjeH+fP9z6ef7gEnIrItCjSJrYMPhueegw0boGNH+OyzqCsSkThToEmsHXUUzJwJK1ZAly4+rV9EpCoKNIm9/HyYMQNeew169IBvvom6IhGJo1gGmmY5SmXdu8OUKX4Lsl8/bRAqIj8Uy0BTL0epykUX+eag06fDFVeUNzMWEQFtHyNp5uqrYd06326mWTMYNSrqikQkLhRoklbM4JZbYP16uP562GcfH7mJiCjQJK3cfLNvLXPvvbB2LQwaBJ98AjvtBMOHR12diEQpls/QRKqTl+e9Hxcvhsceg1at/LbjLrtEXZmIRE2BJmklP997P/bq5aO19evhpz+F0aPhH/+IujoRiZICTdJOfj4MHgxjx8Ill8CLL/q2M506wUcfRV2diERFgSZpp7gYJk/2W42TJ8OqVTB3rrfGKiiAf/876gpFJAqxDDQtrJbqVNw/bcyY8tuPGzf6pqD/+Icvwv7vf6OuVERSLZaBpoXVUp3K+6eVPVMrKfGu/NOmwcKF0LevuomIZBtN25e0UtXU/Pz88oA791z4+GMYOhT23tu3oTnmmPKfg4/ySko0zV8k08RyhCZSF0OGwFVXwaRJsHKl35IsLvafld2yzMuLtkYRSTyN0CQj3XKLj9TuuQdGjPAQGzzYJ5FUvGUpIplDgSYZKSfHn6etWwe33go9e/o0/1GjFGYimUq3HCVj7bQTPPEEtGjhHfr79/cRWtntRxHJLAo0yWhLl/r6tL33hqef9luRFZ+piUjmUKBJRispgccf996PDRrAyJFwxx1+XEQyi4UY75KYm5sbSktLoy5DMsRbb8Epp/g+ai++CHvtFXVFIrIjzGxpCCG38vFYjtDUKUSS4YgjYM4cWLPGW2Tpf14imSWWgaZOIZIsJ5zgLbKWL4fCQvjqq6grEpFEiWWgiSRTp07w8MP+XK1nT/j226grEpFEUKBJVurZE6ZM8S79F1ygvo8imUALqyVrDRgAGzbA1VdDkyZw551gFnVVIrKjFGiS1YYP93Vq48fDj3/s3UREJD0p0CTr3XSTh9r//q+P1K66KuqKRGRHKNAk65l5S6x//9s79TdpAhdeGHVVIlJbCjQRoF49eOghX5t20UWwxx6+87WIpA/NchT53k47Qbt20Lo19O4N8+f78eJiuPnmaGsTke1ToIlUcOKJ8OmnsN9+cMYZHmTaEFQkPSjQRCrIz4fHHvPnaU2a+JT+IUO0h5pIOlCgiVSSnw+XXAKffAL77AOjR8Mzz0RdlYhsjwJNpJLiYp/1OGoUfPMNHHggnHUWzJwZdWUisi0KNJEKiov9mVlREYwZ47cf16+Hgw6CHj3gqaeirlBEqhPLQNP2MRKVkhIPs7JnZmXP1M45B3JzPeyeeCLaGkWkatrgU6SGPv8cOneGJUvgkUc83EQk9dJqg0+RONp9d3juOTj+eDj3XJgxI+qKRKQiBZpILey2Gzz7rK9X69PH91UTkXhQoInUUqNGvo/aKadA377w4INRVyQioEAT2SG77upr0w46yDcIfeCB8p+pVZZINNScWGQH7bILTJrkLbJ+9Sv44gs4/PDyaf8ikloKNJE6KCiA2bM91H7zG9h5Z3+tVlkiqadbjiJ11KkTDBvmf/76a5g6FTZtirYmkWykQBOpo+JimDIFRo70Z2tFRR5yn30WdWUi2UWBJlIHFVtljR3rtxt32w1efhlOOglWrYq6QpHsoUATqYOqWmXNnAn9+8PHH8Nxx8Ebb0Rbo0i2UOsrkSRZvtxbZW3YAI8/7rchRaTu1PpKJMUOPRRefdXXqnXpsvVaNRFJPAWaSBL99KewaBGceqqvVRszBmJ8U0QkrSnQRJJs991hzhzvKDJ6NAwYAN9+G3VVIplHC6tFUqBBA7/luP/+PhtyzRrv1t+4cdSViWQOjdBEUsTMbzlOnQrPPw95ebBsWdRViWQOBZpIitx8s69bGzDAv3/xhe+C3adP1JWJZAYFmkiK5OX5IuziYl90PWkSbNniu19fdZWeq4nUlQJNJEXy830Rdq9ecP31MHiwTxa5/HK47Tbo0AE++STqKkXSlwJNJIXy8z3Ixo717x07wu23w0MPedeRo4/2tlkiUnspCzQza2Nmd5vZ42Y2OFV/r0icFBfD5MkwapR/Ly724336+CLsnXeG9u3hrrtg/Pjyn1d8vzYPFalajQLNzO43s7VmtqzS8QIze8fMVpjZiG19Rgjh7RDCxUAv4ActS0QyXcVGxmPGlN9+LAutI47wUVrHjnDppT4TsuLPy96flxfdv0Ekzmo6QpsGFFQ8YGb1gLuAzkBb4Bwza2tmh5vZM5W+9vz+PWcAi4EFCfsXiKSJqhoZFxX58TJNmsCsWXDjjbBgga9T69HDn7mVhaE2DxWpWo2bE5tZC+CZEMJh378+HrghhNDp+9fXAIQQbqrBZ80JIXTZ3nlqTizZbO5cvxX59dfw3//6bcoxY6KuSiR6yWhO3Bz4sMLr1d8fq66A9mZ2h5lNAeZu47yBZlZqZqXr1q2rQ3ki6e0Xv4A774TNm/31rbfCc89FW5NInNUl0KyKY9UO90IIC0MIl4cQBoUQ7trGeVNDCLkhhNxmzZrVoTyR9FZcDFdcAc88A5dd5iO1rl3h3nujrkwknuoSaKuB/Sq83hf4qG7liEiZsmduBQVwxx3w7LPe6Pjii3209t13UVcoEi91CbQSoJWZHWhmOwG9gVmJKUtEhg/fegJIQQG8+y4UFsKwYb4Q+8MPq3+/SLap6bT96cArwCFmttrM+ocQNgOXAvOAt4GiEMLyRBRlZoVmNnXjxo2J+DiRjNG0KTz5pN92fO01n+r/6KNRVyUSDzWe5RgFzXIUqd6KFXDeebBkiX9v1Qratdt6VFdc7Lcuhw+Prk6RREvGLEcRiVDLlrB4MdxwA0yfDn/4A3TvroXYkr0UaCJprH593wV78WJo1Ag2boQuXeC667QQW7JPLANNz9BEaue44+CNN6B/f5/e/7vfwZlnKswku8Qy0EIIs0MIAxtrf3qRGtttN+8ssvvuPlq7914fpf3nP1FXJpIasQw0Eam9smdmTz/t0/m7doXHHoODDoL586OuTiT5FGgiGaJi8+M99oDZs33j0C1boFMn6NsX1q8vP//mm7U9jWQWBZpIhqi8EBu8ddaHH3pj40cfhdat4U9/ghB89qO2p5FMEstA06QQkcRp2NC79L/+uq9VO/987zrSokX5nmzankYyQSwDTZNCRBLvsMN8ev+kSfDyy/769ddh0CAYOxYGD1aYSXqLZaCJSHLUq+e7Yf/973DaaTB0KIwfDxddBJMn//CZmkg6UaCJZKH99vPna7vt5l/33QfHHgs9eyrUJH0p0ESyVGkpzJwJ77/v4TZvHmzaBBMnwrffRl2dSO0p0ESyVNmsyD328BB76y046STfUPTII+HPf466QpHaiWWgaZajSOq1aeObiM6aBd98Ax07evus99/3n2vdmsRdLANNsxxFomHmG4guXw433QTPP+9Bd911PitS69YkzmIZaCISrR/9CEaMgHfe8dD63e9gwAAYOFDr1iS+FGgiUq3mzb2zyEsvwT77eLA1bKh1axJPCjQR2a4TToDXXvN1a2vW+LHx4z3sROJCgSYiNfKXv8C0ad70ePRoyMnxNlpnnAEffxx1dSIxDTTNchSJn7Ju/l26wA03wAcfQLduMGcOtGzpDZA//zzqKiWbWQgh6hqqlZubG0pLS6MuQ0S2YcUKGDnSu/k3bep/vvhin1gikgxmtjSEkFv5eCxHaCKSPlq2hBkzvPPIkUd615HWraF3b1iwYOtztW5NkkmBJiIJcfTRvm5t/nxo0sRHbJ06+eSRELRuTZJPgSYiCXX66T5ae+QRaNbM17MdcAB07+4hp6n+kiwKNBFJuJwcOOccWLUKOnf2XbM3bvTZkQsW+IitIrXVkkRQoIlI0rz0ks+OvOYaaNQI/vEP6NABTjkFXnihPNjy8tRWS+pOgSYiSVEWSkVF3mFk1iw/ftllsHKlbzDavj0sXOi3IYuK1FZL6kaBJiJJUbZurSyUykJr33090CZN8in/+fkebDk53k5LbbVkR8VyHZqZFQKFLVu2HPDee+9FXY6IJMmmTXDPPd7Z/+OPoUEDf/Y2d65GaFK96tahxTLQymhhtUh2eO456NHDF2N/9hkceqhPJHnySb81KVKRFlaLSGy99Zb3iFy9Gu68E7780tto9ekDDz0E334bdYWSDhRoIhK54cP99uLOO8Ovfw3vveed/Js2hb594eCD4a674Kuvoq5U4kyBJiKx06ABnHde+cjtpz+FSy+FFi3gt7+FDRuirlDiSIEmIrGVkwNdu/p6tkWLfF3ayJHeeWT4cPjoo6grlDhRoIlIWmjXzreqefNN+NnP4NZb4cADYcAAX7CtziKiQBORtHLkkXDbbd4AuVMnnzTSpg0UFEC9ej9sqyXZQ4EmImknPx8efxxeeQUuuQR22cW/hg6Fo47yCSXffBN1lZJqCjQRSUv5+d5RZOJEGDLEF2bfe68H2fnn++3IceN8XZtkh1gGmpkVmtnUjRs3Rl2KiMRUcTFMngyjRvn3V16B/v1h2TJ49llfnH3NNbDffnDiiX5rsvL79cwts8Qy0EIIs0MIAxs3bhx1KSISQxUbH48ZU97YuLgYzPx52vz58Ne/Qs+esGSJr2dr1w4WL/ZO/+rmn3liGWgiIttSXePjkpKtzzviCJg2zdto9enj0//btfPJJAMHwkknpbx0SSL1chSRrDFiBIwfDz/+sT9ba97ct7MZONBnTUp6UC9HEclqxcVw333+zC0nx/doa93aQ27ffb3l1rvv+rnaQTs9KdBEJONV9cxt4kS47jpfqN2rl8+QbN0aCguhfn3toJ2OFGgikvG29cztyCPhgQdg1SofvS1Z4ssAGjeGbt3g2mu1g3a60DM0EZEKNm2Chx/2biTLl/ux006DJ57wkJPo6RmaiEgNNGzo69nuuMMD7MADYcEC7/g/YoQv4JZ4UqCJiFRSXAxnnw1PPQXvvw933w1btvikkBYtvCHyO+9EXaVUpkATEamk8jO3QYO8+8iwYT56K2uIfNZZ8OqrmhUZF3qGJiJSS2vXwqRJvov2hg2+gPuDD3xEd+qpW8+q1ESSxNMzNBGRBNlzTxg7Fv75T588smEDfP45dOwIv/ylwiwqCjQRkR3UqBFccQWsXAkPPugdSJ580hdub9xY/d5sukWZHAo0EZE6atDAu42E4M/V/vUv6N7dF2LPnfvDYMvL08LtZIhloGn7GBFJJxWfmT3xBDz3HOy2G6xZA126+PY1L7xQfn7Zwu5eveD663WLMlFiGWjaPkZE0knlWZEdOsDMmd74+O67vdv/aaf5zxcv9nPKNigdO9a/K8zqTrMcRUSSbNMmmDrVGyJ/+qlvX9Otm4/OBg/2DUo1Qqs5zXIUEYlIw4Zw+eW+SPuWW3x37UsugYMPhnPP3XqDUtlx9aMuQEQkW+yyCwwdCl9/7evWnngCDj8cfvMbb5BcUqJRWl1ohCYikmKjRvnebO++C/36+VY2AwbA3nvDd99FXV36UqCJiERkzz3hnnt8y5oDDoALLoCTToKlS8vP0Zq1mlOgiYhELC8PXn7ZbzuuXOmvBw6Edeu0Zq02FGgiIjGQk+O3H999F6680sPt4INh2TKYPl1r1mpCgSYiEiONG8OECfDWW5Cb67Mjr7oKOnfWmrXtUaCJiMRQmzYwf773hly7Fv70J2jb1jv8a3p/1RRoIiIxZQZ77OGbi/br58/XNm+GM89UqFVFgSYiEmNlbbUeeABefx1atfKtaoYM8W1rpJwCTUQkxoYPL39m1ratdxm54Qb42998Ufa8eVufn83T/BVoIiJppEEDGD0aXn3VJ5AUFPhEkS+/9J9n8zR/BZqISBo6+mhfgD1kCEyZAkce6Z38s3lrGgWaiEiaatgQbr0VFi70TURPPhmGDYPjj8/OrWkUaCIiae7kk33d2sCBHnBt2sCkSd4zcvLk7JkRqUATEckAjRr5ZqLjxsE//+kzIRs0KO8ykg2hpkATEckgZvDUU9C7tz9DmzDBO/uXlERdWfJpPzQRkQwyfLh/Lyz0W5GXXeb9IZ96Ktq6UkEjNBGRDGQGgwbBokWwaRMcd5zffsxkKQ00M9vVzJaaWddU/r0iItnquON8en9uLpx7rjc6/vbbqKtKjhoFmpndb2ZrzWxZpeMFZvaOma0wsxE1+KirgaIdKVRERHbM3nvDggXeuf+22+D00+HTT/1nmdRZpKYjtGlAQcUDZlYPuAvoDLQFzjGztmZ2uJk9U+lrTzPrAPwd+DSB9YuISA00aAC33+5d+5cs8YXZr72WWZ1FajQpJISwyMxaVDp8DLAihPA+gJnNALqFEG4CfnBL0czygV3x8PvazOaGEL6rQ+0iIlJL550Hhx4KZ50F7dr5djRlnUUGD/Z1a+naWaQusxybAx9WeL0aOLa6k0MI1wGYWT9gfXVhZmYDgYEA+++/fx3KExGRqvz851Ba6s/UBgwo/xo71hdjp2OYQd0Czao4Frb3phDCtO38fCowFSA3N3e7nyciIrX3k5/A3LkeYDfdBPXrw29+4yO0/Pz0DLW6zHJcDexX4fW+wEd1K0dERFKlXj2fILL77h5oRUUebunaWaQugVYCtDKzA81sJ6A3MCsxZYmISCqUlMDTT/v3nBwYOhSuuy49O4vUdNr+dOAV4BAzW21m/UMIm4FLgXnA20BRCGF5Iooys0Izm7px48ZEfJyIiFSjbAPRww6Dl1/2Kf4jRsAhh0RdWe1ZCPF9TJWbmxtKS0ujLkNEJGusXw9du/oIbcoUuOiiqCv6ITNbGkLIrXxcra9EROT/NW3qi7A7dvSZj7/7ne+1lg4UaCIispVdd4VZs6BPH3+edsUV8F0arBqOZbd9MysEClu2bBl1KSIiWalBA3jwQdhzT2+XtW4dTJsGO+0UdWXVi+UILYQwO4QwsHHjxlGXIiKStXJyfD+1ceO8U39hoS++jmvvx1gGmoiIxIMZXH013H+/P1t7+GHo2TOevR8VaCIisl0XXuibhK5aBTvvDD16+I7YvXrFp/ejAk1ERLDQF5oAAAVZSURBVGqksBCefx6+/BK++cZvPw4eHI8wg5gGmhZWi4jE04kn+nO1r76CXXaBO++MT5usWAaaJoWIiMRTcbE/U5s2DRo39mdsv/xlPEItloEmIiLxVFLiz8z69vXbjzk53th43ryoK1OgiYhILZT1fgRo29ZDbfNmeOwxWL062toUaCIissOOPNJHZ+vXw2mnwSefRFeLAk1EROokL883C12zBjp08HCLQiwDTbMcRUTSy4knwuzZsHKlNzbesMGP33xz6jqLxDLQNMtRRCT95Of74uvly6FzZ/jiCx+9VdwBO5mdRWIZaCIikp4KCnwW5NKl0KULHHOMv+7VK/mdRRRoIiKSUN26ec/Hl16CM8+E44/3jiLJ7iwSy+1jREQkvfXqBZs2Qb9+0L69P1sbNQomT/ZA0whNRETSxvnnw5VXwpIl0KaN33Isu/2YjM4iCjQREUmavfaCSy+FF1+EESN8ZFZU5B1HEs1CCIn/1DqqsGP1gPfeey/qckREpI7uucdnPu67b90/y8yWhhByf3A8joFWJjc3N5SWlkZdhoiIxEh1gaZbjiIikhEUaCIikhEUaCIikhEUaCIikhEUaCIikhEUaCIikhFiGWjaPkZERGorloGm7WNERKS2YhloIiIitaVAExGRjBDr1ldmtg5YVcWPGgNVPWCr7nhTYH0CS6uL6mqM6jNr896anru987b189pc2zhdV4jXta3t+2pyvq5rPD4z0b+zqbqukLhre0AIodkPjoYQ0u4LmFrL46VR17y9GqP6zNq8t6bnbu+8bf28Ntc2Ttc1bte2tu+ryfm6rvH4zET/zqbquqbi2qbrLcfZtTweJ8mosS6fWZv31vTc7Z23rZ/r2ibmM2v7vpqcr+saj89M9O9sxlzXWN9yTBQzKw1VdGaW9Kbrmpl0XTNXsq9tuo7Qamtq1AVIUui6ZiZd18yV1GubFSM0ERHJfNkyQhMRkQynQBMRkYygQBMRkYyQ1YFmZu3N7EUzu9vM2kddjySWme1qZkvNrGvUtUhimFmb739fHzezwVHXI4ljZmea2T1mNtPMOu7IZ6RtoJnZ/Wa21syWVTpeYGbvmNkKMxuxnY8JwJdAQ2B1smqV2knQtQW4GihKTpVSW4m4riGEt0MIFwO9AE3tj4kEXdunQwgDgH7A2TtUR7rOcjSzk/EwejCEcNj3x+oB7wKn4wFVApwD1ANuqvQRvwLWhxC+M7O9gIkhhD6pql+ql6BrewTeZqchfp2fSU31Up1EXNcQwlozOwMYAdwZQngkVfVL9RJ1bb9/3wTg4RDC67Wto/4O/wsiFkJYZGYtKh0+BlgRQngfwMxmAN1CCDcB27rttAH4UTLqlNpLxLU1s3xgV6At8LWZzQ0hfJfUwmWbEvU7G0KYBcwyszmAAi0GEvQ7a8A44NkdCTNI40CrRnPgwwqvVwPHVneymZ0FdAL2AO5MbmlSR7W6tiGE6wDMrB/fj8STWp3sqNr+zrYHzsL/D+jcpFYmdVWrawtcBnQAGptZyxDC3bX9CzMt0KyKY9XeUw0hPAk8mbxyJIFqdW3//4QQpiW+FEmg2v7OLgQWJqsYSajaXts7gDvq8hem7aSQaqwG9qvwel/go4hqkcTStc1Muq6ZK+XXNtMCrQRoZWYHmtlOQG9gVsQ1SWLo2mYmXdfMlfJrm7aBZmbTgVeAQ8xstZn1DyFsBi4F5gFvA0UhhOVR1im1p2ubmXRdM1dcrm3aTtsXERGpKG1HaCIiIhUp0EREJCMo0EREJCMo0EREJCMo0EREJCMo0EREJCMo0EREJCMo0EREJCMo0EREJCP8H5nFSTc4CQ1sAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1,1, figsize = (7,5))\n", + "axes.plot(times, -invProb.dpred, 'b-')\n", + "axes.plot(times, -d_obs, 'bx')\n", + "axes.set_xscale('log');\n", + "axes.set_yscale('log');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/examples/EM1D_TD_FWD.ipynb b/notebooks/examples/EM1D_TD_FWD.ipynb deleted file mode 100644 index 9fd3394..0000000 --- a/notebooks/examples/EM1D_TD_FWD.ipynb +++ /dev/null @@ -1,308 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - } - ], - "source": [ - "from SimPEG import *\n", - "from simpegEM1D import (\n", - " EM1D, EM1DSurveyTD, Utils1D, get_vertical_discretization_time, \n", - " set_mesh_1d, skytem_HM_2015\n", - ")\n", - "import numpy as np\n", - "%pylab inline" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from simpegEM1D import skytem_HM_2015\n", - "time = np.logspace(-5, -2, 31)\n", - "# three layers\n", - "hz = np.array([10, 10, 10])\n", - "sigma_half = 0.1\n", - "\n", - "# half-space conductivity\n", - "sigma = np.ones(hz.size) * sigma_half\n", - "mesh1D = set_mesh_1d(hz)\n", - "depth = -mesh1D.gridN[:-1]\n", - "# offset b/w VMD source and Bz receiver\n", - "offset = np.array([10.])\n", - "\n", - "LocSigZ = -mesh1D.gridCC\n", - "TDsurvey = EM1DSurveyTD(\n", - " rx_location = np.array([0., 0., 100.]),\n", - " src_location = np.array([0., 0., 100.]),\n", - " topo = np.r_[0., 0., 100.],\n", - " depth = depth,\n", - " rx_type = 'Bz',\n", - " wave_type = 'stepoff',\n", - " src_type = 'VMD',\n", - " offset=offset,\n", - " time = time,\n", - ")\n", - "imap = Maps.IdentityMap(mesh1D)\n", - "prob = EM1D(mesh1D, sigmaMap=imap, verbose=False)\n", - "prob.pair(TDsurvey)\n", - "bz = TDsurvey.dpred(sigma)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "from simpegEM1D import EM1DAnalytics\n", - "from simpegEM1D.DigFilter import setFrequency, transFilt\n", - "from scipy.constants import mu_0\n", - "def bz_analytic_solution(r, t, sigma):\n", - " \"\"\"\n", - " r: offset bewteen VMD soure and Bz receiver (m)\n", - " t: measured times\n", - " sigma: conductivity of the half-space earth\n", - " \"\"\"\n", - " wt, tbase, omega_int = setFrequency(t)\n", - " hz = EM1DAnalytics.Hzanal(sigma, omega_int/2/np.pi, r, 'secondary')\n", - " # Treatment for inaccuracy in analytic solutions\n", - " ind = omega_int < 0.2\n", - " hz[ind] = 0.\n", - " hzTD, f0 = transFilt(hz, wt, tbase, omega_int, t)\n", - " return hzTD*mu_0" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "bz_analytic = bz_analytic_solution(offset, time, sigma_half)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = subplots(1,1, figsize = (7,5))\n", - "axes.plot(TDsurvey.time, bz_analytic, '-')\n", - "axes.plot(TDsurvey.time, bz, 'o')\n", - "axes.set_xscale('log')\n", - "axes.set_yscale('log')\n", - "axes.set_xlabel('Time (s)')\n", - "axes.set_ylabel('Bz (T)')\n", - "axes.legend((\"Analytic\", \"simpegEM1D\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1385.6406460551018" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import numpy as np\n", - "400 * np.sqrt(3) * 2" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from PVGeo.gslib import SGeMSGridReader\n", - "from pyvista import examples" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "from PVGeo.gslib import WriteImageDataToSGeMS" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "WriteImageDataToSGeMS??" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "filename, _ = examples.downloads._download_file('A_WLreferenceCAT.sgems')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'C:\\\\Users\\\\sgkan\\\\AppData\\\\Local\\\\pyvista\\\\pyvista\\\\examples\\\\A_WLreferenceCAT.sgems'" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "filename" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "UniformGrid (0x1fdb421aac8)\n", - " N Cells:\t78000\n", - " N Points:\t157122\n", - " X Bounds:\t0.000e+00, 2.600e+02\n", - " Y Bounds:\t0.000e+00, 3.000e+02\n", - " Z Bounds:\t0.000e+00, 1.000e+00\n", - " Dimensions:\t261, 301, 2\n", - " Spacing:\t1.000e+00, 1.000e+00, 1.000e+00\n", - " N Arrays:\t1\n", - "\n" - ] - } - ], - "source": [ - "grid = SGeMSGridReader().apply(filename)\n", - "print(grid)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "grid?" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "warped = grid.cell_data_to_point_data().warp_by_scalar(scale_factor=5)\n", - "warped.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/notebooks/examples/EM1D_fwd.ipynb b/notebooks/examples/EM1D_fwd.ipynb index 47e3042..b1c2a70 100644 --- a/notebooks/examples/EM1D_fwd.ipynb +++ b/notebooks/examples/EM1D_fwd.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 80, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -11,20 +11,14 @@ "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/srv/conda/lib/python3.6/site-packages/IPython/core/magics/pylab.py:160: UserWarning: pylab import has clobbered these variables: ['pi']\n", - "`%matplotlib` prevents importing * from pylab and numpy\n", - " \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n" - ] } ], "source": [ - "from SimPEG import Mesh, Maps\n", - "from simpegEM1D import *\n", + "from discretize import TensorMesh\n", + "from SimPEG import maps\n", + "from simpegEM1D.simulation_original import EM1DFMSimulation\n", + "from simpegEM1D.survey_original import EM1DSurveyFD\n", + "from simpegEM1D import analytics\n", "import numpy as np\n", "import matplotlib\n", "%pylab inline" @@ -46,14 +40,14 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "nearthick = np.logspace(-1, 1, 5)\n", "deepthick = np.logspace(1, 2, 10)\n", "hx = np.r_[nearthick, deepthick]\n", - "mesh1D = Mesh.TensorMesh([hx], [0.])\n", + "mesh1D = TensorMesh([hx], [0.])\n", "depth = -mesh1D.gridN[:-1]\n", "LocSigZ = -mesh1D.gridCC\n", "nlay = depth.size\n", @@ -69,9 +63,33 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(61,)\n", + "[1.00000000e-02 1.46779927e-02 2.15443469e-02 3.16227766e-02\n", + " 4.64158883e-02 6.81292069e-02 1.00000000e-01 1.46779927e-01\n", + " 2.15443469e-01 3.16227766e-01 4.64158883e-01 6.81292069e-01\n", + " 1.00000000e+00 1.46779927e+00 2.15443469e+00 3.16227766e+00\n", + " 4.64158883e+00 6.81292069e+00 1.00000000e+01 1.46779927e+01\n", + " 2.15443469e+01 3.16227766e+01 4.64158883e+01 6.81292069e+01\n", + " 1.00000000e+02 1.46779927e+02 2.15443469e+02 3.16227766e+02\n", + " 4.64158883e+02 6.81292069e+02 1.00000000e+03 1.46779927e+03\n", + " 2.15443469e+03 3.16227766e+03 4.64158883e+03 6.81292069e+03\n", + " 1.00000000e+04 1.46779927e+04 2.15443469e+04 3.16227766e+04\n", + " 4.64158883e+04 6.81292069e+04 1.00000000e+05 1.46779927e+05\n", + " 2.15443469e+05 3.16227766e+05 4.64158883e+05 6.81292069e+05\n", + " 1.00000000e+06 1.46779927e+06 2.15443469e+06 3.16227766e+06\n", + " 4.64158883e+06 6.81292069e+06 1.00000000e+07 1.46779927e+07\n", + " 2.15443469e+07 3.16227766e+07 4.64158883e+07 6.81292069e+07\n", + " 1.00000000e+08]\n" + ] + } + ], "source": [ "FDsurvey = EM1DSurveyFD(\n", " rx_location = np.array([0., 0., 0.]),\n", @@ -84,8 +102,25 @@ " frequency = np.logspace(-2, 8, 61),\n", " offset = 8. * np.ones(61),\n", " a = 1.,\n", - " I=1.\n", - ")" + " I = 1.\n", + ")\n", + "\n", + "Colesurvey = EM1DSurveyFD(\n", + " rx_location = np.array([0., 0., 0.]),\n", + " src_location = np.array([0., 0., 0.]),\n", + " field_type = 'secondary',\n", + " rx_type = 'Hz',\n", + " src_type = 'VMD',\n", + " depth = depth,\n", + " topo = topo,\n", + " frequency = np.logspace(-2, 8, 61),\n", + " offset = 8. * np.ones(61),\n", + " a = 1.,\n", + " I = 1.\n", + ")\n", + "\n", + "print(np.shape(FDsurvey.frequency))\n", + "print(FDsurvey.frequency)" ] }, { @@ -132,13 +167,13 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "sig_half = 1e-2\n", "chi_half = 0.\n", - "Expmap = Maps.ExpMap(mesh1D)\n", + "Expmap = maps.ExpMap(mesh1D)\n", "tau = np.ones(nlay, dtype=float)*1e-1\n", "eta = np.ones(nlay, dtype=float)*0.5\n", "c = np.ones(nlay, dtype=float)*0.88" @@ -146,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -155,56 +190,84 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Conductivity\n", - "prob = EM1D(\n", - " mesh1D, sigmaMap=Expmap,\n", - " chi=np.zeros(FDsurvey.n_layer)\n", + "simFD = EM1DFMSimulation(\n", + " mesh1D, survey=FDsurvey, sigmaMap=Expmap,\n", + " chi=np.zeros(nlay)\n", ")\n", - "if prob.ispaired:\n", - " prob.unpair()\n", - "if FDsurvey.ispaired:\n", - " FDsurvey.unpair()\n", - "prob.pair(FDsurvey)\n", - "Hz = FDsurvey.dpred(m_1D)" + "\n", + "# Hz = simFD.dpred(m_1D)\n", + "Hz = simFD.fields(m_1D)\n", + "# print(np.shape(Hz))\n", + "# print(Hz)" ] }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(61,)\n", + "[ 5.53757290e-15-9.82263144e-13j 1.13879984e-14-1.44243389e-12j\n", + " 2.33869700e-14-2.11861458e-12j 4.80265611e-14-3.11270526e-12j\n", + " 9.85321185e-14-4.57529619e-12j 2.01925484e-13-6.72974845e-12j\n", + " 4.13070866e-13-9.90931818e-12j 8.42699459e-13-1.46159963e-11j\n", + " 1.71187054e-12-2.16175922e-11j 3.45402835e-12-3.21164614e-11j\n", + " 6.89324945e-12-4.80592236e-11j 1.35141956e-11-7.27264954e-11j\n", + " 2.57469873e-11-1.11841532e-10j 4.69381200e-11-1.75456456e-10j\n", + " 8.03625965e-11-2.80588017e-10j 1.26323796e-10-4.53489970e-10j\n", + " 1.80484076e-10-7.29084498e-10j 2.34605771e-10-1.15219144e-09j\n", + " 2.81668418e-10-1.78240651e-09j 3.17628539e-10-2.70633190e-09j\n", + " 3.40249353e-10-4.05412480e-09j 3.46382970e-10-6.01972956e-09j\n", + " 3.29112985e-10-8.88867071e-09j 2.74424515e-10-1.30783931e-08j\n", + " 1.56052188e-10-1.91970525e-08j -7.34649201e-11-2.81285629e-08j\n", + " -4.98587742e-10-4.11547143e-08j -1.26861497e-09-6.01292914e-08j\n", + " -2.64647850e-09-8.77243958e-08j -5.09387832e-09-1.27775521e-07j\n", + " -9.41909607e-09-1.85758825e-07j -1.70321780e-08-2.69439907e-07j\n", + " -3.03824285e-08-3.89734624e-07j -5.37019594e-08-5.61811467e-07j\n", + " -9.42554839e-08-8.06426882e-07j -1.64411243e-07-1.15139217e-06j\n", + " -2.85008894e-07-1.63287394e-06j -4.90700650e-07-2.29584692e-06j\n", + " -8.38131544e-07-3.19231789e-06j -1.41784724e-06-4.37473857e-06j\n", + " -2.37029252e-06-5.88011751e-06j -3.90438704e-06-7.69763704e-06j\n", + " -6.31245224e-06-9.70951271e-06j -9.96542029e-06-1.15932852e-05j\n", + " -1.52548159e-05-1.26788492e-05j -2.24233543e-05-1.17762397e-05j\n", + " -3.12057216e-05-7.04845415e-06j -4.02242882e-05+3.88574150e-06j\n", + " -4.62353997e-05+2.32904563e-05j -4.37086455e-05+5.17274855e-05j\n", + " -2.58114013e-05+8.56121270e-05j 1.19221248e-05+1.15323983e-04j\n", + " 6.56055912e-05+1.27189320e-04j 1.19607430e-04+1.12212552e-04j\n", + " 1.54009937e-04+7.71012871e-05j 1.62201883e-04+4.27991566e-05j\n", + " 1.57646011e-04+2.42228164e-05j 1.55099671e-04+1.69490808e-05j\n", + " 1.55346214e-04+1.20096993e-05j 1.55438184e-04+8.12727655e-06j\n", + " 1.55423867e-04+5.53589397e-06j]\n" + ] + } + ], "source": [ "# Frequency-dependent conductivity\n", - "probcole = EM1D(\n", - " mesh1D, sigmaMap=Expmap,\n", + "simCole = EM1DFMSimulation(\n", + " mesh1D, survey=Colesurvey, sigmaMap=Expmap,\n", " eta=eta, tau=tau, c=c,\n", - " chi=np.zeros(FDsurvey.n_layer)\n", + " chi=np.zeros(nlay)\n", ")\n", - "if probcole.ispaired:\n", - " probcole.unpair()\n", - "if FDsurvey.ispaired:\n", - " FDsurvey.unpair()\n", - "probcole.pair(FDsurvey)\n", - "HzCole = FDsurvey.dpred(m_1D)\n", - "Hzanal = EM1DAnalytics.Hzanal(sig_half, FDsurvey.frequency, FDsurvey.offset, 'secondary')" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [], - "source": [ - "Hz_r = Hz.reshape((2, 61))[0,:]" + "\n", + "# HzCole = simCole.dpred(m_1D)\n", + "HzCole = simCole.fields(m_1D)\n", + "Hzanal = analytics.Hzanal(sig_half, FDsurvey.frequency, FDsurvey.offset, 'secondary')\n", + "print(np.shape(HzCole))\n", + "print(HzCole)" ] }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -213,73 +276,91 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 91, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1,1, figsize = (8, 5))\n", - "ax.loglog(FDsurvey.frequency, abs(Hz[:FDsurvey.n_frequency]), 'b-')\n", - "ax.loglog(FDsurvey.frequency, abs(Hzanal.real), 'bx')\n", - "ax.loglog(FDsurvey.frequency, abs(Hz[FDsurvey.n_frequency:]), 'r-')\n", - "ax.loglog(FDsurvey.frequency, abs(Hzanal.imag), 'rx')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.real(Hz)), 'b-')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.real(Hzanal)), 'bx')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.imag(Hz)), 'r-')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.imag(Hzanal)), 'rx')\n", "legend(('Real $H_{z}$', 'Real $H_{z \\ true}$', 'Imag $H_{z}$', 'Imag $H_{z \\ true}$'))" ] }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 93, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1,1, figsize = (8, 5))\n", - "ax.loglog(FDsurvey.frequency, abs(Hz[:FDsurvey.n_frequency]), 'b-')\n", - "ax.loglog(FDsurvey.frequency, abs(HzCole[:FDsurvey.n_frequency]), 'bx')\n", - "ax.loglog(FDsurvey.frequency, abs(Hz[FDsurvey.n_frequency:]), 'r-')\n", - "ax.loglog(FDsurvey.frequency, abs(HzCole[FDsurvey.n_frequency:]), 'rx')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.real(HzCole)), 'b-')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.real(Hzanal)), 'bx')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.imag(HzCole)), 'r-')\n", + "ax.loglog(FDsurvey.frequency, np.abs(np.imag(Hzanal)), 'rx')\n", "legend(('Real $H_{z}$', 'Real $H_{z \\ IP}$', 'Imag $H_{z}$', 'Imag $H_{z \\ IP}$'))" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -298,7 +379,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/EM1D_inversion_FD_height_correction.ipynb b/notebooks/examples/EM1D_inversion_FD_height_correction.ipynb index 57872bd..722d860 100644 --- a/notebooks/examples/EM1D_inversion_FD_height_correction.ipynb +++ b/notebooks/examples/EM1D_inversion_FD_height_correction.ipynb @@ -16,7 +16,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/sgkang/anaconda3/lib/python3.6/site-packages/IPython/core/magics/pylab.py:160: UserWarning: pylab import has clobbered these variables: ['pi', 'erf']\n", + "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\IPython\\core\\magics\\pylab.py:160: UserWarning: pylab import has clobbered these variables: ['pi']\n", "`%matplotlib` prevents importing * from pylab and numpy\n", " \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n" ] @@ -24,6 +24,7 @@ ], "source": [ "from SimPEG import *\n", + "from discretize import TensorMesh\n", "from simpegEM1D import *\n", "from scipy.constants import mu_0\n", "import numpy as np\n", @@ -51,8 +52,8 @@ ")\n", "\n", "chi_half = 0.\n", - "wires = Maps.Wires(('sigma', mesh1D.nC),('h', 1))\n", - "expmap = Maps.ExpMap(mesh1D)\n", + "wires = maps.Wires(('sigma', mesh1D.nC),('h', 1))\n", + "expmap = maps.ExpMap(mesh1D)\n", "# expmap_h = Maps.ExpMap(nP=1)\n", "sigmaMap = expmap * wires.sigma\n", "# hMap = expmap_h*wires.h\n", @@ -74,7 +75,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 2, @@ -83,7 +84,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -105,19 +106,15 @@ "metadata": {}, "outputs": [], "source": [ - "prob = EM1D(\n", - " mesh1D, sigmaMap=sigmaMap, hMap=wires.h,\n", + "sim = EM1DFMSimulation(\n", + " mesh1D, survey=FDsurvey, sigmaMap=sigmaMap, hMap=wires.h,\n", " chi= np.zeros(FDsurvey.n_layer)\n", ")\n", - "if prob.ispaired:\n", - " prob.unpair()\n", - "if FDsurvey.ispaired:\n", - " FDsurvey.unpair()\n", - "prob.pair(FDsurvey) \n", - "d_true = FDsurvey.dpred(m_true)\n", + " \n", + "d_true = sim.dpred(m_true)\n", "# d_p = FDsurvey.dpred(m_dx_p)\n", "# d_n = FDsurvey.dpred(m_dx_n)\n", - "d_dh = FDsurvey.dpred(m_true_dh)\n", + "d_dh = sim.dpred(m_true_dh)\n", "# J_h_diff = (d_p-d_n) / (dh)\n", "# plt.plot(J_h_diff, 'k')\n", "# plt.plot(prob.getJ_height(m_true), 'bx')" @@ -130,7 +127,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbUAAAEzCAYAAAC2Q50YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deXgUVb7G8e8hbIqyCFxRQQVlQEQWTVRUMIHIJltQIxA2RZEA4zKDI3IJO4xmBh0XzAXFAUGEoERBUSTQAYQoCQ6gCCrDrsgii6AsWc79ozokQMhGkup03s/z9JPuU9Xdvw5Fv6lTp04Zay0iIiL+oIzbBYiIiBQWhZqIiPgNhZqIiPgNhZqIiPgNhZqIiPgNhZqIiPiNsrmtYIypCKwEKnjXf99aO9oYMwO4FzjqXbW/tXa9McYArwAdgT+87V97X6sfMNK7/gRr7cyc3rtGjRr2+uuvz/eHEhER/7Vu3bqD1tqa2S3LNdSAU0Bra+1xY0w54AtjzKfeZc9aa98/Z/0OQH3v7Q4gBrjDGHMFMBoIBCywzhiz0Fp7+EJvfP3115OcnJyHEkVEpLQwxuy80LJcux+t47j3YTnvLacztrsC73if9yVQ1RhzFdAOWGqtPeQNsqVA+7x+CBERkdzk6ZiaMSbAGLMe2I8TTF95F000xmw0xrxsjKngbbsG2J3l6Xu8bRdqP/e9Bhpjko0xyQcOHMjnxxERkdIsT6FmrU2z1jYDagO3G2MaA88DDYEg4ArgOe/qJruXyKH93PeaZq0NtNYG1qyZbZepiIhItvI1+tFaewRIANpba/d6uxhPAf8Gbveutgeok+VptYGfc2gXEREpFLmGmjGmpjGmqvf+JUAosMV7nAzvaMduwLfepywE+hrHncBRa+1eYAnQ1hhTzRhTDWjrbRMRESkUeRn9eBUw0xgTgBOCsdbaj40xy40xNXG6FdcDg7zrL8YZzr8VZ0j/IwDW2kPGmPFAkne9cdbaQ4X3UUREpLQzvnzpmcDAQKsh/SIikpUxZp21NjC7ZZpRRERE/IZCTURE/IZCTUREityqVasYOHAgiYmJRfo+CjURESlS8+fPJzg4mDfffJPWrVsXabAp1EREpEhYa5kxYwa9e/cmPT0dgJSUFBISEorsPRVqIiJS6A4fPkyPHj145JFHaNSoERUrViQgIIDy5csTHBxcZO+bl/PURERE8mzlypX07t2bvXv3MmnSJP72t7+xdu1aEhISCA4OpkWLFkX23go1EREpFCkpKYwdO5a///3v1KtXjzVr1hAUFARAixYtijTMMijURETkov33v/8lIiKCr776ikceeYRXX32Vyy67rNjrUKiJiEiBWWt55513GDp0KGXLliU2NpaHHnrItXo0UERERArkyJEj9OzZk/79+3PrrbeyYcMGVwMNFGoiIlIAq1atomnTprz//vtMnDiR5cuXc+2117pdlkJNRETyLiUlhaioKIKDgylXrhxr1qxhxIgRBAQEuF0aoGNqIiKSR1kHg/Tv359XX32Vyy+/3O2yzqJQExGRHFlrmTVrFkOGDCEgIIB58+YRHh7udlnZUvejiIhc0JEjR+jVqxf9+vWjefPmbNy40WcDDRRqIiJyARmDQebPn8+ECRPweDw+MRgkJwo1ERE5S2pqKqNGjSI4OJiyZcuyevVq/vd//9dnBoPkRMfURETkjG3bthEREcGXX35Jv379eO2113xuMEhOFGoiIoK1ltmzZzNkyBDKlCnD3Llzefjhh90uK9/U/SgiUsodPXqUiIgI+vbtS7NmzdiwYUOJDDRQqImIlGqrV6+madOmxMbGMn78eDweD9ddd53bZRWYQk1EpBRKTU1l9OjRtGrVioCAAL744gtGjhxZIgaD5ETH1ERESplzB4O8+uqrVK5c2e2yCoVCTUSkFJk9ezaDBw8u0YNBcqLuRxGRUiBjMEifPn1o2rRpiR4MkhOFmoiIn1u9ejXNmjVj3rx5jB8/noSEhBI9GCQnCjURET+VmprKmDFjaNWqFcYYvxkMkhMdUxMR8UPbt2+nd+/erFmzhj59+vD666/7zWCQnCjURET8zLvvvsvgwYMxxjBnzhx69uzpdknFRt2PIiJ+ImMwSO/evWnSpAkbNmwoVYEGeQg1Y0xFY8xaY8wGY8wmY8xYb3tdY8xXxpgfjTHzjDHlve0VvI+3epdfn+W1nve2f2+MaVdUH0pEpLRZs2bNmcEg48aNK/EzgxRUXvbUTgGtrbVNgWZAe2PMncCLwMvW2vrAYWCAd/0BwGFr7Y3Ay971MMY0AnoANwPtgTeMMf57tFJEpBhkDAZp2bIlxhhWrVpFVFQUZcuWzqNLuYaadRz3PiznvVmgNfC+t30m0M17v6v3Md7lbYwxxts+11p7ylq7HdgK3F4on0JEpBTasWMH9957L2PHjiUiIoL169fTokULt8tyVZ6OqRljAowx64H9wFLgv8ARa22qd5U9wDXe+9cAuwG8y48C1bO2Z/OcrO810BiTbIxJPnDgQP4/kYhIKTBnzhyaNm3Kt99+y5w5c3jnnXdKxejG3OQp1Ky1adbaZkBtnL2rm7JbzfvTXGDZhdrPfa9p1tpAa21gzZo181KeiEip8dtvv9GnTx8iIiK45ZZbSuVgkJzka/SjtfYIkADcCVQ1xmR02tYGfvbe3wPUAfAurwIcytqezXNERCQXGYNB3nvvPcaOHUtCQgLXX3+922X5lLyMfqxpjKnqvX8JEApsBjzAg97V+gEfee8v9D7Gu3y5tdZ623t4R0fWBeoDawvrg4iI+KvU1FTGjh1Lq1atAFi1ahWjRo0qtYNBcpKX38hVwEzvSMUyQKy19mNjzHfAXGPMBOA/wHTv+tOBWcaYrTh7aD0ArLWbjDGxwHdAKjDEWptWuB9HRMS/7Nixg969e7N69Wp69+7NlClTdOwsB8bZifJNgYGBNjk52e0yRERcMWfOHCIjIwGIiYmhV69eLlfkG4wx66y1gdkt04wiIiI+JutgkMaNG7N+/XoFWh4p1EREfEhiYiLNmjVjzpw5jBkzhhUrVlC3bl23yyoxFGoiIj4gLS2N8ePH07JlS6y1rFq1itGjR2swSD7ptyUi4rIdO3bQp08fvvjiCyIiIpgyZQpVqlRxu6wSSaEmIuKi9957j0GDBmGtZfbs2URERLhdUomm7kcRERf89ttv9O3bl169enHzzTezYcMGBVohUKiJiBSzL7/8kubNm/Puu+8yevRoVq5cqcEghUShJiJSTDIGg9xzzz2kp6ezcuVKxowZo8EghUi/SRGRYrBz50569+6twSBFTKEmIlLE5s6dy6BBg0hPT2fWrFn07t3b7ZL8lrofRUSKyLFjx+jXrx89e/akUaNGrF+/XoFWxBRqIiJF4KuvvqJZs2bMnj2bUaNGsXLlSurVq+d2WX5PoSYiUojS0tKYMGECd999N2lpaaxcuZKxY8dqMEgx0W9ZRKSQ7Nq1i969e7Nq1Sp69erFG2+8ocEgxUyhJiJSCObNm8cTTzyhwSAuU/ejiMhFOHbsGP3796dHjx7cdNNNGgziMoWaiEgBrV27lubNmzNr1ixGjRrFqlWrNBjEZQo1EZF8SktLY+LEidx1112kpKSwYsUKDQbxEQo1EZF8iIuL48Ybb2TkyJGEh4ezYcMG7rnnHrfLEi/9WSEikkfz5s2jR48eAJQvX56hQ4dStWpVl6uSrLSnJiKSBzt37uSJJ5448zgtLY0VK1a4WJFkR6EmIpKLvXv30qZNG9LS0qhQoQIBAQGUL1+e4OBgt0uTc6j7UUQkBwcPHiQ0NJRffvmF+Ph4rLUkJCQQHBxMixYt3C5PzqFQExG5gKNHj9KuXTu2bdvG4sWLufPOOwEUZj5MoSYiko3ff/+d+++/n40bN/Lhhx8SEhLidkmSBwo1EZFznDx5km7dupGYmMjcuXO5//773S5J8kihJiKSRUpKCg8//DDx8fHMmDGDhx56yO2SJB80+lFExCstLY2+ffuycOFCXn/9dfr16+d2SZJPCjUREcBay6BBg5g7dy4vvPACQ4YMcbskKQCFmoiUetZannnmGd566y1GjhzJc88953ZJUkAKNREp9UaNGsUrr7zCU089xbhx49wuRy5CrqFmjKljjPEYYzYbYzYZY57yto8xxvxkjFnvvXXM8pznjTFbjTHfG2PaZWlv723baowZXjQfSUQk71588UUmTJjAY489xssvv4wxxu2S5CLkZfRjKvBXa+3XxpjLgXXGmKXeZS9ba/+ZdWVjTCOgB3AzcDUQb4z5k3fxFOA+YA+QZIxZaK39rjA+iIhIfk2ZMoXhw4fTs2dP/u///k+B5gdyDTVr7V5gr/f+MWPMZuCaHJ7SFZhrrT0FbDfGbAVu9y7baq3dBmCMmetdV6EmIsVu5syZDB06lC5dujBz5kwCAgLcLkkKQb6OqRljrgeaA195m4YaYzYaY942xlTztl0D7M7ytD3etgu1n/seA40xycaY5AMHDuSnPBGRPJk/fz6PPvoooaGhzJs3j3LlyrldkhSSPIeaMeYy4APgaWvtb0AMcAPQDGdPbnLGqtk83ebQfnaDtdOstYHW2sCaNWvmtTwRkTxZvHgxvXr1okWLFnz44YdUrFjR7ZKkEOVpRhFjTDmcQHvXWrsAwFq7L8vyN4GPvQ/3AHWyPL028LP3/oXaRUSKnMfj4YEHHqBJkyZ88sknVKpUye2SpJDlZfSjAaYDm621L2VpvyrLamHAt977C4EexpgKxpi6QH1gLZAE1DfG1DXGlMcZTLKwcD6GiEjOvvzySzp37ky9evVYsmQJVapUcbskKQJ52VO7G+gDfGOMWe9tGwH0NMY0w+lC3AE8AWCt3WSMicUZAJIKDLHWpgEYY4YCS4AA4G1r7aZC/CwiItlav349HTp0oFatWsTHx1OjRg23S5IiYqw977CWzwgMDLTJyclulyEiJdiWLVto1aoVFStWZNWqVVx33XVulyQXyRizzlobmN0yzSgiIn5r27ZttGnThjJlyhAfH69AKwV06RkR8Us//fQToaGhnDhxghUrVvCnP/0p9ydJiadQExG/s3//fkJDQzl48CDLli3jlltucbskKSYKNRHxK4cPH6Zdu3bs3LmTzz77jKCgILdLkmKkUBMRv3Hs2DE6duzId999x8KFC2nVqpXbJUkxU6iJiF84ceIEXbt2JSkpifnz59OuXbvcnyR+R6EmIiXe6dOnefDBB0lISGDWrFmEhYW5XZK4RKEmIiVaamoqvXv3ZvHixUydOpWIiAi3SxIX6Tw1ESmx0tPTefzxx5k/fz6TJ09m4MCBbpckLlOoiUiJZK3lySefZMaMGYwZM4a//OUvbpckPkChJiIljrWW559/nilTpjBs2DBGjRrldkniIxRqIlLiTJo0iRdffJFBgwYRHR2NczEREYWaiJQwr7zyCiNHjqRPnz5MmTJFgebjoqOj8Xg8Z7V5PB6io6OL5P0UaiJSYkyfPp2nn36a7t278/bbb1OmjL7CfF1QUBDh4eFngs3j8RAeHl5kM71oSL+IlAhz587l8ccfp3379syZM4eyZfX1VRKEhIQQGxtLeHg4kZGRxMTEEBsbS0hISJG8n/7MERGft3DhQvr06UPLli354IMPqFChgtslST6EhIQQGRnJ+PHjiYyMLLJAA4WaiPi4+Ph4HnroIZo3b86iRYu49NJL3S5J8snj8RATE0NUVBQxMTHnHWMrTAo1EfFZq1evpmvXrjRo0IDPPvuMypUru12S5FPGMbTY2FjGjRt3piuyqIJNoSYiPmndunV07NiR2rVrs3TpUq644gq3S5ICSEpKOusYWsYxtqSkpCJ5P2OtLZIXLgyBgYE2OTnZ7TJEpJht2rSJe++9l8suu4xVq1ZRp04dt0sSH2KMWWetDcxumfbURMSnbN26ldDQUMqXL8+yZcsUaJIvGhMrIj5j9+7dtGnThpSUFFauXMkNN9zgdklSwijURMQn/PLLL7Rp04YjR47g8Xho1KiR2yVJCaRQExHXHTp0iLZt2/LTTz+xdOlSbr31VrdLkhJKoSYirvrtt99o3749P/zwA5988gl33XWX2yVJCaZQExHX/PHHH3Tq1In//Oc/LFiwgDZt2rhdkpRwCjURccWpU6fo3r07X3zxBe+99x6dO3d2uyTxAwo1ESl2qamp9OzZkyVLljB9+nQefvhht0sSP6Hz1ESkWKWnp/PII48QFxfHK6+8wqOPPup2SeJHFGoiUmystQwePJjZs2czceJEnnzySbdLEj+jUBORYmGt5dlnn2Xq1KkMHz6cESNGuF2S+KFcQ80YU8cY4zHGbDbGbDLGPOVtv8IYs9QY86P3ZzVvuzHGvGqM2WqM2WiMuTXLa/Xzrv+jMaZf0X0sEfE148aNY/LkyQwdOpRJkya5XY74qbzsqaUCf7XW3gTcCQwxxjQChgPLrLX1gWXexwAdgPre20AgBpwQBEYDdwC3A6MzglBE/NvkyZMZM2YM/fv355VXXsEY43ZJ4qdyDTVr7V5r7dfe+8eAzcA1QFdgpne1mUA37/2uwDvW8SVQ1RhzFdAOWGqtPWStPQwsBdoX6qcREZ8zdepUhg0bRnh4OG+99RZlyuiohxSdfG1dxpjrgebAV8CV1tq94AQf8D/e1a4Bdmd52h5v24Xaz32PgcaYZGNM8oEDB/JTnoj4mNmzZxMZGcn999/PrFmzCAgIcLsk8XN5DjVjzGXAB8DT1trfclo1mzabQ/vZDdZOs9YGWmsDa9asmdfyRMTHxMXF0b9/f0JCQpg/fz7ly5d3uyQpBfIUasaYcjiB9q61doG3eZ+3WxHvz/3e9j1A1gsg1QZ+zqFdRPzMZ599xsMPP8ztt9/ORx99xCWXXOJ2SVJK5GX0owGmA5uttS9lWbQQyBjB2A/4KEt7X+8oyDuBo97uySVAW2NMNe8AkbbeNhHxIytXriQsLIybb76ZxYsXc9lll7ldkpQieZkm626gD/CNMWa9t20E8AIQa4wZAOwCHvIuWwx0BLYCfwCPAFhrDxljxgNJ3vXGWWsPFcqnEBGfsHbtWjp16kTdunX5/PPPqVq1qtslSSljrD3vsJbPCAwMtMnJyW6XISJ5sHHjRoKDg6latSqrVq3immvOGwcmUiiMMeustYHZLdPYWhG5aD/88AP33Xcfl156KcuWLVOgiWsUaiJyUXbs2EGbNm2w1hIfH0/dunXdLklKMV16RkQKbO/evYSGhnL8+HESEhJo2LCh2yVJKadQE5ECOXjwIKGhoezbt4/4+HiaNm3qdkki6n4Ukfw7evQo7dq1Y9u2bSxatIg77rjD7ZKKXHR0NB6P56w2j8dDdHS0SxVJdhRqIpIvv//+O/fffz/ffPMNCxYsIDg42O2SikVQUBDh4eFngs3j8RAeHk5QUJDLlUlW6n4UkTw7efIk3bp1IzExkdjYWDp06OB2ScUmJCSE2NhYwsPDiYyMJCYmhtjYWEJCQtwuTbLQnpqI5ElKSgrh4eHEx8fz73//mwceeMDtkopdSEgIkZGRjB8/nsjISAWaD1KoiUiu0tLS6Nu3L4sWLWLKlCn07dvX7ZJc4fF4iImJISoqipiYmPOOsYn7FGoikqP09HSeeOIJ5s6dS3R0NIMHD3a7JFdkHEOLjY1l3LhxZ7oiFWy+RaEmIhdkreWZZ55h+vTpREVF8eyzz7pdkmuSkpLOOoaWcYwtKSkpl2dKcdLcjyJyQSNHjmTixIk888wzTJ48GeeiHSLu0tyPIpJvL774IhMnTuTxxx9XoEmJoVATkfNMmTKF4cOH06tXL2JiYhRoUmIo1ETkLDNmzGDo0KF07dqVGTNmEBAQ4HZJInmmUBORM+bPn8+AAQO47777mDdvHuXKlXO7JJF8UaiJCACffPIJvXr14q677iIuLo4KFSq4XZJIvinURITly5fzwAMP0LRpUz7++GMqVarkdkkiBaJQEynlEhMT6dKlC/Xr12fJkiVUqVLF7ZJECkyhJlKKrV+/ng4dOnDVVVexdOlSqlev7nZJIhdFoSZSSm3evJm2bdtSpUoVli1bRq1atdwuSeSiKdRESqFt27YRGhpKmTJliI+P59prr3W7JJFCoeupiZQye/bsITQ0lJMnT7JixQrq16/vdkkihUahJlKK7N+/n9DQUA4ePMjy5ctp3Lix2yWJFCqFmkgpcfjwYdq2bcuuXbtYsmQJgYHZzgcrUqIp1ERKgWPHjtGxY0c2b97MokWLaNmypdsliRQJhZqInztx4gRdunQhKSmJDz74gLZt27pdkkiRUaiJ+LHTp0/z4IMPsmLFCmbPnk3Xrl3dLkmkSCnURPxUamoqERERLF68mGnTptGrVy+3SxIpcjpPTcQPpaen89hjj/H+++/z0ksv8fjjj7tdkkixUKiJ+BlrLX/+85+ZOXMm48aN45lnnnG7JJFik2uoGWPeNsbsN8Z8m6VtjDHmJ2PMeu+tY5ZlzxtjthpjvjfGtMvS3t7bttUYM7zwP4qIWGt5/vnneeONN3j22WcZOXKk2yWJFKu87KnNANpn0/6ytbaZ97YYwBjTCOgB3Ox9zhvGmABjTAAwBegANAJ6etcVkUI0adIkXnzxRSIjI3nxxRcxxrhdkkixynWgiLV2pTHm+jy+XldgrrX2FLDdGLMVuN27bKu1dhuAMWaud93v8l2xiGTrX//6FyNHjqRv3768/vrrCjQplS7mmNpQY8xGb/dkNW/bNcDuLOvs8bZdqP08xpiBxphkY0zygQMHLqI8kdIhMTGR7t2788wzz/DAAw8wffp0ypTR4XIpnQq65ccANwDNgL3AZG97dn8a2hzaz2+0dpq1NtBaG1izZs0ClidSOqxatYp7772XuLg4ypQpw5NPPknZsjpTR0qvAoWatXaftTbNWpsOvElmF+MeoE6WVWsDP+fQLiIFtHr1asLDw0lJSQHAGMPq1atdrkrEXQUKNWPMVVkehgEZIyMXAj2MMRWMMXWB+sBaIAmob4ypa4wpjzOYZGHByxYpvfbv30///v255557SE9Pp3z58gQEBFC+fHmCg4PdLk/EVbn2Uxhj3gOCgRrGmD3AaCDYGNMMpwtxB/AEgLV2kzEmFmcASCowxFqb5n2docASIAB421q7qdA/jYgfS0tLY9q0aYwYMYLff/+d4cOHM3LkSDZu3EhCQgLBwcG0aNHC7TJFXGWszfbQlk8IDAy0ycnJbpch4rqkpCQGDx5McnIyrVu3ZsqUKTRs2NDtskRcYYxZZ63N9tpJGiIl4sMOHTrEoEGDuOOOO/jpp5947733iI+PV6CJXIBCTcQHpaen8/bbb9OgQQPeeustnn76abZs2UKPHj10/plIDhRqIj5m/fr1tGzZkgEDBtCwYUO+/vprXnrpJSpXrux2aSI+T6Em4iOOHj3KU089xW233caPP/7IjBkzWLlyJU2aNHG7NJESQ2dpirjMWsucOXMYNmwY+/btIzIykgkTJlCtWrXcnywiZ1Goibjou+++Y8iQISQkJHD77bfz8ccfc9ttt7ldlkiJpe5HERccP36cv/3tbzRt2pQNGzYwdepUEhMTFWgiF0l7aiLFyFrLggULePrpp9mzZw+PPvooL7zwAprnVKRwaE9NpJj8+OOPdOjQgQcffJDq1auzevVqpk+frkATKUQKNZEiduLECUaNGkXjxo1JTEzklVdeITk5mbvuusvt0kT8jrofRYrQxx9/zJNPPsn27duJiIjgH//4B1dddVXuTxSRAtGemkgR2LFjB127dqVz585ccskleDweZs+erUATKWIKNZFCdOrUKSZOnEijRo1YtmwZ0dHRrF+/XpeEESkm6n4UKSRLly5l6NCh/PDDDzz44IO89NJL1KlTJ/cnikih0Z6ayEXas2cP4eHhtG3bFmstn332GfPnz1egibhAoSZSQCkpKfzzn/+kYcOGLFq0iPHjx/PNN9/Qrl07t0sTKbXU/ShSACtWrGDIkCFs2rSJTp068eqrr1K3bl23yxIp9bSnJpIPv/zyC3369CE4OJjff/+dhQsXsmjRIgWaiI9QqInkQWpqKq+99hoNGjQgNjaWkSNHsmnTJjp37ux2aSKShbofRXLx5ZdfEhkZyfr167nvvvt4/fXX+dOf/uR2WSKSDe2piVzAwYMHeeyxx2jRogUHDhwgNjaWJUuWKNBEfJhCTeQc6enpvPnmmzRo0ICZM2cybNgwNm/ezEMPPYQxxu3yRCQH6n4UyWLdunUMHjyYtWvX0qpVK9544w1uvvlmt8sSkTzSnpoIcOTIEYYOHUpQUBA7d+5k1qxZJCQkKNBEShiFmpRq1lreeecdGjRoQExMDEOHDmXLli307t3b57sao6Oj8Xg8Z7V5PB6io6NdqkjEfQo1KbW++eYb7r33Xvr160e9evVITk7m1VdfpWrVqm6XlidBQUGEh4efCTaPx0N4eDhBQUEuVybiHoWalDrHjh3jr3/9K82bN+e7777jrbfeYvXq1TRv3tzt0vIlJCSE2NhYwsPDGTVqFOHh4cTGxhISEuJ2aSKuUahJqWGtZd68eTRs2JCXX36ZAQMG8P333zNgwADKlCmZ/xVCQkKIjIxk/PjxREZGKtCk1CuZ/5NF8un777+nbdu29OjRg1q1apGYmMjUqVOpXr2626VdFI/HQ0xMDFFRUcTExJx3jE2ktFGoiV/7448/GDFiBLfccgtJSUlMmTKFtWvXcscdd7hd2kXLOIYWGxvLuHHjznRFKtikNFOoiV+y1vLhhx9y00038fe//52ePXvy/fffM3jwYAICAtwur1AkJSWddQwt4xhbUlKSy5WJuMdYa3NewZi3gU7AfmttY2/bFcA84HpgBxBurT1snDHQrwAdgT+A/tbar73P6QeM9L7sBGvtzNyKCwwMtMnJyQX4WFKabdu2jT//+c8sXryYxo0b88Ybb9CyZUu3yxKRQmKMWWetDcxuWV721GYA7c9pGw4ss9bWB5Z5HwN0AOp7bwOBGG8BVwCjgTuA24HRxphq+fsYIjk7efIkY8eOpVGjRqxcuZLJkyfz9ddfK9BESpFcQ81auxI4dJiHe2IAABakSURBVE5zVyBjT2sm0C1L+zvW8SVQ1RhzFdAOWGqtPWStPQws5fygFCmwTz/9lMaNGzNmzBi6devGli1b+Mtf/kK5cuXcLk1EilFB53680lq7F8Bau9cY8z/e9muA3VnW2+Ntu1D7eYwxA3H28rj22msLWJ6UFrt27eKZZ55hwYIFNGjQgKVLlxIaGup2WcUqMRESEiA4GFq0cLsa32Xt2beCtq1dC0lJEBKi37cvKuwJjbObV8jm0H5+o7XTgGngHFMrvNLEn5w+fZqXXnqJ8ePHY61l0qRJ/OUvf6FChQpul1asZs+GRx6B1FQoUwYaNIDLLnOWFcYXuK+35XWdohAQABMmwNChmb9zcV9BQ22fMeYq717aVcB+b/seoE6W9WoDP3vbg89pTyjge0sp5/F4GDx4MFu2bKFbt27861//4rrrrnO7rGJz9CjMnQtvv+3sNWRIT3fCLePUO2POvpWmtqJ6/eXL4dNPnbBMS4Pnn4cxY6B1a+jc2bnVrp3vf1IpTNbaXG84oxy/zfL4H8Bw7/3hQLT3/v3Apzh7ZncCa73tVwDbgWre23bgitze97bbbrMiGX7++Wfbs2dPC9h69erZjz/+2O2Sik16urUej7V9+lh7ySXOPsjNN1v75JPWVqxobUCA075mjduV+rc1a5zfc8bv+7XXrH36aWtvuCFz37B5c2tHjbI2Odn5d5PCByTbC+XVhRbYzAB7D9gLpODscQ0AquOMevzR+/MK77oGmAL8F/gGCMzyOo8CW723R3J7X6tQE6+UlBT78ssv28svv9xWqFDBjh492v7xxx9ul1Usdu+2dsKEzC/NypWtfeIJa7/6KvMLc80aaydNUqAVl+x+3+np1m7aZO0LL1h7993Wlinj/HtdfbW1Awda+/HH1paSTbZY5BRquZ6n5iadpyarV69m8ODBbNy4kfbt2/Paa69x4403ul1WkTp1ChYtgunT4fPPnW7F4GB49FF44AG49FK3K5TcHDgAixc7/45LlsDx486/W2godOkC998PtWq5XWXJldN5ago18Un79+/nueeeY8aMGdSpU4d//etfhIWF+fw1zi7GN984x8lmzYJff4VrroH+/Z2bn+e4Xzt1yhmdumiRc9u1y2m//XYn4Dp3hltuyTx2J7lTqEmJkZaWxrRp0xgxYgTHjx/nr3/9K1FRUVSqVMnt0orEkSPOoI/p0yE5GcqVg65dnb2ytm2dEXbiP6yFjRszAy5joM9112UONLn3Xihlg3jzTaEmJUJSUhKDBw8mOTmZkJAQpkyZwk033eR2WYUuPR1WrHD2yt5/H06ehMaNYcAAiIiAmjXdrlCKy9698MknTsAtXQonTjinB7Rv7wRcx45Qo4bbVfoehZr4tEOHDjFixAimTZtGrVq1mDx5Mj169PC7rsbdu2HmTPj3v2HbNqhcGXr1cvbKAgPV/VTanTgBy5Zl7sXt3euce3jXXZl7cQ0bajsBhZr4qPT0dGbMmMFzzz3H4cOH+fOf/8zYsWOpXLmy26UVmlOnYOFCZ69syRKn+ykkxAmy7t016EOyl54OX3/thNvChbB+vdN+442ZAXfPPU53dWmkUBOfs2HDBgYPHsyaNWu4++67eeONN2jSpInbZRWajRudIJs92xn0Ubt25qCPG25wuzopaXbvho8/dgJu+XI4fRqqVoUOHZzBJu3bO49LC4Wa+IyjR48yevRoXnvtNapXr050dDR9+/alTJmSf2m/I0fgvfecMMsY9NGtm7NXdt99GvQhheP4cef426JFTtAdOABly0LLls4eXJcu/v+Hk0JNXGetZc6cOQwbNox9+/YxaNAgJk6cSLVqJfsKROnpznDtt9+GDz5wBn3cckvmoA8d5JeilJbmjKBcuNAJuU2bnPabbsoMuDvv9L8/qBRq4orExEQSEhK47rrrePPNN0lISCAwMJA33niDoKAgt8u7KLt3w4wZzqCP7duhSpXMQR+33aaD+eKObdsyuylXrHDmAq1RwxlF2aWLc5rI5Ze7XeXFU6hJsUtMTKR169acOnUKay2XX345//jHP3jssccIKKF/Np46BR995OyVff65M+ijdevMQR+XXOJ2hSKZjh51BictXOjMbnL4MJQv78xOk3HSd0m9updCTYrNtm3biIuL47XXXmPnzp0AGGMYMWIEEyZMcLm6gtm40Tk5evZsOHTIGfTxyCPOoI969dyuTiR3qamwZk1mN+UPPzjtTZpkBlxgoHMKQUmgUJMiY61l48aNxMXFERcXx8aNGwGoX78+27dvx1pL+fLlWbZsGS1K0BUVjxyBOXOcvbJ165y/cDMGfYSG+t8xCildvv8+83y4L75wjg3XqgWdOjkBFxrq26ebKNSkUKWnp5OYmHgmyLZt24Yxhrvvvpvu3bvTrVs36tate+aYWnBwcIkItIxBH9Onw4IFzqCPJk0yB31kXKdMxJ/8+qtzjbhFi+Czz+C336BiRSfYOnd2gu7qq92u8mwKNblop0+fxuPxsGDBAj766CP27dtHuXLlCA0NJSwsjC5dunDllVe6XWaB7NqVOehjxw5n0EdEhLNXduutGvQhpcfp07ByZeZe3PbtTntgYOZJ382auf9/QqEmBXL8+HE+++wz4uLi+OSTTzh69CiVKlWiY8eOhIWF0bFjR6pUqeJ2mQWSMehj+nTnnB9roU0bJ8jCwjToQ8Ra5xSBjID78kunrU4dZ++tSxdn0EnFisVfm0JN8uzXX39l0aJFxMXF8fnnn3Py5EmqV69Oly5d6N69O6GhoVR0YysuJBs2OEH27rvOoI86dTIHfdSt63Z1Ir5r//7MyZeXLIE//oBKlZzTBDp3dq4R9z//Uzy1KNQkR7t37+bDDz8kLi6OlStXkpaWRp06dQgLCyMsLIx77rmHsmXLul1mgR0+7Mz0MX26M59e+fLO3tijjzp7Zxr0IZI/J0+Cx5O5F7dnj9MleeedmSd9N2pUdN2UCjU5z5YtW84M9EhKSgLgpptuonv37oSFhXHrrbeW6Fny09Od/3QZgz5OnYKmTZ1BH716adCHSGGx1plwOWPy5XXrnPa6dTMDrmVLpz0hwemyvNhxYwo1wVrLunXriIuLY8GCBWzZsgWA22+//cweWYMGDVyu8uKdO+ijatWzB32ISNH6+WdnVpNFiyA+3tmru/RS5w9La50LoC5bdnHBllOoldw+JclVamoqq1atIi4ujg8//JDdu3cTEBDAvffey5AhQ+jWrRu1a9d2u8yLdvJk5qCP+HjnP05oKEya5HQzluBDgCIlztVXw8CBzu2PP5z/k+PHO5N8gzPCMiHh4vfWLkSh5mdOnjzJ0qVLiYuLY+HChfz6669UrFiRtm3bMn78eDp16kR1P+l7W78+8/Iuhw87U/6MGuUM+rj+ererK3rR0RAU5FyfLYPHA0lJ8Le/uVeXSIZLL3W6H2vWdI5fnz6dOVVXUVGo+YGjR4+yePFiFixYwKeffsrvv/9OlSpV6NSpE2FhYbRv355KlSq5XWahOHzYmelj+nT4z3+c/yDdu2cO+igp0/wUhqAgCA+H2Fgn2DyezMcivqRFC6fLsbCOqeVEx9RKqH379vHRRx8RFxfHsmXLSElJoVatWnTt2pWwsDBCQkIoX768K7VFR0cTFBRESJZdCI/HQ1JSEn8rwC5EerpzYcS3384c9NGsWeagjyuuKMzqS5aMIIuMhJiYzIAT8Wc6puYntm/ffmagx5o1a7DWcsMNN/DUU08RFhbGnXfe6RMX2wwKCiI8PJzY2FhCQkLweDxnHufHzp2Zgz527oRq1eDxx529subNi6b2kiYkxAm08eMhKkqBJoK11mdvt912my3N0tPT7YYNG+yYMWNs06ZNLWAB27RpUztmzBi7YcMGm56e7naZ2Vq+fLmtUaOGjYqKsjVq1LDLly/P0/NOnLD2vfesve8+a41xbqGhTtuJE0VcdAm0fLm1NWpYGxXl/Mzjr1kK4MUXz//9Ll/utEvxApLtBXLD9eDK6VYaQy0tLc2uXr3aDhs2zN5www0WsMYYe/fdd9vJkyfb//73v26XmGdRUVEWsFFRUbmu+/XX1g4dam21as5Wed111o4ZY+327UVeZomVEWgZX7TnPpbCpd+371Co+bhTp07ZJUuW2CeeeMLWqlXLArZcuXK2ffv2durUqXbv3r1ul5hvedlT+/VXa197zdrmzZ0tsUIFa3v0sHbpUmvT0lwouoTRnkPx056xb1Co+aDjx4/b999/30ZERNgqVapYwFaqVMk++OCD9t1337VHjhxxu8QCywi0jCDL+jgtzdrPP3fCq0IFZwu89VZrX3/dCTkRXxcV5Wy3eeiAkCKSU6hpoEgxOnTo0JnJgpcsWXJmsuCMqalCQ0O5xA+mh09KSjozSAQgJCSEV1+NZdKkJPr3D2HXLmfQx8CBzqCPZs1cLlgkjzweZ5RpVJTzMyREg3N8jYb0F7E9e/acmSx4xYoVpKWlUbt27TNTU7Vs2bJETxZ8ISkpziwf8+fDtm2Z88Hdd58TZF27aqYPKVmyngd47nmBCrbiVWRD+o0xO4BjQBqQaq0NNMZcAcwDrgd2AOHW2sPGmR33FaAj8AfQ31r79cW8v6/6/vvvz0wWvHbtWgAaNmzIc889R1hYGLfddluJniwYnKmo9u93LiK4bZvzM+v9Xbuc88vAmal7wAAYORKuu87dukUKKinp7AALCXEeJyUp1HxJYewihFhrD2Z5PBxYZq19wRgz3Pv4OaADUN97uwOI8f4s8ay1fP311yxYsIC4uDg2b94MOOdrTZo0ibCwMBo2bOhylfl37FhmWJ0bXtu3O/O6ZXXllVCvHtx1lzNN1YoVTviVKeO0K9CkJMtu3gB1P/qeouj36goEe+/PBBJwQq0r8I73IN+XxpiqxpirrLV7i6CGIpeamsoXX3xxZrLgXbt2ERAQQKtWrYiMjKRbt27UqVPH7TJzlJLi7FFlF1rbtsHBg2evf9llTjjdeKNzYcC6dZ1bvXpOiF16aea6iYnFN9ebiEiGiw01C3xujLHAVGvtNODKjKCy1u41xmRcC/UaYHeW5+7xtp0VasaYgcBAgGuvvfYiyytcJ0+eJD4+/sxkwQcPHjwzWfDYsWPp3LmzT00WbC3s23fhLsLduzO7CAHKlnX2purWdeZTzBpades61yDLa69pcc71JiKS4WJD7W5r7c/e4FpqjNmSw7rZfR2eN0rFG4zTwBkocpH1XbTffvuNTz75hLi4OD799FOOHz9O5cqVz5os+LLLLnOtvowuwuxCa/t2OHHi7PVr1XJC6p57zg6sunWhdu3CvQp0ixYKMxEpXhcVatban70/9xtj4oDbgX0Z3YrGmKuA/d7V9wBZ++NqAz9fzPsXlX379rFw4ULi4uKIj48nJSWFK6+8koiIiGKfLPj06Zy7CH/99ez1L7/cCao//QnatTs7tM7tIhQR8TcFDjVjTCWgjLX2mPd+W2AcsBDoB7zg/fmR9ykLgaHGmLk4A0SO+tLxtIzJguPi4li9ejXWWurVq8eTTz55ZrLggMLcjfGyFn755fzQyvi5Z8/ZXYTlymV2ET744PldhFdckfcuQhERf3Mxe2pXAnHeoellgTnW2s+MMUlArDFmALALeMi7/mKc4fxbcYb0P3IR733RrLV8++23Z4Js/fr1ADRp0oRRo0YRFhZGkyZNCmXo/W+/XbiLcMeO87sIr7rKCahWrc7vIrzmmsLtIhQR8Sel6uTr9PR0vvrqqzNBtnXrVowxtGjRgu7du9OtWzduuOGGfL/u6dPOpVEu1EV46NDZ61eufHZQndtF6AeTioiIFJlSfT21lStXMmPGDA4fPsxXX33F3r17KVeuHK1bt2bYsGF07dqVWrVq5fga6enZdxFm3P/pp/O7CK+/3gmpwMDzw6taNXURikjpEB3tXKU96/l8Ho9z0noBrhmcK78OtcTERFq3bk1aWhoAwcHB/POf/6Rjx45UrVr1rHWPHs25i/DkybNf++qrnYAKDj4/tK6+Wl2EIiLgBNqFphcrCn4dagkJCaSn3wG0wphEbr21B9Wr92Lu3PPD6/Dhs59bpYoTUo0awf33n99FqHkLL6y4/zITEd+VMZ1YeLhzlfaYmKKdL9OvQ6169U5Y+1egHNbCSy8ZXnrJWVa+fGYXYVDQ+ce4qlVzs/KSrbj/MhMR3xYS4gTa+PHOFQ6Kcmoxvw216OhofvghCGMaY63BGEvLlh4aNUrif//3b1x9tTMnoRS+4v7LTER8W3Fessdvv9aDgoL44INwypVLICAAypVLYOPGcMLDg6hdW4FW1LL+ZRYZqUATKa2y9tSMG5f5B6/HUzTv57df7SEhISxYEMull4bTqtUoLr00nAULMi9cKUXr3L/MimoDFhHfltMle4qC35+nNmrUKMaPH09UVBTjxo0rpMokJ7qYoogUpZzOU/PbPTUAj8dDTEwMUVFRxMTE4NHuQrEo7r/MREQy+O1AkSee+C9z577Chx86XY4hISF06/YKPXpcy9Sp+Z81RPJOF1MUEbf4bahBEsbEAhmz6YdgzN3AAkChJiLij/w21KZO7UGPHmcPK4+LK09ISA+3SxMRkSLi18fUNKxcRKR08etQ07ByEZHSxW9DrbhP+BMREff5bahpWLmISOnj9ydfi4iIfym1J1+LiEjpolATERG/oVATERG/oVATERG/oVATERG/oVATERG/oVATERG/4dPnqRljDgA7vQ+rAEcL4WUL+jr5eV5e1s1tnZyW57SsBnAwl/f2BYX171nU7+EP20tOy7W9FO57+Mr2kpf1CvId4yvby3XW2prZLrHWlogbMM3N18nP8/Kybm7r5LQ8l2XJbv9bFee/Z1G/hz9sLzkt1/bin9vLxWwTOS0rCdtLSep+XOTy6+TneXlZN7d1clpeWL8LNxXHZyiM9/CH7SWv7+HLtL3kf91S+R3j092Pkn/GmGR7geljRM6l7UXyoyRsLyVpT03yZprbBUiJou1F8sPntxftqYmIiN/QnpqIiPgNhZqIiPgNhZqIiPgNhZqIiPgNhZofM8bcZIz5P2PM+8aYSLfrkZLBGFPJGLPOGNPJ7VrEtxljgo0xq7zfM8Fu1wMKtRLHGPO2MWa/Mebbc9rbG2O+N8ZsNcYMB7DWbrbWDgLCAZ8+t0SKTn62Ga/ngNjirVJ8RT63FwscByoCe4q71uwo1EqeGUD7rA3GmABgCtABaAT0NMY08i7rAnwBLCveMsWHzCCP24wxJhT4DthX3EWKz5hB3r9jVllrO+D8ITS2mOvMlkKthLHWrgQOndN8O7DVWrvNWnsamAt09a6/0Fp7FxBRvJWKr8jnNhMC3An0Ah43xug7opTJz/ZirU33Lj8MVCjGMi+orNsFSKG4Btid5fEe4A5vH3d3nI1tsQt1ie/Kdpux1g4FMMb0Bw5m+dKS0u1C3zHdgXZAVeB1Nwo7l0LNP5hs2qy1NgFIKN5SpITIdps5c8faGcVXipQAF/qOWQAsKO5icqKuBf+wB6iT5XFt4GeXapGSQduM5EeJ2V4Uav4hCahvjKlrjCkP9AAWulyT+DZtM5IfJWZ7UaiVMMaY94BEoIExZo8xZoC1NhUYCiwBNgOx1tpNbtYpvkPbjORHSd9eNEu/iIj4De2piYiI31CoiYiI31CoiYiI31CoiYiI31CoiYiI31CoiYiI31CoiYiI31CoiYiI3/h/rCwUk3MlUY4AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -156,7 +153,7 @@ "metadata": {}, "outputs": [], "source": [ - "from SimPEG import Regularization" + "from SimPEG import regularization, data" ] }, { @@ -170,74 +167,75 @@ "name": "stdout", "output_type": "stream", "text": [ - "SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||\n", "SimPEG.InvProblem will set Regularization.mref to m0.\n", "SimPEG.InvProblem will set Regularization.mref to m0.\n", "\n", - " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", - " ***Done using same Solver and solverOpts as the problem***\n", + " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same Solver and solverOpts as the problem***\n", "model has any nan: 0\n", "=============================== Projected GNCG ===============================\n", " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", "-----------------------------------------------------------------------------\n", "x0 has any nan: 0\n", - " 0 3.28e-01 4.36e+02 0.00e+00 4.36e+02 4.01e+01 0 \n", - " 1 3.28e-01 2.49e+02 1.22e+01 2.53e+02 2.75e+01 2 \n", - " 2 1.64e-01 1.77e+02 5.59e+01 1.86e+02 7.53e+01 1 Skip BFGS \n", - " 3 1.64e-01 1.56e+02 1.20e+02 1.76e+02 1.07e+02 0 \n", - " 4 8.21e-02 4.19e+01 1.06e+02 5.07e+01 3.71e+01 0 \n", - " 5 8.21e-02 1.13e+01 1.12e+02 2.05e+01 1.21e+01 0 \n", + " 0 3.56e+00 4.42e+02 0.00e+00 4.42e+02 3.90e+01 0 \n", + " 1 3.56e+00 2.92e+02 3.98e+00 3.06e+02 2.15e+01 1 \n", + " 2 1.78e+00 2.44e+02 1.42e+01 2.69e+02 3.15e+01 0 Skip BFGS \n", + " 3 1.78e+00 1.02e+02 4.81e+01 1.87e+02 2.17e+01 0 \n", + " 4 8.89e-01 6.26e+01 6.18e+01 1.18e+02 1.66e+01 0 \n", + " 5 8.89e-01 1.43e+01 8.60e+01 9.08e+01 8.66e+00 0 \n", + " 6 4.44e-01 1.09e+01 8.70e+01 4.96e+01 8.91e+00 0 \n", "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 4.3743e+01\n", - "1 : |xc-x_last| = 2.2077e+00 <= tolX*(1+|x0|) = 4.7106e+00\n", - "0 : |proj(x-g)-x| = 1.2056e+01 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 1.2056e+01 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 40 <= iter = 6\n", + "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 4.4342e+01\n", + "1 : |xc-x_last| = 1.1550e+00 <= tolX*(1+|x0|) = 4.7106e+00\n", + "0 : |proj(x-g)-x| = 8.9111e+00 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 8.9111e+00 <= 1e3*eps = 1.0000e-02\n", + "0 : maxIter = 40 <= iter = 7\n", "------------------------- DONE! -------------------------\n" ] } ], "source": [ - "FDsurvey.dtrue = d_true\n", "std = 0.07\n", "floor = 0.\n", "np.random.seed(1)\n", - "uncert = std*abs(FDsurvey.dtrue)+floor\n", - "noise = std*FDsurvey.dtrue*np.random.randn(FDsurvey.dtrue.size)\n", - "FDsurvey.dobs = FDsurvey.dtrue+noise\n", - "dmisfit = DataMisfit.l2_DataMisfit(FDsurvey)\n", - "dmisfit.W = 1./(abs(FDsurvey.dobs)*std+floor)\n", + "uncert = std*abs(d_true)+floor\n", + "noise = std*np.abs(d_true)*np.random.randn(len(d_true))\n", + "d_obs = d_true + noise\n", + "dataObj = data.Data(FDsurvey, dobs=d_obs, noise_floor=uncert)\n", + "\n", + "dmisfit = data_misfit.L2DataMisfit(dataObj, sim)\n", + "dmisfit.W = utils.sdiag(1/uncert)\n", "m0 = np.r_[np.log(np.ones_like(sig)*sig_half), 45.]\n", - "reg_sigma = Regularization.Sparse(\n", + "reg_sigma = regularization.Sparse(\n", " mesh1D, mapping=wires.sigma, cell_weights=mesh1D.vol,\n", " alpha_s = 0.01\n", ")\n", "p=0.\n", "qx, qz = 1., 1.\n", "reg_sigma.norms = np.c_[p, qx, qz, 0.]\n", - "IRLS = Directives.Update_IRLS(\n", - " maxIRLSiter=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, \n", - " betaSearch=False,\n", + "IRLS = directives.Update_IRLS(\n", + " max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, \n", + " beta_tol=1e-2,\n", " chifact_start = 1.\n", ")\n", - "mesh_h = Mesh.TensorMesh([1])\n", - "reg_h = Regularization.Sparse(\n", + "mesh_h = TensorMesh([1])\n", + "reg_h = regularization.Sparse(\n", " mesh_h, mapping=wires.h, \n", " alpha_s = 1.\n", ")\n", "reg = reg_sigma + reg_h\n", - "opt = Optimization.ProjectedGNCG(maxIter = 40)\n", + "opt = optimization.ProjectedGNCG(maxIter = 40)\n", "opt.maxIterLS = 5\n", - "invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)\n", - "beta = Directives.BetaSchedule(coolingFactor=2, coolingRate=2)\n", - "betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", - "target = Directives.TargetMisfit()\n", - "update_sense = Directives.UpdateSensitivityWeights()\n", - "inv = Inversion.BaseInversion(invProb, directiveList=[beta,betaest,target])\n", + "invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)\n", + "beta = directives.BetaSchedule(coolingFactor=2, coolingRate=2)\n", + "betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", + "target = directives.TargetMisfit()\n", + "update_sense = directives.UpdateSensitivityWeights()\n", + "inv = inversion.BaseInversion(invProb, directiveList=[beta,betaest,target])\n", "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS, betaest])\n", "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS])\n", "\n", - "prob.counter = opt.counter = Utils.Counter()\n", + "# prob.counter = opt.counter = utils.Counter()\n", "opt.LSshorten = 0.5\n", "opt.remember('xc')\n", "mopt = inv.run(m0)" @@ -253,7 +251,7 @@ "output_type": "stream", "text": [ "[45.]\n", - "[30.86179626]\n", + "[31.38778403]\n", "30.0\n" ] } @@ -280,7 +278,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/sgkang/anaconda3/lib/python3.6/site-packages/IPython/core/magics/pylab.py:160: UserWarning: pylab import has clobbered these variables: ['inv', 'floor', 'beta', 'std', 'axes']\n", + "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\IPython\\core\\magics\\pylab.py:160: UserWarning: pylab import has clobbered these variables: ['beta', 'std', 'axes', 'floor', 'inv']\n", "`%matplotlib` prevents importing * from pylab and numpy\n", " \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n" ] @@ -288,7 +286,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 8, @@ -297,7 +295,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -324,7 +322,7 @@ { "data": { "text/plain": [ - ">" + ">" ] }, "execution_count": 9, @@ -333,7 +331,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -348,8 +346,8 @@ "fig, axes = subplots(1,1, figsize = (7,5))\n", "axes.plot(FDsurvey.frequency, d_true[0:FDsurvey.n_frequency], 'k-')\n", "axes.plot(FDsurvey.frequency, d_true[FDsurvey.n_frequency:], 'b-')\n", - "axes.plot(FDsurvey.frequency, FDsurvey.dobs[0:FDsurvey.n_frequency], 'kx')\n", - "axes.plot(FDsurvey.frequency, FDsurvey.dobs[FDsurvey.n_frequency:], 'bx')\n", + "axes.plot(FDsurvey.frequency, d_obs[0:FDsurvey.n_frequency], 'kx')\n", + "axes.plot(FDsurvey.frequency, d_obs[FDsurvey.n_frequency:], 'bx')\n", "axes.set_xscale('log')\n", "axes.set_xlabel" ] @@ -378,7 +376,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/EM1D_inversion_FD_sensitivity_weight.ipynb b/notebooks/examples/EM1D_inversion_FD_sensitivity_weight.ipynb index b696375..5cbd941 100644 --- a/notebooks/examples/EM1D_inversion_FD_sensitivity_weight.ipynb +++ b/notebooks/examples/EM1D_inversion_FD_sensitivity_weight.ipynb @@ -31,7 +31,7 @@ "sig_half = 1e-3\n", "sig_blk = sig_half*50.\n", "chi_half = 0.\n", - "expmap = Maps.ExpMap(mesh1D)\n", + "expmap = maps.ExpMap(mesh1D)\n", "sig = np.ones(FDsurvey.n_layer)*sig_half\n", "blk_ind = (-50>LocSigZ) & (-80> Fix Jmatrix\n", - "Eps_p: 3.849488979385257\n", - "Eps_q: 3.849488979385257\n", - "delta phim: inf\n", - " 9 3.33e-02 4.54e+00 4.84e+01 6.15e+00 2.79e+01 1 Skip BFGS \n", - ">> Fix Jmatrix\n", - "Eps_p: 3.2079074828210477\n", - "Eps_q: 3.2079074828210477\n", - "delta phim: 7.441e-01\n", - " 10 5.41e-02 4.00e+00 4.97e+01 6.68e+00 2.43e+00 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 2.6732562356842067\n", - "Eps_q: 2.6732562356842067\n", - "delta phim: 3.276e-02\n", - " 11 9.48e-02 3.32e+00 4.92e+01 7.99e+00 2.06e+01 1 \n", - ">> Fix Jmatrix\n", - "Eps_p: 2.227713529736839\n", - "Eps_q: 2.227713529736839\n", - "delta phim: 4.107e-01\n", - " 12 1.72e-01 3.08e+00 4.85e+01 1.14e+01 2.58e+00 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 1.856427941447366\n", - "Eps_q: 1.856427941447366\n", - "delta phim: 2.237e-02\n", - " 13 3.09e-01 3.13e+00 4.32e+01 1.65e+01 1.60e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 1.5470232845394716\n", - "Eps_q: 1.5470232845394716\n", - "delta phim: 3.360e-01\n", - " 14 5.66e-01 2.99e+00 4.08e+01 2.61e+01 7.34e+00 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 1.2891860704495597\n", - "Eps_q: 1.2891860704495597\n", - "delta phim: 9.189e-02\n", - " 15 9.79e-01 3.44e+00 3.84e+01 4.10e+01 1.38e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 1.074321725374633\n", - "Eps_q: 1.074321725374633\n", - "delta phim: 2.503e-02\n", - " 16 4.89e-01 5.02e+00 3.51e+01 2.22e+01 1.28e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.895268104478861\n", - "Eps_q: 0.895268104478861\n", - "delta phim: 3.847e-02\n", - " 17 2.45e-01 4.95e+00 3.39e+01 1.32e+01 4.12e+00 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.7460567537323841\n", - "Eps_q: 0.7460567537323841\n", - "delta phim: 2.283e-02\n", - " 18 1.22e-01 4.78e+00 3.21e+01 8.70e+00 7.77e+00 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.6217139614436534\n", - "Eps_q: 0.6217139614436534\n", - "delta phim: 9.067e-03\n", - " 19 1.94e-01 4.25e+00 3.18e+01 1.04e+01 3.11e+00 0 Skip BFGS \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.5180949678697112\n", - "Eps_q: 0.5180949678697112\n", - "delta phim: 3.956e-03\n", - " 20 3.07e-01 4.32e+00 2.99e+01 1.35e+01 1.01e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.4317458065580927\n", - "Eps_q: 0.4317458065580927\n", - "delta phim: 1.166e-02\n", - " 21 4.90e-01 4.18e+00 2.77e+01 1.78e+01 1.25e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.3597881721317439\n", - "Eps_q: 0.3597881721317439\n", - "delta phim: 8.923e-03\n", - " 22 7.80e-01 4.23e+00 2.63e+01 2.47e+01 1.67e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.29982347677645327\n", - "Eps_q: 0.29982347677645327\n", - "delta phim: 9.063e-03\n", - " 23 1.22e+00 4.44e+00 2.47e+01 3.45e+01 2.44e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.24985289731371108\n", - "Eps_q: 0.24985289731371108\n", - "delta phim: 1.245e-02\n", - " 24 6.09e-01 4.58e+00 2.39e+01 1.91e+01 2.16e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.2082107477614259\n", - "Eps_q: 0.2082107477614259\n", - "delta phim: 2.046e-02\n", - " 25 3.05e-01 4.55e+00 2.34e+01 1.17e+01 1.83e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.1735089564678549\n", - "Eps_q: 0.1735089564678549\n", - "delta phim: 1.715e-02\n", - " 26 4.77e-01 4.43e+00 2.29e+01 1.54e+01 1.73e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.14459079705654576\n", - "Eps_q: 0.14459079705654576\n", - "delta phim: 1.722e-02\n", - " 27 7.46e-01 4.42e+00 2.22e+01 2.10e+01 1.64e+01 0 \n", - ">> Fix Jmatrix\n", - "Eps_p: 0.1204923308804548\n", - "Eps_q: 0.1204923308804548\n", - "delta phim: 2.699e-03\n", - " 28 1.17e+00 4.37e+00 2.13e+01 2.93e+01 2.10e+01 0 \n", - ">> Fix Jmatrix\n", - "Reach maximum number of IRLS cycles: 20\n", - "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 8.4267e+01\n", - "1 : |xc-x_last| = 1.5616e-01 <= tolX*(1+|x0|) = 3.1110e+00\n", - "0 : |proj(x-g)-x| = 2.1001e+01 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 2.1001e+01 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 40 <= iter = 29\n", - "------------------------- DONE! -------------------------\n" - ] - } - ], + "outputs": [], "source": [ "\n", - "dmisfit = DataMisfit.l2_DataMisfit(FDsurvey)\n", - "dmisfit.W = 1./(abs(FDsurvey.dobs)*std+floor)\n", + "dmisfit = data_misfit.L2DataMisfit(dataObj, sim)\n", + "dmisfit.W = 1./(abs(data_obj.dobs)*std+floor)\n", "\n", - "reg = Regularization.Sparse(\n", - " mesh1D, mapping=Maps.IdentityMap(mesh1D)\n", + "reg = regularization.Sparse(\n", + " mesh1D, mapping=maps.IdentityMap(mesh1D)\n", ")\n", "p=0.\n", "qx, qz = 2., 2.\n", "reg.norms = np.c_[p, qx, qz, 0.]\n", - "IRLS = Directives.Update_IRLS(\n", - " maxIRLSiter=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, \n", + "IRLS = directives.update_IRLS(\n", + " max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, \n", " betaSearch=False,\n", " chifact_start = 1.\n", ")\n", - "opt = Optimization.ProjectedGNCG(maxIter = 40)\n", + "opt = optimization.ProjectedGNCG(maxIter = 40)\n", "opt.maxIterLS = 5\n", - "invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)\n", - "beta = Directives.BetaSchedule(coolingFactor=2, coolingRate=2)\n", - "betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", - "target = Directives.TargetMisfit()\n", - "sense = Directives.UpdateSensitivityWeights(threshold=delta)\n", + "invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)\n", + "beta = directives.BetaSchedule(coolingFactor=2, coolingRate=2)\n", + "betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", + "target = directives.TargetMisfit()\n", + "sense = directives.UpdateSensitivityWeights(threshold=delta)\n", "# inv = Inversion.BaseInversion(invProb, directiveList=[beta,betaest,target])\n", - "inv = Inversion.BaseInversion(invProb, directiveList=[IRLS, betaest])\n", + "inv = inversion.BaseInversion(invProb, directiveList=[IRLS, betaest])\n", "\n", - "prob.counter = opt.counter = Utils.Counter()\n", "opt.LSshorten = 0.5\n", "opt.remember('xc')\n", "mopt = inv.run(m0)" @@ -295,72 +134,27 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "doi, act_ind = prob.depth_of_investigation(uncert)" + "doi, act_ind = sim.depth_of_investigation_christiansen_2012(uncert)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "230.0630993146064\n" - ] - } - ], + "outputs": [], "source": [ "print (doi)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/sgkang/anaconda2/envs/simpeg/lib/python3.6/site-packages/IPython/core/magics/pylab.py:160: UserWarning: pylab import has clobbered these variables: ['beta', 'floor', 'inv', 'pi', 'std']\n", - "`%matplotlib` prevents importing * from pylab and numpy\n", - " \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%pylab inline\n", "fig, ax = subplots(1,1, figsize=(5, 8))\n", @@ -371,24 +165,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "230.0630993146064\n" - ] - } - ], + "outputs": [], "source": [ "print (doi)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -397,24 +183,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0037711442200994323\n" - ] - } - ], + "outputs": [], "source": [ "print (delta)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "scrolled": false }, @@ -425,20 +203,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = subplots(1,1, figsize = (7,5))\n", "axes.plot(FDsurvey.frequency, -invProb.dpred[0:FDsurvey.n_frequency], 'k.-')\n", @@ -452,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -462,30 +229,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAHsCAYAAADhDQeoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3X+c3FV97/HXx0ACgSCwQAkQGlBi5UeLZh9UaKtbfwD6AEXRewGvbWrbVFur97Z9WCle71KL9ofbJt40wdXQxBsJNzUlkEAKknbVErxho8QAmhhwaeJGCYtoQiT8OvePM+uO6/6YJDM7Z7Ov5+Mxj535nu+c+Zwd8t4v3/nOOZFSQpJUjpc0uwBJ0s8ymCWpMAazJBXGYJakwhjMklQYg1mSCjPugzkiLo2ILRGxLSI+0ux6JOlgxXi+jjkiJgFbgTcBO4D7gatTSg83tTBJOgjj/Yj5AmBbSunRlNKzwC3A25pckyQdlPEezKcC26se76hsk6Rx67BmF3CQYohtP3duJiLmAnMBjjhi2uzjjpvFccfB7t3w/PNw4omwaxcceSRMmgR79sDxx8OPfgQvvggtLfDEE3DUUbm/p5+GE06Avj54yUvgpS+FJ5+Eo4+GF16An/xkoM/DDoNp0+CHP8w/n3sOnnkmt3/721uIgDPPfAVPPQXHHAP79uVb//OnTMm3H/8Yjj02v/Zzzw20H3EEHH54HksJY9q1K9dz1FE4Jsc0oca0efPGJ1JKJ9Yj2MZ7MO8AZlQ9Pg3oHbxTSqkT6ARobW1N3d3dY1PdKNra2gDo6upqah2SDl5EPFavvsb7qYz7gbMi4oyImAxcBdze5Jok6aCM6yPmlNLzEfEB4C5gEnBTSumhJpclSQdlXAczQErpTuDOZtchSfUy3k9lSNIhZ1J7e3uzaxhTHR2d7X19c2lpgRUrYO1amDULOjryp8Lbt8OyZTB9OixdCl1dMGMGzJuXP6HduhWWL4eZM2HhQtiwIX8iu2BB/vR306bcb3+fmzfD1KmwaFF+/fXrYeXK/vYl7N0LF100h85OmDwZ1q2DVasGnt/TA3v3wuLF+VPo1athzZqB9t7eXPeSJRQyJtiyBSJwTI5pQo1p/vzrd7a3t3fWI6fG9Tf/DoRXZUhqhIjYmFJqrUdfnsqQpMIYzJJUGINZkgpjMEtSYbwqw6syDqlPxh2TY/KqjHHIqzIkNYJXZUjSIcxglqTCGMySVBiDWZIKYzBLUmEMZkkqjNcxex3zIXUtqWNyTF7HPA55HbOkRvA6Zkk6hBnMklQYg1mSCmMwS1JhDGZJKozBLEmF8Tpmr2M+pK4ldUyOyeuYxyGvY5bUCF7HLEmHMINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTC+M0/v/l3SH37yjE5Jr/5Nw75zT9JjeA3/yTpEGYwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgrjV7L9SvYh9bVYx+SY/Er2OORXsiU1gl/JlqRDmMEsSYUxmCWpMAazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFca4M58o4pOYrcEyOybkyxiHnypDUCM6VIUmHMINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEOa3YBE90DDzzw0zkzJNXmmmuuYe7cuc0uo2EmXDDv3g3t7XDllXlWqL4+mDs3z0Z13nlw9NFw331w9dV51ql9++Caa/JsU7Nn5z42boQ5c+Dmm2HKFLjssjxD1oUXwp49eQas/j5bWqCtLc+A1daWZ6/aujW3T5t2DSedlGvq64Pjj88zXz3zDJxySt73iCPybFpPPpn72r0bnn12oH3q1DyL1lNPwYkn5p/PPTfQftRRMGkS/PjHcNJJ+XVSyve///08w1b/7+Xkk+Hxx/PsXC0t+f4xx8ALL8DTTw/0efjhcOyxsGtX/vnss7nu/vbJk3O/jskxNWJMP/jBA/T0wKxZc3/m31NnZ57xrbU1zxp38cW5radnoH3mzDxT3N13w+WXQ3c37Nw50D5rVn6trq79z4h6cnY5SeNKqbMyOrucJB3Cig/miGiPiO9FxAOV21uq2q6NiG0RsSUiLmlmnZJUL+PlHPM/pJQ+Vb0hIs4GrgLOAU4B7omIWSmlF5pRoCTVS/FHzCN4G3BLSmlfSum7wDbggibXJEkHbbwE8wci4psRcVNEHFfZdiqwvWqfHZVtkjSuFRHMEXFPRDw4xO1twCLgZcD5wE6go/9pQ3Q15CUmETE3IrojonvXrl0NGYMk1UsR55hTSm+sZb+I+CywpvJwBzCjqvk0oHeY/juBTsiXyx14pZLUeEUcMY8kIqZXPXw78GDl/u3AVRExJSLOAM4CNox1fZJUb0UcMY/ibyPifPJpih7gDwBSSg9FxArgYeB54I+8IkPSoaD4YE4pvWeEthuAG8awHElquOJPZUjSRGMwS1JhDGZJKozBLEmFmdTe3t7sGsZUR0dne1/fXFpaYMUKWLs2z8Ha0ZHnXd2+HZYty/O6Ll2a52OdMQPmzcvzxm7dmudenjkTFi6EDRvy/LELFuR5WTdtyv3297l5c563dtGi/Prr1+e5mfvbt2zJc9B2dua5bdetg1WrBtp7evI8uYsX5/lrV6/Oc8D2t/f25rqXLMExOaYJMabu7iX09sL5588pakzz51+/s729vbMeOeV8zJLGFedjliSNOYNZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwriCiatIOCbHNK7G5AomhyBXMJHGN1cwkSSNOYNZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhjMklQYg1mSCnNYswuYyDo7O7n55pubXYY0rjzwwAOcf/75zS6joSZcMO/eDe3tcOWVeRHFvj6YOzcv3njeeXD00XDffXD11XmRxn374Jpr8uKMs2fnPjZuhDlz4OabYcoUuOyyvKDkhRfCnj15wcj+PltaoK0tLxjZ1pYXe9y6Nbd/4hM38/jjD/DKV55PXx8cf3xeKPKZZ+CUU/K+RxyRF9R88snc1+7d8OyzA+1Tp+ZFJ596Ck48Mf987rmB9qOOgkmT4Mc/hpNOyuNNKd///vfzgpT9v5eTT4bHH8+LWba05PvHHAMvvABPPz3Q5+GHw7HHwq5d+eezz+a6+9snT879OibH1IgxnXXW+Uybdg1dXT/776mzMy+Q2tqaF1m9+OLc1tMz0D5zZl5Y9e674fLLobsbdu4caJ81K79WV9f+Z0Q9uRhrE5W6qKSk/edirJJ0CDOYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUmEnt7e3NrmFMdXR0tvf1zaWlBVasgLVr85LlHR15mfLt22HZsrwM+tKlefnyGTNg3ry8zPrWrbB8eV4GfeFC2LAhL7e+YEFexnzTptxvf5+bN+dl3hctyq+/fj2sXNnfvoS9e+Gii+bQ2ZmXgl+3DlatGnh+T09eVn7x4rzc++rVecn0/vbe3lz3kiUUMibYsiUvQ++YHNNEGtP8+dfvbG9v76xHTkVKqR79jButra2pu7u72WUA0NbWBkBXV1dT65B08CJiY0qptR59eSpDkgpjMEtSYQxmSSqMwSxJhTGYJakwRQRzRLwrIh6KiBcjonVQ27URsS0itkTEJVXbL61s2xYRHxn7qiWpMYoIZuBB4B3AV6o3RsTZwFXAOcClwMKImBQRk4B/BN4MnA1cXdlXksa9w5pdAEBK6VsAETG46W3ALSmlfcB3I2IbcEGlbVtK6dHK826p7Pvw2FQsSY1TyhHzcE4Ftlc93lHZNtx2SRr3xuyIOSLuAU4eoum6lNJtwz1tiG2Jof+gDPsVxoiYC8wFOP3000epVJKaa8yCOaX0xgN42g5gRtXj04Deyv3htg/12p1AJ+SvZB9AHZI0Zko/lXE7cFVETImIM4CzgA3A/cBZEXFGREwmf0B4exPrlKS6KeLDv4h4O/C/gROBOyLigZTSJSmlhyJiBflDveeBP0opvVB5zgeAu4BJwE0ppYeaVL4k1VURwZxSuhW4dZi2G4Abhth+J3Bng0uTpDFX+qkMSZpwDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSrMpPb29mbXMKY6Ojrb+/rm0tICK1bA2rUwaxZ0dEBfH2zfDsuWwfTpsHQpdHXBjBkwbx7s3g1bt8Ly5TBzJixcCBs2QEsLLFgA+/bBpk253/4+N2+GqVNh0aL8+uvXw8qV/e1L2LsXLrpoDp2dMHkyrFsHq1YNPL+nB/buhcWLYdo0WL0a1qwZaO/tzXUvWUIhY4ItWyACx+SYJtSY5s+/fmd7e3tnPXIqUppYs2C2tram7u7uZpcBQFtbGwBdXV1NrUPSwYuIjSml1tH3HJ2nMiSpMAazJBXGYJakwtQ0H3NEnAm8DpgJHAnsAr4O3JtSeqZh1UnSBDRiMEfEu4EPAa3AD8jr6v0EOB74K+CZiPgC8DcppccaXKskTQjDBnNEfIO8nNMS4MqU0vZB7VOAC8nr7XVHxB+mlP65gbVK0oQw0hHzR1NKdwzXmFLaB3QBXRHxUeCMOtcmSRPSsME8UigPse8TwBN1qUiSJrj9Wow1Io4HTmLQ1RwppYfrWZQkTWS1XpXxKuCfgPMGNwEJmFTnuiRpwqr1iPkm4HvkKzR+QA5jSVID1BrMZwHvSilta2QxkqTav/n3H8ArG1mIJCmr9Yj5d4HPVb4B+CDwXHVjSukr9S5Mkiaq/TmVcT5wyRBtfvgnSXVUazB/BlgHfBI//JOkhqo1mE8D3pJSeqSRxUiSav/w70vA7EYWIknKaj1i/legIyJ+GdjMz3/49y/1LkySJqpag3lh5edfDNHmh3+SVEc1BXNKyZVOJGmMGLiSVJhhgzki/ltERC2dRMTMiPiN+pUlSRPXSEfM7wW2RMRfRMS5g0M6Io6PiLdGxApgA/DSRhYqSRPFsMGcUno98D/Ii7BuAvZExHcj4lsR8X3ygqyfAbYB56SU1oxFwZJ0qBvxw7/KKiZ3RMQJwK8Dv0heJfsJ4BvAN1JKLza8SkmaQGq9KuMJYFWDa5Ek4VUZklQcg1mSCjOpvb292TWMqY6Ozva+vrm0tMCKFbB2LcyaBR0d0NcH27fDsmUwfTosXQpdXTBjBsybB7t3w9atsHw5zJwJCxfChg3Q0gILFsC+fbBpU+63v8/Nm2HqVFi0KL/++vWwcmV/+xL27oWLLppDZydMngzr1sGqVQPP7+mBvXth8WKYNg1Wr4Y1awbae3tz3UuWUMiYYMsWiMAxOaYJNab586/f2d7e3lmPnIqUJtYMnq2tram7u7vZZQDQ1tYGQFdXV1PrkHTwImJjSqm1Hn15KkOSClPrJEZExK8CbwBOYlCgp5Q+WOe6JGnCqimYI+LPgL8lf5mkl59dwWRinQuRpAar9Yj5Q8AHU0oLGlmMJKn2c8zHAHc2shBJUlZrMC8HLm1kIZKkbNhTGRHxJ1UPtwPXR8SvAd/k55eW+vvGlCdJE89I55j/eNDjPcBFlVu1BBjMklQnwwZzSumMsSxEkpTVdI45Ij4WEVOH2H5kRHys/mVJ0sRV64d//ws4eojtUyttkqQ6qTWYg6G/SPIq4Mn6lSNJGvELJhGxmxzICXg0IqrDeRJwBHBj48qTpIlntG/+fYB8tHwTcB3wo6q2Z4GelNJ9DapNkiak0db8WwoQEd8F1qeUnhtpf0nSwat1zb8vR8QREfEe4OzK5oeB5SmlnzSsOkmagGq9XO7VwKNAB3BB5fYp8nnnVzeuPEmaeGq9KqMT+A/gtJTSa1NKrwVmAF+ptEmS6qTWaT/PAX4rpfR0/4aU0tMR8ZdAGes0SdIhotYj5m8DpwyxfTqwtX7lSJJqPWL+KPDpyhHy1yrbXlPZ/pGIOL5/x5SSXziRpINQazCvrvy8mYFvAEbl521VjxP5iyeSpANUazD/ZkOrkCT9VM3XMTe6EElSVuuHf0TEeRGxICLWRsT0yrYrIuJVjStPkiaeWr9gcjFwP3Aq8HrgyErTy3DaT0mqq1qPmD8O/ElK6e3kyYv6dZG/BShJqpNag/kc4M4htj8JHD/EdknSAao1mH9IPo0x2KuBHfUrR5JUazDfDPxdRJxGvlb5sIh4HXkio883qjhJmohqDeaPAt8FHiOv/fcw8G/kiY1uONgiIuJdEfFQRLwYEa1V22dGxE8i4oHK7caqttkRsTkitkXEpyMihu5dksaXWq9jfg54d2VF7FeRA/0bKaXv1KmOB4F3AJ8Zou2RlNL5Q2xfBMwlf0X8TuBSYG2d6pGkpqn1m38ApJQeAR6pdxEppW8B1HrQW7mO+pj+Za0i4vPAFdQQzLt3Q3s7XHkldHVBXx/MnQudnXDeeXD00XDffXD11bBmDezbB9dcA0uWwOzZuY+NG2HOHLj5ZpgyBS67DJYvhwsvhD17YPPmgT5bWqCtDVauzD97e2Hr1tze0wOTJ+f+Vq+Giy/ObT09A8+fORNmzYK774bLL4fubti5c6B91iw45ZQ8lhLG1NkJ06dDa6tjckwTa0z1FCkNtfh11Q4RRwIfBq4EzqSyMCvwz0BHPVcwiYgu4M9SSt2VxzOBh8gz2P0Y+GhK6auV0x1/nVJ6Y2W/3wD+PKV02Wiv0dramrq7y5iptK2tDYCurq6m1iHp4EXExpRS6+h7jm60VbIPI59LfjXwr8Ad5MmKzgY+Brw5Il6XUnp+tBeKiHuAk4doui6ldNsQ2wF2AqenlPoiYjawKiLOYWACpWrD/oWJiLnk0x6cfvrpo5UqSU012qmMucDLgVenlB6qboiIc4F/r+yzcLQX6j+63R8ppX3Avsr9jRHxCDCLfIneaVW7ngb0jtBPJ5WVVlpbW0f+XwRJarLRrsp4J3DD4FAGSCk9CHyysk9DRMSJETGpcv9M4Czg0ZTSTmB3RLymcjXGbzEw/agkjWujBfM55FMZw7kHOPdgi4iIt0fEDuBC4I6IuKvS9FrgmxGxCfgi8L6qifjfD3wO2Eb+QNIrMiQdEkY7lXEcsGuE9l3AsQdbRErpVuDWIbavBFYO85xu6vBHQZJKM9oR8yRgpA/2XsQVSySprkY7Yg5gWUTsG6Z9Sp3rkaQJb7RgXlpDH86VIUl1NGIwp5R+Z6wKkSRlNS8tJUkaGwazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhjMklSYSe3t7c2uYUx1dHS29/XNpaUFVqyAtWth1izo6IC+Pti+HZYtg+nTYelS6OqCGTNg3jzYvRu2boXly2HmTFi4EDZsgJYWWLAA9u2DTZtyv/19bt4MU6fCokX59devh5Ur+9uXsHcvXHTRHDo7YfJkWLcOVq0aeH5PD+zdC4sXw7RpsHo1rFkz0N7bm+tesoRCxgRbtkAEjskxTagxzZ9//c729vbOeuRUpJTq0c+40dramrq7u5tdBgBtbW0AdHV1NbUOSQcvIjamlFrr0ZenMiSpMAazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSpMEcEcEX8XEd+OiG9GxK0RcWxV27URsS0itkTEJVXbL61s2xYRH2lO5ZJUf0UEM/Al4NyU0i8DW4FrASLibOAq4BzgUmBhREyKiEnAPwJvBs4Grq7sK0njXhHBnFK6O6X0fOXh14DTKvffBtySUtqXUvousA24oHLbllJ6NKX0LHBLZV9JGvcOa3YBQ3gv8H8r908lB3W/HZVtANsHbf/VWjrfvRva2+HKK6GrC/r6YO5c6OyE886Do4+G++6Dq6+GNWtg3z645hpYsgRmz859bNwIc+bAzTfDlClw2WWwfDlceCHs2QObNw/02dICbW2wcmX+2dsLW7fm9p4emDw597d6NVx8cW7r6Rl4/syZMGsW3H03XH45dHfDzp0D7bNmwSmn5LGUMKbOTpg+HVpbHZNjmlhjqqdIKdW3x+FeKOIe4OQhmq5LKd1W2ec6oBV4R0opRcQ/AvellJZV2hcDd5KP9C9JKf1eZft7gAtSSn88zGvPBeYCnH766bMfe+yx+g7uALW1tQHQ1dXV1DokHbyI2JhSaq1HX2N2xJxSeuNI7RHx28BlwBvSwF+LHcCMqt1OA3or94fbPtRrdwKdAK2trWPzl0iSDlAR55gj4lLgz4G3ppT2VjXdDlwVEVMi4gzgLGADcD9wVkScERGTyR8Q3j7WdUtSI5RyjnkBMAX4UkQAfC2l9L6U0kMRsQJ4GHge+KOU0gsAEfEB4C5gEnBTSumh5pQuSfVVRDCnlF4+QtsNwA1DbL+TfL5Zkg4pRZzKkCQNMJglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhjMklSYSe3t7c2uYUx1dHS29/XNpaUFVqyAtWth1izo6IC+Pti+HZYtg+nTYelS6OqCGTNg3jzYvRu2boXly2HmTFi4EDZsgJYWWLAA9u2DTZtyv/19bt4MU6fCokX59devh5Ur+9uXsHcvXHTRHDo7YfJkWLcOVq0aeH5PD+zdC4sXw7RpsHo1rFkz0N7bm+tesoRCxgRbtkAEjskxTagxzZ9//c729vbOeuRUpJTq0c+40dramrq7u5tdBgBtbW0AdHV1NbUOSQcvIjamlFrr0ZenMiSpMAazJBXGYJakwhjMklQYg1mSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwhQRzBHxdxHx7Yj4ZkTcGhHHVrbPjIifRMQDlduNVc+ZHRGbI2JbRHw6IqJ5I5Ck+ikimIEvAeemlH4Z2ApcW9X2SErp/MrtfVXbFwFzgbMqt0vHrFpJaqAigjmldHdK6fnKw68Bp420f0RMB45JKd2XUkrA54ErGlymJI2JIoJ5kPcCa6senxER34iIL0fEb1S2nQrsqNpnR2XbkCJibkR0R0T3rl276l+xJNXRYWP1QhFxD3DyEE3XpZRuq+xzHfA88IVK207g9JRSX0TMBlZFxDnAUOeT03CvnVLqBDoBWltbh91PkkowZsGcUnrjSO0R8dvAZcAbKqcnSCntA/ZV7m+MiEeAWeQj5OrTHacBvY2oW5LGWhGnMiLiUuDPgbemlPZWbT8xIiZV7p9J/pDv0ZTSTmB3RLymcjXGbwG3NaF0Saq7MTtiHsUCYArwpcpVb1+rXIHxWuAvI+J54AXgfSmlJyvPeT+wBDiSfE567eBOJWk8KiKYU0ovH2b7SmDlMG3dwLmNrEuSmqGIUxmSpAEGsyQVxmCWpMIYzJJUGINZkgpjMEtSYQxmSSqMwSxJhTGYJakwBrMkFcZglqTCGMySVBiDWZIKYzBLUmEMZkkqjMEsSYUxmCWpMAazJBXGYJakwkRKqdk1jKmI+BHwnVF2eynwowNs39+2E4AnRqlnrI02/rHuc3+fW8v+B7vPcG2+x2Pz3Fr3b8S/5eG2vyKlNK2GmkaXUppQN6DzYPcZqX1/24DuZv9ODuR3NJZ97u9z6/EeH+j77Htczntcy371eo/r/T5PxFMZq+uwz0jtB9pWkkbUeTB97u9z6/Eej7bPcG2+x2Pz3Fr3b8S/5Ya/xxPuVEZpIqI7pdTa7DrUOL7HE0M93+eJeMRcms5mF6CG8z2eGOr2PnvELEmF8YhZkgpjMEtSYQxmSSqMwVywiHhlRNwYEV+MiPc3ux7VX0RcERGfjYjbIuLiZtej+ouIMyNicUR8sdbnGMwNEhE3RcTjEfHgoO2XRsSWiNgWER8ZqY+U0rdSSu8D/gvg5VaFqdN7vCql9PvAHOC/NrBcHYA6vcePppR+d79e16syGiMiXgvsAT6fUjq3sm0SsBV4E7ADuB+4GpgEfHJQF+9NKT0eEW8FPgIsSCndPFb1a3T1eo8rz+sAvpBS+voYla8a1Pk9/mJK6Z21vO5h9Slfg6WUvhIRMwdtvgDYllJ6FCAibgHellL6JHDZMP3cDtweEXcABnNB6vEeR0QAfw2sNZTLU69/x/vLUxlj61Rge9XjHZVtQ4qItoj4dER8Briz0cWpLvbrPQb+GHgj8M6IeF8jC1Pd7O+/45aIuBF4VURcW8sLeMQ8tmKIbcOeS0opdQFdjSpGDbG/7/GngU83rhw1wP6+x33Afv3R9Yh5bO0AZlQ9Pg3obVItagzf40Nfw99jg3ls3Q+cFRFnRMRk4Crg9ibXpPryPT70Nfw9NpgbJCKWA/cBr4iIHRHxuyml54EPAHcB3wJ+az4CAAAGr0lEQVRWpJQeamadOnC+x4e+Zr3HXi4nSYXxiFmSCmMwS1JhDGZJKozBLEmFMZglqTAGsyQVxmBWsSJiQUR0jcHrtA+e1nGU/dsiIkXECQ2qZ05E/Fsj+q7htS+LiAciwmxoIn/5GlFE/EJEzI+IRyJiX0R8LyLWRsRbml3b/oqImZVAHTy39aeA1+1HV+uB6UBfpd85EbGnTjVOBv4KuL5q29SI+ERl7t9nIuKJiLg3Iq4e4vk3RsQ/HOjrp5TWAC8A7z7QPnTwnMRIw6pMd3gvsBu4FthE/mP+BuBG4PRm1VZPKaU95Dl3a93/WeD7DSrnncAzKaUvV227Efg14EPAg8DxwK9Wfv5UZQrRyzn4UP0n4IPA/znIfnSgUkrevA15I0812gscPUTbcVX3TwduJQf4buBfgNOq2tvJgXIV8Ehln1XACVX7TCIfuf6wcpsHLAK6qvbpIi8YUF3HEmBN1eMA/hT4DrCPPOHMJyttadCtq7q+yv1LgGeBlkGv8wlgU+V+W+X5J1Tdr761Ax/r73NQP/cCnx7hd74G+PtB254Cfq+G9+sC8lH8YVXjfT9wG7CXPLn7b5In3bkLeBp4AHj1oH5Orzz35c3+b3Ci3jyVoSFFxPHApeQg/LmjyZTSDyv7BTlkfwF4Pfkf/inAqkpbv5nkpZPeDlwMvAq4oar9T4HfB/4AuJAc1Ady5PcJ4H+SV5I4B3gXA3PnXlD5eSn5VMQ7hnj+PeRwe1f/hso4rgaWDbH/euC/k4NveuX2KeAm4Jci4oKqfl4BXAQsHqH+Xwe6B237PnBpRLx0hOcBXAHckfJcDv0+CtwC/Eql3+WV119Ifg96yX/cfiql9J/AD9i/0zuqp2b/ZfBW5o0cYgl4+yj7vYl8TnJm1bYzgReBN1YetwPPAC+t2uc68ioQ/Y97geuqHr+EfITXVbWtixGOmIGjK6/zvmFqnVkZU+ug7e1UHd0C/wB8terxr1fGeGrlcVulnxMqj+cAe4Z4vTXAjVWP/wboHuF3eWyl398ctP215D8uzwFfBxYAbxri+Q8B76h6nKj830Ll8bmVbX9Ste1nxlK1/evAx5v93+FEvXnErOEMNRn4UF4J9KaUevo3pLzkTi9wdtV+j6WUflT1uBc4CaByJDidPItXfx8vAv9vP2s+G5gCrNvP5w22DPi1iPjFyuN3k/9AfG8/+/kscFVEHFlZJ+49jHy0fGTl5zPVG1NKXyH/sXs9sAKYBdxdWdkGgIh4eWWfuwb1+c2q+z+o/Nw8xLaTBj3vJ1X1aIwZzBrOd8hHUq8cZb9g+NUbqrc/N0Tb/v739yI//wfj8EG1HLSU0kbg28A1EXE4+bTGUKcxRnMH+RTHlcBbyEfEy0fYv4/8ezluiJqeSyl9NaX01ymli8mna+ZWrUd3BbAupfT0oKdW/97TCNsGvxfHA7tGqFUNZDBrSCmlJ8lHXx+IiKMHt0fEsZW7DwOnVi9YGRFnks8zP1zja/0I2Am8pqqPYOCccL9d5CPrar9Sdf9h8gd+bxjmpZ6t/JxUQ1lfIB8pXwocBawcYd9nh+oz5XO9S4D3Vm7/klJ6arhOUr7a42F+9v80htP/u+1/b95GPtd/0CLiCOBl5NMZagKDWSP5Q/JRaHdEvCsiXhERvxQR72fgf5HvIV9G94WImF25RvgL5H/U+/MlifnAhyPinZUPyebx8yH8b8CbI+KtlVr+nqolflJKuyv9fDIificiXhYRF1TqBXic/L/ol1Suzx7pw7Rl5ID8OHB7SunHI+zbAxwREW+KiBMiYmpV2+fIH6JdxsinMfrdRT6n/VMR0RURf1D5/c6sXEP+CWAL8K2IOJH8R211Df3X4jXkP3D31qk/7SeDWcNKKX0XeDXwJfIHV98kh+NbyVdPkPInRVeQj2a7gH8nX0VwRaWtVh3k62c/Rz63/BJywFe7qep2L/na41sH7XNtpdb/SV5dYiX58rD+I9gPAr9HPsd92whjfwz4D/IR+YinMVJK68nXGi8n/x4+XNX2KPBl4D+pbWHdz5KvwKi+Rvku8vnpu8inWBYCXyV/APgC+drl+1NKPxjc2QG6GvhCSmlvnfrTfnIFE6nBIuJhctDdMOrOef9bgIdSSh+vcf/bgHtTSn97EGX293UiOfxbK3+Y1QQeMUsNEhEnRcSHyJfpfWaU3at9GBjp1Mlg9zLyh4r74wzgDw3l5vKIWWqQiEjAE+Trhv16s2pmMEtSYTyVIUmFMZglqTAGsyQVxmCWpMIYzJJUGINZkgrz/wEwastXNHzAfAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = subplots(1,1, figsize=(5, 8))\n", "Utils1D.plotLayer(sig, mesh1D, showlayers=True)" @@ -508,7 +254,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/EM1D_inversion_TD_layers.ipynb b/notebooks/examples/EM1D_inversion_TD_layers.ipynb deleted file mode 100644 index 0a4b2bc..0000000 --- a/notebooks/examples/EM1D_inversion_TD_layers.ipynb +++ /dev/null @@ -1,534 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\sgkan\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\IPython\\core\\magics\\pylab.py:160: UserWarning: pylab import has clobbered these variables: ['time']\n", - "`%matplotlib` prevents importing * from pylab and numpy\n", - " \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n" - ] - } - ], - "source": [ - "from SimPEG import *\n", - "from simpegEM1D import (\n", - " EM1D, EM1DSurveyTD, Utils1D, get_vertical_discretization_time, \n", - " set_mesh_1d, skytem_HM_2015\n", - ")\n", - "import numpy as np\n", - "%pylab inline" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [], - "source": [ - "from simpegEM1D import skytem_HM_2015\n", - "time = np.logspace(-5, -2, 31)\n", - "hz = get_vertical_discretization_time(time, facter_tmax=0.3, factor_tmin=10., n_layer=19)\n", - "mesh1D = set_mesh_1d(hz)\n", - "depth = -mesh1D.gridN[:-1]\n", - "LocSigZ = -mesh1D.gridCC\n", - "TDsurvey = EM1DSurveyTD(\n", - " rx_location = np.array([0., 0., 100.+30.]),\n", - " src_location = np.array([0., 0., 100.+30.]),\n", - " topo = np.r_[0., 0., 100.],\n", - " depth = depth,\n", - " rx_type = 'dBzdt',\n", - " wave_type = 'stepoff',\n", - " src_type = 'CircularLoop',\n", - " a = 13.,\n", - " I = 1.,\n", - " time = time,\n", - " base_frequency = 25.,\n", - " use_lowpass_filter=False,\n", - " high_cut_frequency=210*1e3 \n", - ")\n", - "sig_half = 1./20.\n", - "# sig_blk = sig_half * 20.\n", - "chi_half = 0.\n", - "expmap = Maps.ExpMap(mesh1D)" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [], - "source": [ - "# two_layer_map = TwoLayerMap(mesh, logSigma=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [], - "source": [ - "sig = np.ones(TDsurvey.n_layer)*sig_half\n", - "blk_ind = (-30>LocSigZ) & (-70]" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = subplots(1,1, figsize=(5, 8))\n", - "Utils1D.plotLayer(sig, mesh1D, showlayers=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Wall time: 63.8 ms\n" - ] - } - ], - "source": [ - "%%time\n", - "prob = EM1D(mesh1D, sigmaMap=expmap, verbose=False)\n", - "if prob.ispaired:\n", - " prob.unpair()\n", - "if TDsurvey.ispaired:\n", - " TDsurvey.unpair()\n", - "prob.pair(TDsurvey)\n", - "prob.chi = np.zeros(TDsurvey.n_layer)\n", - "d_true = TDsurvey.dpred(m_true)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [], - "source": [ - "J = prob.getJ_sigma(m_true)" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "i_time=10\n", - "for i_time in range(0, time.size, 3):\n", - " plt.plot(mesh1D.vectorCCx, J[i_time,:])\n", - "plt.yscale('symlog', linthreshy=1e-8)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.,\n", - " 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5., 5.])" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(116,)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "TDsurvey.frequency.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = subplots(1,1, figsize = (7,5))\n", - "axes.plot(TDsurvey.time, -d_true, '.-')\n", - "axes.set_xscale('log');\n", - "axes.set_yscale('log');" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "np.random.seed(1)\n", - "TDsurvey.dtrue = d_true\n", - "std = 0.05\n", - "noise = std*abs(TDsurvey.dtrue)*np.random.randn(*TDsurvey.dtrue.shape)\n", - "floor = 0.\n", - "std = 0.07\n", - "TDsurvey.dobs = TDsurvey.dtrue+noise\n", - "uncert = abs(TDsurvey.dobs)*std+floor" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = subplots(1,1, figsize = (7,5))\n", - "axes.plot(TDsurvey.time, -d_true, 'b.-')\n", - "axes.plot(TDsurvey.time, -TDsurvey.dobs, 'r.-')\n", - "axes.set_xscale('log');\n", - "axes.set_yscale('log');" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||\n" - ] - } - ], - "source": [ - "dmisfit = DataMisfit.l2_DataMisfit(TDsurvey)\n", - "uncert = (abs(TDsurvey.dobs)*std+floor)\n", - "dmisfit.W = 1./ uncert" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "m0 = np.log(np.ones_like(sig)*sig_half)\n", - "d_0 = TDsurvey.dpred(m0)\n", - "# delta = prob.get_threshold(uncert)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "reg = Regularization.Sparse(\n", - " mesh1D,\n", - " mapping=Maps.IdentityMap(mesh1D),\n", - " alpha_s=1.,\n", - " alpha_x=1.\n", - ")\n", - "p = 0\n", - "qx, qz = 2., 2.\n", - "reg.norms = np.c_[p, qx, qz, 0.]\n", - "IRLS = Directives.Update_IRLS(\n", - " maxIRLSiter=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, betaSearch=False,\n", - " chifact_start = 1.\n", - ")\n", - "opt = Optimization.ProjectedGNCG(maxIter = 25)\n", - "invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)\n", - "beta = Directives.BetaSchedule(coolingFactor=2., coolingRate=1)\n", - "betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1e0)\n", - "target = Directives.TargetMisfit()\n", - "# update_sense = Directives.UpdateSensitivityWeights(threshold=delta)\n", - "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS, betaest])\n", - "inv = Inversion.BaseInversion(invProb, directiveList=[beta, betaest, target])\n", - "prob.counter = opt.counter = Utils.Counter()\n", - "opt.LSshorten = 0.5\n", - "opt.remember('xc')" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SimPEG.InvProblem will set Regularization.mref to m0.\n", - "\n", - " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", - " ***Done using same Solver and solverOpts as the problem***\n", - "model has any nan: 0\n", - "=============================== Projected GNCG ===============================\n", - " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", - "-----------------------------------------------------------------------------\n", - "x0 has any nan: 0\n", - " 0 3.32e+01 5.47e+02 0.00e+00 5.47e+02 2.77e+02 0 \n", - " 1 1.66e+01 3.57e+02 1.34e+00 3.79e+02 6.65e+01 0 \n", - " 2 8.29e+00 2.05e+02 5.53e+00 2.51e+02 7.46e+01 0 Skip BFGS \n", - " 3 4.15e+00 5.46e+01 1.40e+01 1.13e+02 4.49e+01 0 \n", - " 4 2.07e+00 1.73e+01 1.62e+01 5.09e+01 3.52e+01 0 \n", - " 5 1.04e+00 7.93e+00 1.59e+01 2.44e+01 8.24e+00 0 Skip BFGS \n", - "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 5.4768e+01\n", - "1 : |xc-x_last| = 2.8751e-01 <= tolX*(1+|x0|) = 1.1037e+00\n", - "0 : |proj(x-g)-x| = 8.2367e+00 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 8.2367e+00 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 25 <= iter = 6\n", - "------------------------- DONE! -------------------------\n", - "CPU times: user 2.54 s, sys: 47.5 ms, total: 2.59 s\n", - "Wall time: 1.62 s\n" - ] - } - ], - "source": [ - "%%time\n", - "mopt = inv.run(m0)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counters:\n", - " ProjectedGNCG.activeSet : 6\n", - " ProjectedGNCG.doEndIteration : 6\n", - " ProjectedGNCG.doStartIteration : 6\n", - " ProjectedGNCG.projection : 27\n", - " ProjectedGNCG.scaleSearchDirection : 6\n", - "\n", - "Times: mean sum\n", - " EM1D.Jtvec_approx : 6.60e-04, 2.37e-02, 36x\n", - " EM1D.Jvec_approx : 3.95e-03, 1.42e-01, 36x\n", - " ProjectedGNCG.findSearchDirection : 3.25e-02, 1.95e-01, 6x\n", - " ProjectedGNCG.minimize : 1.58e+00, 1.58e+00, 1x\n", - " ProjectedGNCG.modifySearchDirection : 7.02e-02, 4.21e-01, 6x\n" - ] - } - ], - "source": [ - "opt.counter.summary()\n", - "xc = opt.recall('xc')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = subplots(1,1, figsize=(5, 8))\n", - "Utils1D.plotLayer(sig, mesh1D)\n", - "Utils1D.plotLayer(expmap*mopt, mesh1D, showlayers=False, **{'color':'r'})\n", - "# Utils1D.plotLayer(expmap*invProb.l2model, mesh1D, showlayers=False, **{'color':'b', 'lw':1.})" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1,1, figsize = (7,5))\n", - "axes.plot(TDsurvey.time, -invProb.dpred, 'b-')\n", - "axes.plot(TDsurvey.time, -TDsurvey.dobs, 'bx')\n", - "axes.set_xscale('log');\n", - "axes.set_yscale('log');" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pyMKL" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/notebooks/examples/EM1D_simulation_skytem_lowpass_filter.ipynb b/notebooks/examples/EM1D_simulation_skytem_lowpass_filter.ipynb index 7c566cb..c173811 100644 --- a/notebooks/examples/EM1D_simulation_skytem_lowpass_filter.ipynb +++ b/notebooks/examples/EM1D_simulation_skytem_lowpass_filter.ipynb @@ -169,7 +169,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/Test_global_em1d_inversion.ipynb b/notebooks/examples/Test_global_em1d_inversion.ipynb index c725cbc..041f06f 100644 --- a/notebooks/examples/Test_global_em1d_inversion.ipynb +++ b/notebooks/examples/Test_global_em1d_inversion.ipynb @@ -14,13 +14,16 @@ } ], "source": [ - "from SimPEG import Mesh, Maps\n", + "from SimPEG import maps, data\n", "import numpy as np\n", + "from discretize import TensorMesh\n", "from matplotlib.colors import LogNorm\n", - "from simpegEM1D import (\n", - " GlobalEM1DProblemFD, GlobalEM1DSurveyFD, get_vertical_discretization_frequency\n", + "from simpegEM1D.simulation_stitched1d_original import (\n", + " GlobalEM1DSimulationFD, GlobalEM1DSurveyFD\n", ")\n", + "from simpegEM1D.EM1DSimulation_original import get_vertical_discretization_frequency\n", "from pymatsolver import PardisoSolver\n", + "from simpegEM1D.EM1DSimulation_original import *\n", "%pylab inline" ] }, @@ -72,7 +75,7 @@ "n_sounding = 50\n", "dx = 100.\n", "hx = np.ones(n_sounding) * dx\n", - "mesh = Mesh.TensorMesh([hx, hz], x0='00')\n", + "mesh = TensorMesh([hx, hz], x0='00')\n", "inds = mesh.gridCC[:,1]<25\n", "sigma = np.ones(mesh.nC) * 1./20.\n", "sigma[inds] = 1./30.\n", @@ -95,7 +98,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -145,7 +148,7 @@ } ], "source": [ - "mapping = Maps.ExpMap(mesh)\n", + "mapping = maps.ExpMap(mesh)\n", "# mapping = Maps.IdentityMap(mesh)\n", "survey = GlobalEM1DSurveyFD(\n", " rx_locations = rx_locations,\n", @@ -157,14 +160,13 @@ " field_type = 'secondary',\n", " topo = topo\n", ")\n", - "prob = GlobalEM1DProblemFD(\n", - " mesh, sigmaMap=mapping, chi=chi, hz=hz, parallel=True, n_cpu=2, verbose=True,\n", + "sim = GlobalEM1DSimulationFD(\n", + " mesh, survey=survey, sigmaMap=mapping, chi=chi, hz=hz, parallel=True, n_cpu=2, verbose=True,\n", " Solver=PardisoSolver\n", ")\n", - "prob.pair(survey)\n", + "\n", "m = np.log(sigma_em1d)\n", - "# m = sigma_em1d.copy()\n", - "prob.model = m" + "# m = sigma_em1d.copy()" ] }, { @@ -177,19 +179,70 @@ "output_type": "stream", "text": [ "Compute fields\n", - ">> Compute response\n", - "SimPEG.Survey assigned new std of 3.00%\n" + ">> Compute response\n" ] } ], "source": [ "# %%time\n", - "dobs = survey.makeSyntheticData(m, std=0.03, force=True)" + "# dobs = sim.makeSyntheticData(m, std=0.03, force=True)\n", + "d_true = sim.dpred(m)\n", + "std = 0.03\n", + "floor = 0.\n", + "np.random.seed(1)\n", + "uncert = std*abs(d_true)+floor\n", + "noise = std*np.abs(d_true)*np.random.randn(len(d_true))\n", + "d_obs = d_true + noise\n" ] }, { "cell_type": "code", "execution_count": 10, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "J_sigma matrix shape\n", + "(18000,)\n", + "IJLayers shapes\n", + "(18000,)\n", + "(18000,)\n" + ] + } + ], + "source": [ + "m0 = np.ones(mesh.nC) * np.log(1./20.)\n", + "mapping = maps.ExpMap(mesh)\n", + "sim.sigmaMap = mapping\n", + "sim._Jmatrix_sigma = [\n", + " run_simulation_FD(sim.input_args(i, jac_switch='sensitivity_sigma')) for i in range(sim.n_sounding)\n", + "]\n", + "print(\"J_sigma matrix shape\")\n", + "sim._Jmatrix_sigma = np.hstack(sim._Jmatrix_sigma)\n", + "print(sim._Jmatrix_sigma.shape)\n", + "print(\"IJLayers shapes\")\n", + "for x in sim.IJLayers:\n", + " print(x.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "J = sim.getJ_sigma(m0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -198,13 +251,13 @@ "Text(0, 0.5, 'Hz/Hp (ppm)')" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -216,7 +269,7 @@ } ], "source": [ - "DOBS = dobs.reshape(( prob.n_sounding, 2, survey.n_frequency))\n", + "DOBS = d_obs.reshape(( sim.n_sounding, 2, survey.n_frequency))\n", "i_freq=0\n", "plt.semilogy(mesh.vectorCCx, DOBS[:,0,i_freq], 'k')\n", "plt.semilogy(mesh.vectorCCx, DOBS[:,1,i_freq], 'b') \n", @@ -231,25 +284,25 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "from SimPEG import (\n", - " Regularization, Directives, Inversion, InvProblem, Optimization, DataMisfit, Utils\n", + " regularization, directives, inversion, inverse_problem, optimization, data_misfit, utils\n", ")\n", "from simpegEM1D import get_2d_mesh, LateralConstraint" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def run_inversion(option=None, ps=2, px=2, pz=2, alpha_s=1., alpha_x=1., alpha_z=1.):\n", " \n", - " mapping = Maps.ExpMap(mesh)\n", + " mapping = maps.ExpMap(mesh)\n", " # mapping = Maps.IdentityMap(mesh)\n", " survey = GlobalEM1DSurveyFD(\n", " rx_locations = rx_locations,\n", @@ -261,16 +314,22 @@ " field_type = 'secondary',\n", " topo = topo\n", " )\n", - " survey.dobs = dobs\n", - " prob = GlobalEM1DProblemFD(\n", - " mesh, sigmaMap=mapping, chi=chi, hz=hz, parallel=True, n_cpu=2, verbose=True,\n", + "\n", + " sim = GlobalEM1DSimulationFD(\n", + " mesh, survey=survey, sigmaMap=mapping, chi=chi, hz=hz, parallel=True, n_cpu=2, verbose=True,\n", " Solver=PardisoSolver\n", " )\n", - " prob.pair(survey)\n", + "\n", "# m = np.log(sigma_em1d)\n", "\n", + " std = 0.03\n", + " floor = 0.\n", + " np.random.seed(1)\n", + " uncert = std*abs(d_obs)+floor\n", + " dataObj = data.Data(survey, dobs=d_obs, noise_floor=uncert)\n", + " \n", " mesh_reg = get_2d_mesh(n_sounding, hz)\n", - " regmap = Maps.IdentityMap(mesh_reg)\n", + " regmap = maps.IdentityMap(mesh_reg)\n", " # mapping is required ... for IRLS\n", " reg = LateralConstraint(\n", " mesh_reg, mapping=regmap,\n", @@ -278,42 +337,41 @@ " alpha_x = alpha_x,\n", " alpha_y = alpha_z,\n", " )\n", - " xy = Utils.ndgrid(np.arange(n_sounding), np.r_[0.])\n", + " xy = utils.ndgrid(np.arange(n_sounding), np.r_[0.])\n", " reg.get_grad_horizontal(xy, hz, dim=2, use_cell_weights=True)\n", - " std = 0.03\n", - " floor = 0.\n", - " np.random.seed(1)\n", - " uncert = std*abs(dobs)+floor\n", + " \n", + " \n", " m0 = np.ones(mesh_reg.nC) * np.log(1./20.)\n", "# m0 = np.ones(mesh_reg.nC) *1./20.\n", - " dmisfit = DataMisfit.l2_DataMisfit(survey)\n", + " dmisfit = data_misfit.L2DataMisfit(dataObj, sim)\n", " dmisfit.W = 1./uncert\n", " ps = ps\n", " px, pz = px, pz\n", " reg.norms = np.c_[ps, px, pz, 0.]\n", - " IRLS = Directives.Update_IRLS(\n", - " maxIRLSiter=30, minGNiter=1, \n", + " IRLS = directives.Update_IRLS(\n", + " max_irls_iterations=30, minGNiter=1, \n", " fix_Jmatrix=True, \n", - " betaSearch=True,\n", " f_min_change = 1e-4,\n", " coolingRate=3\n", " )\n", - " opt = Optimization.InexactGaussNewton(maxIter = 40, maxIterCG=20)\n", - " invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)\n", - " beta = Directives.BetaSchedule(coolingFactor=2, coolingRate=1)\n", - " betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", - " target = Directives.TargetMisfit()\n", - " sense = Directives.UpdateSensitivityWeights()\n", - " update_precon = Directives.UpdatePreconditioner()\n", + " opt = optimization.InexactGaussNewton(maxIter = 40, maxIterCG=20)\n", + " \n", + " invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)\n", + " \n", + " beta = directives.BetaSchedule(coolingFactor=2, coolingRate=1)\n", + " sense = directives.UpdateSensitivityWeights()\n", + " betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", + " target = directives.TargetMisfit()\n", + " update_precon = directives.UpdatePreconditioner()\n", " if option is None:\n", " reg.alpha_x=0.\n", - " inv = Inversion.BaseInversion(invProb, directiveList=[beta,betaest,target, sense]) \n", + " inv = inversion.BaseInversion(invProb, directiveList=[beta,sense,betaest,target]) \n", " elif option == \"l2\":\n", " reg.alpha_x=10. \n", - " inv = Inversion.BaseInversion(invProb, directiveList=[beta, betaest, target, sense])\n", + " inv = inversion.BaseInversion(invProb, directiveList=[beta, sense, betaest, target])\n", " elif option == \"l0\":\n", - " inv = Inversion.BaseInversion(invProb, directiveList=[IRLS, betaest, sense])\n", - " prob.counter = opt.counter = Utils.Counter()\n", + " inv = inversion.BaseInversion(invProb, directiveList=[IRLS, sense, betaest])\n", + "# prob.counter = opt.counter = Utils.Counter()\n", " opt.LSshorten = 0.5\n", " opt.remember('xc')\n", "# print (reg.cell_weights)\n", @@ -321,12 +379,12 @@ " if option == 'l0':\n", " return mopt, invProb.l2model, invProb.dpred\n", " else:\n", - " return mopt, invProb.dpred" + " return mopt, None, invProb.dpred" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": { "scrolled": false }, @@ -337,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -346,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": { "scrolled": false }, @@ -357,218 +415,44 @@ "text": [ ">> Use multiprocessing for parallelization\n", ">> n_cpu: 2\n", - "SimPEG.DataMisfit.l2_DataMisfit assigning default std of 5%\n", - "SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||\n", "SimPEG.InvProblem will set Regularization.mref to m0.\n", "\n", - " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", - " ***Done using same Solver and solverOpts as the problem***\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/sgkang/Projects/simpeg/SimPEG/Directives.py:935: UserWarning: Without a Linear preconditioner, convergence may be slow. Consider adding `Directives.UpdatePreconditioner` to your directives list\n", - " \"Without a Linear preconditioner, convergence may be slow. \"\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same Solver and solverOpts as the problem***\n", + ">> Compute J sigma\n", "Compute fields\n", ">> Compute response\n", - ">> Compute J sigma\n", "model has any nan: 0\n", "============================ Inexact Gauss Newton ============================\n", " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", "-----------------------------------------------------------------------------\n", "x0 has any nan: 0\n", - " 0 6.03e+00 2.57e+04 0.00e+00 2.57e+04 6.27e+03 0 \n", + " 0 3.43e+02 2.50e+04 0.00e+00 2.50e+04 6.16e+03 0 \n", "Compute fields\n", ">> Compute response\n", ">> Compute J sigma\n", - " 1 6.03e+00 1.29e+03 1.72e+01 1.40e+03 6.82e+02 0 \n", + " 1 1.71e+02 3.02e+03 1.02e+01 4.77e+03 1.01e+03 0 \n", "Compute fields\n", ">> Compute response\n", ">> Compute J sigma\n", - " 2 6.03e+00 3.07e+02 2.45e+01 4.54e+02 1.65e+02 0 Skip BFGS \n", + " 2 8.57e+01 9.78e+02 1.59e+01 2.34e+03 3.72e+02 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", - "Reached starting chifact with l2-norm regularization: Start IRLS steps...\n", - "eps_p: 0.6342385711563501 eps_q: 0.6342385711563501\n", - ">> Fix Jmatrix\n", - "delta phim: inf\n", ">> Compute J sigma\n", - " 3 3.02e+00 2.18e+02 4.20e+01 3.44e+02 7.06e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 5.33e+00 2.18e+02 4.20e+01 4.42e+02 5.69e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 9.09e+00 2.18e+02 4.20e+01 6.00e+02 5.59e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.50e+01 2.18e+02 4.20e+01 8.48e+02 9.86e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 2.35e+01 2.18e+02 4.20e+01 1.21e+03 1.84e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 1.776e+00\n", - " 4 2.35e+01 3.12e+02 3.32e+01 1.09e+03 3.82e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 9.840e-02\n", - " 5 2.35e+01 3.04e+02 3.52e+01 1.13e+03 1.06e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.641e-01\n", - " 6 2.35e+01 3.03e+02 3.78e+01 1.19e+03 2.17e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.166e-01\n", - " 7 2.35e+01 3.03e+02 4.03e+01 1.25e+03 2.69e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 1.761e-01\n", - " 8 2.35e+01 2.96e+02 4.36e+01 1.32e+03 4.64e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 1.406e-01\n", - " 9 2.35e+01 3.06e+02 4.65e+01 1.40e+03 4.60e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 9.411e-02\n", - " 10 2.35e+01 3.21e+02 4.93e+01 1.48e+03 5.40e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 10 1.90e+01 3.21e+02 4.93e+01 1.26e+03 4.89e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 6.124e-02\n", - " 11 1.90e+01 3.10e+02 5.23e+01 1.31e+03 5.38e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 4.119e-02\n", - " 12 1.90e+01 3.20e+02 5.03e+01 1.28e+03 6.56e+01 1 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 12 1.57e+01 3.20e+02 5.03e+01 1.11e+03 7.41e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 5.109e-02\n", - " 13 1.57e+01 3.18e+02 5.03e+01 1.11e+03 6.96e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", + " 3 4.29e+01 5.26e+02 1.94e+01 1.36e+03 2.06e+02 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 8.940e-03\n", - " 14 1.57e+01 3.24e+02 4.69e+01 1.06e+03 7.76e+01 1 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 14 1.30e+01 3.24e+02 4.69e+01 9.33e+02 9.33e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.850e-02\n", - " 15 1.30e+01 3.17e+02 4.46e+01 8.96e+02 7.88e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.516e-02\n", - " 16 1.30e+01 3.15e+02 4.12e+01 8.50e+02 7.11e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.676e-02\n", - " 17 1.30e+01 3.09e+02 3.75e+01 7.96e+02 5.82e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.648e-02\n", - " 18 1.30e+01 3.03e+02 3.40e+01 7.45e+02 5.12e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.468e-02\n", - " 19 1.30e+01 2.96e+02 3.10e+01 6.98e+02 4.57e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 2.168e-02\n", - " 20 1.30e+01 2.91e+02 2.83e+01 6.57e+02 4.21e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 1.929e-02\n", - " 21 1.30e+01 2.86e+02 2.60e+01 6.23e+02 3.90e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 1.520e-02\n", - " 22 1.30e+01 2.83e+02 2.40e+01 5.96e+02 3.47e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 9.436e-03\n", - " 23 1.30e+01 2.81e+02 2.24e+01 5.72e+02 3.18e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 4.275e-03\n", - " 24 1.30e+01 2.79e+02 2.11e+01 5.53e+02 3.10e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 7.674e-04\n", - " 25 1.30e+01 2.78e+02 1.98e+01 5.36e+02 2.99e+01 0 \n", + ">> Compute J sigma\n", + " 4 2.14e+01 3.48e+02 2.22e+01 8.23e+02 1.17e+02 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", - ">> Fix Jmatrix\n", - "delta phim: 1.528e-05\n", - "Minimum decrease in regularization.End of IRLS\n", + ">> Compute J sigma\n", "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 2.5682e+03\n", - "1 : |xc-x_last| = 3.6111e-01 <= tolX*(1+|x0|) = 1.1702e+01\n", - "0 : |proj(x-g)-x| = 2.9863e+01 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 2.9863e+01 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 40 <= iter = 26\n", + "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 2.5002e+03\n", + "1 : |xc-x_last| = 1.1827e+00 <= tolX*(1+|x0|) = 1.1702e+01\n", + "0 : |proj(x-g)-x| = 1.1748e+02 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 1.1748e+02 <= 1e3*eps = 1.0000e-02\n", + "0 : maxIter = 40 <= iter = 5\n", "------------------------- DONE! -------------------------\n" ] } @@ -579,7 +463,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": { "scrolled": false }, @@ -590,21 +474,18 @@ "text": [ ">> Use multiprocessing for parallelization\n", ">> n_cpu: 2\n", - "SimPEG.DataMisfit.l2_DataMisfit assigning default std of 5%\n", - "SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||\n", "SimPEG.InvProblem will set Regularization.mref to m0.\n", "\n", - " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", - " ***Done using same Solver and solverOpts as the problem***\n", - "Compute fields\n", - ">> Compute response\n" + " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same Solver and solverOpts as the problem***\n", + ">> Compute J sigma\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/sgkang/Projects/simpeg/SimPEG/Directives.py:935: UserWarning: Without a Linear preconditioner, convergence may be slow. Consider adding `Directives.UpdatePreconditioner` to your directives list\n", + "D:\\Documents\\Repositories\\simpeg\\SimPEG\\directives.py:916: UserWarning: Without a Linear preconditioner, convergence may be slow. Consider adding `Directives.UpdatePreconditioner` to your directives list\n", " \"Without a Linear preconditioner, convergence may be slow. \"\n" ] }, @@ -612,264 +493,159 @@ "name": "stdout", "output_type": "stream", "text": [ - ">> Compute J sigma\n", + "Compute fields\n", + ">> Compute response\n", "model has any nan: 0\n", "============================ Inexact Gauss Newton ============================\n", " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", "-----------------------------------------------------------------------------\n", "x0 has any nan: 0\n", - " 0 7.15e+00 2.57e+04 0.00e+00 2.57e+04 6.27e+03 0 \n", + " 0 4.98e+02 2.50e+04 0.00e+00 2.50e+04 6.16e+03 0 \n", "Compute fields\n", ">> Compute response\n", ">> Compute J sigma\n", - " 1 7.15e+00 1.59e+03 2.63e-01 1.59e+03 8.19e+02 0 \n", + " 1 4.98e+02 1.53e+03 2.52e-01 1.65e+03 7.68e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Compute J sigma\n", - " 2 7.15e+00 3.19e+02 2.10e+00 3.35e+02 2.30e+02 0 Skip BFGS \n", + " 2 4.98e+02 3.87e+02 3.53e-01 5.63e+02 7.87e+01 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", - "Reached starting chifact with l2-norm regularization: Start IRLS steps...\n", - "eps_p: 0.7908770648777925 eps_q: 0.7908770648777925\n", - ">> Fix Jmatrix\n", - "delta phim: inf\n", ">> Compute J sigma\n", - " 3 3.57e+00 2.17e+02 3.03e+00 2.28e+02 1.03e+02 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 6.39e+00 2.17e+02 3.03e+00 2.36e+02 1.01e+02 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.12e+01 2.17e+02 3.03e+00 2.51e+02 1.07e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.97e+01 2.17e+02 3.03e+00 2.76e+02 1.35e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 3.44e+01 2.17e+02 3.03e+00 3.21e+02 2.12e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 5.99e+01 2.17e+02 3.03e+00 3.98e+02 3.68e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.02e+02 2.17e+02 3.03e+00 5.26e+02 6.39e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.64e+02 2.17e+02 3.03e+00 7.15e+02 1.05e+03 0 \n", + " 3 2.49e+02 3.42e+02 3.93e-01 4.40e+02 7.40e+01 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", + "Reached starting chifact with l2-norm regularization: Start IRLS steps...\n", + "eps_p: 0.48452322852378993 eps_q: 0.48452322852378993\n", ">> Fix Jmatrix\n", - "delta phim: 4.474e-01\n", - " 4 1.64e+02 2.72e+02 7.46e-01 3.95e+02 1.89e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 4 2.58e+02 2.72e+02 7.46e-01 4.65e+02 3.08e+02 0 \n", + ">> Compute J sigma\n", + " 4 2.49e+02 2.96e+02 4.09e-01 3.98e+02 2.08e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 2.319e-01\n", - " 5 2.58e+02 2.73e+02 5.24e-01 4.08e+02 2.47e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 5 4.02e+02 2.73e+02 5.24e-01 4.84e+02 4.40e+02 0 \n", + " 5 3.88e+02 2.69e+02 5.87e-01 4.97e+02 7.65e+01 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 5.853e-02\n", - " 6 4.02e+02 2.77e+02 5.47e-01 4.97e+02 3.67e+02 0 \n", + " 6 3.88e+02 3.11e+02 4.01e-01 4.67e+02 9.75e+00 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 3.577e-02\n", - " 7 4.02e+02 2.85e+02 4.85e-01 4.80e+02 2.25e+02 0 \n", + " 7 3.88e+02 3.05e+02 4.61e-01 4.84e+02 1.33e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 2.101e-03\n", - " 8 4.02e+02 3.15e+02 4.14e-01 4.82e+02 6.68e+01 0 Skip BFGS \n", + " 8 3.88e+02 3.17e+02 4.43e-01 4.89e+02 6.18e+00 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 6.949e-02\n", - " 9 4.02e+02 3.18e+02 3.94e-01 4.76e+02 5.13e+01 0 \n", + " 9 3.88e+02 3.22e+02 4.53e-01 4.98e+02 7.70e+00 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.046e-02\n", - " 10 4.02e+02 3.19e+02 3.91e-01 4.76e+02 2.73e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", + " 10 3.88e+02 3.29e+02 4.55e-01 5.06e+02 7.53e+00 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 7.852e-02\n", - " 11 4.02e+02 3.19e+02 4.14e-01 4.86e+02 2.56e+01 1 \n", + " 11 3.19e+02 3.36e+02 4.60e-01 4.82e+02 2.26e+01 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.457e-02\n", - " 12 4.02e+02 3.27e+02 4.12e-01 4.93e+02 2.37e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 12 3.32e+02 3.27e+02 4.12e-01 4.64e+02 2.33e+01 0 \n", + " 12 3.19e+02 3.28e+02 5.33e-01 4.98e+02 1.46e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 5.539e-02\n", - " 13 3.32e+02 3.26e+02 4.49e-01 4.75e+02 1.96e+01 0 \n", + " 13 2.60e+02 3.40e+02 5.18e-01 4.75e+02 2.29e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.450e-01\n", - " 14 3.32e+02 3.26e+02 4.74e-01 4.83e+02 2.24e+01 0 \n", + " 14 2.15e+02 3.32e+02 6.14e-01 4.64e+02 2.02e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.436e-01\n", - " 15 3.32e+02 3.26e+02 5.01e-01 4.93e+02 2.67e+01 0 \n", + " 15 1.79e+02 3.30e+02 6.90e-01 4.54e+02 2.01e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.596e-01\n", - " 16 3.32e+02 3.27e+02 5.30e-01 5.03e+02 4.17e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 16 2.75e+02 3.27e+02 5.30e-01 4.73e+02 2.15e+01 0 \n", + " 16 1.79e+02 3.28e+02 7.96e-01 4.70e+02 2.15e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.639e-01\n", - " 17 2.75e+02 3.30e+02 5.27e-01 4.75e+02 2.64e+01 0 Skip BFGS \n", + " 17 1.46e+02 3.39e+02 8.09e-01 4.57e+02 2.43e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.447e-01\n", - " 18 2.75e+02 3.30e+02 5.52e-01 4.82e+02 3.07e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", + " 18 1.20e+02 3.37e+02 9.58e-01 4.52e+02 2.99e+01 0 \n", "Compute fields\n", ">> Compute response\n", - " 18 2.27e+02 3.30e+02 5.52e-01 4.55e+02 2.46e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 18 1.89e+02 3.30e+02 5.52e-01 4.34e+02 3.94e+01 0 Skip BFGS \n", + ">> Fix Jmatrix\n", + " 19 9.80e+01 3.38e+02 1.09e+00 4.44e+02 3.63e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.695e-01\n", - " 19 1.89e+02 3.28e+02 5.71e-01 4.36e+02 3.25e+01 0 \n", + " 20 8.02e+01 3.38e+02 1.23e+00 4.37e+02 5.04e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.657e-01\n", - " 20 1.89e+02 3.26e+02 6.01e-01 4.40e+02 3.16e+01 0 \n", + " 21 6.58e+01 3.37e+02 1.45e+00 4.32e+02 6.74e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.891e-02\n", - " 21 1.89e+02 3.25e+02 6.30e-01 4.43e+02 5.18e+01 0 \n", + " 22 5.39e+01 3.38e+02 1.37e+00 4.11e+02 7.78e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 6.371e-02\n", - " 22 1.89e+02 3.22e+02 6.64e-01 4.47e+02 8.07e+01 0 \n", + " 23 4.45e+01 3.33e+02 1.25e+00 3.89e+02 9.40e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 2.848e-02\n", - " 23 1.89e+02 3.20e+02 6.95e-01 4.51e+02 1.40e+02 0 \n", + " 24 4.45e+01 3.29e+02 1.08e+00 3.76e+02 1.02e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 2.689e-02\n", - " 24 1.89e+02 3.19e+02 6.88e-01 4.49e+02 2.10e+02 0 \n", + " 25 4.45e+01 3.25e+02 9.16e-01 3.66e+02 1.17e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 4.554e-02\n", - " 25 1.89e+02 3.19e+02 6.30e-01 4.38e+02 2.50e+02 0 \n", + " 26 4.45e+01 3.23e+02 7.93e-01 3.59e+02 1.09e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.379e-02\n", - " 26 1.89e+02 3.20e+02 5.98e-01 4.33e+02 2.23e+02 0 \n", + " 27 4.45e+01 3.21e+02 7.58e-01 3.55e+02 1.09e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 8.133e-02\n", - " 27 1.89e+02 3.23e+02 5.40e-01 4.25e+02 1.53e+02 0 \n", + " 28 4.45e+01 3.18e+02 7.47e-01 3.51e+02 1.23e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 7.456e-02\n", - " 28 1.89e+02 3.25e+02 4.90e-01 4.17e+02 1.34e+02 0 \n", + " 29 4.45e+01 2.99e+02 8.97e-01 3.39e+02 1.03e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 3.986e-02\n", - " 29 1.89e+02 3.26e+02 4.56e-01 4.12e+02 1.40e+02 0 \n", + " 30 4.45e+01 2.91e+02 9.14e-01 3.32e+02 1.26e+02 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.122e-02\n", - " 30 1.89e+02 3.26e+02 4.33e-01 4.08e+02 1.40e+02 0 \n", + " 31 4.45e+01 2.87e+02 8.76e-01 3.26e+02 1.19e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.249e-03\n", - " 31 1.89e+02 3.25e+02 4.24e-01 4.04e+02 1.46e+02 0 \n", + " 32 4.45e+01 2.81e+02 8.71e-01 3.20e+02 1.63e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.044e-02\n", - " 32 1.89e+02 3.23e+02 4.15e-01 4.01e+02 1.66e+02 0 \n", + " 33 4.45e+01 2.75e+02 8.75e-01 3.14e+02 1.76e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", "Reach maximum number of IRLS cycles: 30\n", "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 2.5682e+03\n", - "1 : |xc-x_last| = 1.9160e-01 <= tolX*(1+|x0|) = 1.1702e+01\n", - "0 : |proj(x-g)-x| = 1.6587e+02 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 1.6587e+02 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 40 <= iter = 33\n", + "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 2.5002e+03\n", + "1 : |xc-x_last| = 3.0590e-01 <= tolX*(1+|x0|) = 1.1702e+01\n", + "0 : |proj(x-g)-x| = 1.7618e+02 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 1.7618e+02 <= 1e3*eps = 1.0000e-02\n", + "0 : maxIter = 40 <= iter = 34\n", "------------------------- DONE! -------------------------\n" ] } @@ -880,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": { "scrolled": false }, @@ -891,21 +667,18 @@ "text": [ ">> Use multiprocessing for parallelization\n", ">> n_cpu: 2\n", - "SimPEG.DataMisfit.l2_DataMisfit assigning default std of 5%\n", - "SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||\n", "SimPEG.InvProblem will set Regularization.mref to m0.\n", "\n", - " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", - " ***Done using same Solver and solverOpts as the problem***\n", - "Compute fields\n", - ">> Compute response\n" + " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same Solver and solverOpts as the problem***\n", + ">> Compute J sigma\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/sgkang/Projects/simpeg/SimPEG/Directives.py:935: UserWarning: Without a Linear preconditioner, convergence may be slow. Consider adding `Directives.UpdatePreconditioner` to your directives list\n", + "D:\\Documents\\Repositories\\simpeg\\SimPEG\\directives.py:916: UserWarning: Without a Linear preconditioner, convergence may be slow. Consider adding `Directives.UpdatePreconditioner` to your directives list\n", " \"Without a Linear preconditioner, convergence may be slow. \"\n" ] }, @@ -913,300 +686,159 @@ "name": "stdout", "output_type": "stream", "text": [ - ">> Compute J sigma\n", + "Compute fields\n", + ">> Compute response\n", "model has any nan: 0\n", "============================ Inexact Gauss Newton ============================\n", " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", "-----------------------------------------------------------------------------\n", "x0 has any nan: 0\n", - " 0 7.15e+00 2.57e+04 0.00e+00 2.57e+04 6.27e+03 0 \n", + " 0 4.98e+02 2.50e+04 0.00e+00 2.50e+04 6.16e+03 0 \n", "Compute fields\n", ">> Compute response\n", ">> Compute J sigma\n", - " 1 7.15e+00 1.59e+03 2.63e-01 1.59e+03 8.19e+02 0 \n", + " 1 4.98e+02 1.53e+03 2.52e-01 1.65e+03 7.68e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Compute J sigma\n", - " 2 7.15e+00 3.20e+02 2.10e+00 3.35e+02 2.31e+02 0 Skip BFGS \n", + " 2 4.98e+02 3.87e+02 3.53e-01 5.63e+02 7.87e+01 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", - "Reached starting chifact with l2-norm regularization: Start IRLS steps...\n", - "eps_p: 0.7905642935391772 eps_q: 0.7905642935391772\n", - ">> Fix Jmatrix\n", - "delta phim: inf\n", ">> Compute J sigma\n", - " 3 3.57e+00 2.13e+02 1.68e+00 2.19e+02 8.81e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 6.45e+00 2.13e+02 1.68e+00 2.24e+02 8.62e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.16e+01 2.13e+02 1.68e+00 2.33e+02 8.36e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 2.06e+01 2.13e+02 1.68e+00 2.48e+02 8.20e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 3.56e+01 2.13e+02 1.68e+00 2.73e+02 8.78e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 6.14e+01 2.13e+02 1.68e+00 3.16e+02 1.16e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.03e+02 2.13e+02 1.68e+00 3.85e+02 1.84e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 1.67e+02 2.13e+02 1.68e+00 4.93e+02 3.03e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 3 2.61e+02 2.13e+02 1.68e+00 6.51e+02 4.86e+02 0 \n", + " 3 2.49e+02 3.42e+02 3.93e-01 4.40e+02 7.40e+01 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", + "Reached starting chifact with l2-norm regularization: Start IRLS steps...\n", + "eps_p: 0.4831159414302415 eps_q: 0.4831159414302415\n", ">> Fix Jmatrix\n", - "delta phim: 4.628e-01\n", - " 4 2.61e+02 2.92e+02 3.36e-01 3.79e+02 1.06e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 4 4.16e+02 2.92e+02 3.36e-01 4.32e+02 9.36e+01 0 \n", + ">> Compute J sigma\n", + " 4 2.49e+02 2.96e+02 4.90e-01 4.18e+02 1.22e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 3.753e-01\n", - " 5 4.16e+02 2.72e+02 3.74e-01 4.27e+02 2.34e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", + " 5 3.91e+02 2.64e+02 7.86e-01 5.71e+02 3.46e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 8.961e-02\n", - " 6 4.16e+02 2.75e+02 3.87e-01 4.37e+02 2.99e+01 1 \n", + " 6 3.91e+02 3.30e+02 3.66e-01 4.73e+02 9.98e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.600e-02\n", - " 7 4.16e+02 2.87e+02 3.79e-01 4.45e+02 1.81e+01 0 \n", + " 7 3.91e+02 3.02e+02 5.24e-01 5.07e+02 1.09e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 5.859e-03\n", - " 8 4.16e+02 2.92e+02 3.88e-01 4.54e+02 1.92e+01 0 Skip BFGS \n", + " 8 3.23e+02 3.32e+02 4.09e-01 4.64e+02 7.57e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 2.730e-02\n", - " 9 4.16e+02 3.00e+02 3.92e-01 4.63e+02 1.91e+01 0 \n", + " 9 3.23e+02 3.12e+02 5.56e-01 4.92e+02 6.54e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 3.130e-02\n", - " 10 4.16e+02 3.07e+02 3.87e-01 4.68e+02 1.66e+01 0 Skip BFGS \n", + " 10 2.65e+02 3.36e+02 4.61e-01 4.58e+02 6.63e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 4.197e-02\n", - " 11 4.16e+02 3.12e+02 3.96e-01 4.76e+02 1.76e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", + " 11 2.65e+02 3.20e+02 6.13e-01 4.83e+02 5.38e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 7.438e-02\n", - " 12 4.16e+02 3.15e+02 4.11e-01 4.86e+02 3.15e+01 1 \n", + " 12 2.16e+02 3.41e+02 5.25e-01 4.54e+02 6.39e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.838e-02\n", - " 13 4.16e+02 3.24e+02 3.95e-01 4.89e+02 1.12e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Compute fields\n", - ">> Compute response\n", + " 13 2.16e+02 3.27e+02 6.92e-01 4.76e+02 5.09e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 7.797e-02\n", - " 14 4.16e+02 3.25e+02 4.20e-01 5.00e+02 3.43e+01 2 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 14 3.41e+02 3.25e+02 4.20e-01 4.68e+02 9.62e+00 0 \n", + " 14 1.75e+02 3.45e+02 6.07e-01 4.51e+02 6.31e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.528e-01\n", - " 15 3.41e+02 3.24e+02 4.65e-01 4.83e+02 3.22e+01 0 \n", + " 15 1.43e+02 3.38e+02 6.91e-01 4.37e+02 1.72e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.875e-01\n", - " 16 3.41e+02 3.25e+02 5.21e-01 5.03e+02 6.24e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 16 2.82e+02 3.25e+02 5.21e-01 4.72e+02 2.84e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 16 2.32e+02 3.25e+02 5.21e-01 4.46e+02 1.10e+01 0 Skip BFGS \n", + " 16 1.18e+02 3.35e+02 7.53e-01 4.24e+02 3.66e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.928e-01\n", - " 17 2.32e+02 3.24e+02 5.75e-01 4.58e+02 3.30e+01 0 \n", + " 17 9.79e+01 3.30e+02 9.71e-01 4.25e+02 3.73e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.946e-01\n", - " 18 2.32e+02 3.24e+02 6.41e-01 4.73e+02 6.13e+01 0 \n", + " 18 9.79e+01 3.29e+02 1.10e+00 4.37e+02 3.95e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.832e-01\n", - " 19 2.32e+02 3.26e+02 7.71e-01 5.05e+02 1.19e+02 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 19 1.90e+02 3.26e+02 7.71e-01 4.73e+02 7.40e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 19 1.56e+02 3.26e+02 7.71e-01 4.47e+02 4.02e+01 0 Skip BFGS \n", + " 19 9.79e+01 3.26e+02 1.29e+00 4.52e+02 6.31e+01 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.386e-01\n", - " 20 1.56e+02 3.29e+02 8.98e-01 4.69e+02 7.80e+01 0 Skip BFGS \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 20 1.28e+02 3.29e+02 8.98e-01 4.44e+02 4.52e+01 0 \n", - "Compute fields\n", - ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 20 1.06e+02 3.29e+02 8.98e-01 4.24e+02 3.03e+01 0 Skip BFGS \n", + " 20 9.79e+01 3.22e+02 1.35e+00 4.54e+02 1.05e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 8.896e-02\n", - " 21 1.06e+02 3.27e+02 1.03e+00 4.37e+02 7.60e+01 0 Skip BFGS \n", + " 21 9.79e+01 3.17e+02 1.41e+00 4.55e+02 1.58e+02 0 \n", "Compute fields\n", ">> Compute response\n", - "Beta search step\n", - "Compute fields\n", - ">> Compute response\n", - " 21 8.77e+01 3.27e+02 1.03e+00 4.18e+02 4.81e+01 0 \n", + ">> Fix Jmatrix\n", + " 22 9.79e+01 3.14e+02 1.36e+00 4.46e+02 2.30e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 8.533e-02\n", - " 22 8.77e+01 3.25e+02 1.11e+00 4.22e+02 1.07e+02 0 Skip BFGS \n", + " 23 9.79e+01 3.12e+02 1.23e+00 4.32e+02 2.72e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 4.816e-02\n", - " 23 8.77e+01 3.23e+02 1.01e+00 4.12e+02 1.30e+02 0 \n", + " 24 9.79e+01 3.13e+02 1.07e+00 4.18e+02 3.23e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 1.494e-02\n", - " 24 8.77e+01 3.22e+02 9.29e-01 4.03e+02 1.50e+02 0 \n", + " 25 9.79e+01 3.15e+02 1.02e+00 4.15e+02 4.11e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 4.205e-02\n", - " 25 8.77e+01 3.23e+02 8.46e-01 3.97e+02 8.39e+01 0 \n", + " 26 9.79e+01 3.22e+02 8.80e-01 4.08e+02 3.66e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.465e-03\n", - " 26 8.77e+01 3.23e+02 8.16e-01 3.94e+02 1.02e+02 0 \n", + " 27 9.79e+01 3.26e+02 7.70e-01 4.02e+02 3.17e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 3.262e-02\n", - " 27 8.77e+01 3.23e+02 7.87e-01 3.92e+02 1.29e+02 0 \n", + " 28 9.79e+01 3.29e+02 7.07e-01 3.98e+02 3.16e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 3.600e-02\n", - " 28 8.77e+01 3.21e+02 7.91e-01 3.90e+02 1.92e+02 0 \n", + " 29 8.11e+01 3.31e+02 6.18e-01 3.81e+02 1.74e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 6.215e-02\n", - " 29 8.77e+01 3.20e+02 7.92e-01 3.90e+02 2.32e+02 0 \n", + " 30 8.11e+01 3.29e+02 5.83e-01 3.76e+02 1.63e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 7.214e-02\n", - " 30 8.77e+01 3.20e+02 7.89e-01 3.89e+02 3.01e+02 0 Skip BFGS \n", + " 31 8.11e+01 3.28e+02 5.56e-01 3.73e+02 2.14e+02 0 Skip BFGS \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.542e-02\n", - " 31 8.77e+01 3.21e+02 7.69e-01 3.88e+02 3.26e+02 0 \n", + " 32 8.11e+01 3.28e+02 5.23e-01 3.70e+02 2.53e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", - "delta phim: 9.593e-02\n", - " 32 8.77e+01 3.21e+02 7.32e-01 3.86e+02 3.69e+02 0 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " 33 8.11e+01 3.27e+02 4.99e-01 3.67e+02 3.08e+02 0 \n", "Compute fields\n", ">> Compute response\n", ">> Fix Jmatrix\n", "Reach maximum number of IRLS cycles: 30\n", "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 2.5682e+03\n", - "1 : |xc-x_last| = 1.7725e-01 <= tolX*(1+|x0|) = 1.1702e+01\n", - "0 : |proj(x-g)-x| = 3.6919e+02 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 3.6919e+02 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 40 <= iter = 33\n", + "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 2.5002e+03\n", + "1 : |xc-x_last| = 1.8464e-01 <= tolX*(1+|x0|) = 1.1702e+01\n", + "0 : |proj(x-g)-x| = 3.0787e+02 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 3.0787e+02 <= 1e3*eps = 1.0000e-02\n", + "0 : maxIter = 40 <= iter = 34\n", "------------------------- DONE! -------------------------\n" ] } @@ -1217,12 +849,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1234,8 +866,8 @@ } ], "source": [ - "DOBS = dobs.reshape((prob.n_sounding, 2, survey.n_frequency))\n", - "DPRED = pred.reshape((prob.n_sounding, 2, survey.n_frequency))\n", + "DOBS = d_obs.reshape((sim.n_sounding, 2, survey.n_frequency))\n", + "DPRED = pred.reshape((sim.n_sounding, 2, survey.n_frequency))\n", "for i_freq in range(survey.n_frequency):\n", " plt.semilogy(mesh.vectorCCx, DOBS[:,0,i_freq], 'k')\n", " plt.semilogy(mesh.vectorCCx, DPRED[:,0,i_freq], 'kx')\n", @@ -1246,29 +878,29 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "sigma_est_l2 = Utils.mkvc((np.exp(mopt_l2)).reshape((prob.n_sounding, prob.n_layer)))\n", - "sigma_est_l2_qx2 = Utils.mkvc((np.exp(mopt_l2_qx2)).reshape((prob.n_sounding, prob.n_layer)))\n", - "sigma_est_l2_ps0 = Utils.mkvc((np.exp(mopt_l2_ps0)).reshape((prob.n_sounding, prob.n_layer)))\n", + "sigma_est_l2 = utils.mkvc((np.exp(mopt_l2)).reshape((sim.n_sounding, sim.n_layer)))\n", + "sigma_est_l2_qx2 = utils.mkvc((np.exp(mopt_l2_qx2)).reshape((sim.n_sounding, sim.n_layer)))\n", + "# sigma_est_l2_ps0 = utils.mkvc((np.exp(mopt_l2_ps0)).reshape((sim.n_sounding, sim.n_layer)))\n", "\n", - "sigma_est_l0 = Utils.mkvc((np.exp(mopt_l0)).reshape((prob.n_sounding, prob.n_layer)))\n", - "sigma_est_l0_qx2 = Utils.mkvc((np.exp(mopt_l0_qx2)).reshape((prob.n_sounding, prob.n_layer)))\n", - "sigma_est_l0_ps0 = Utils.mkvc((np.exp(mopt_l0_ps0)).reshape((prob.n_sounding, prob.n_layer)))" + "sigma_est_l0 = utils.mkvc((np.exp(mopt_l0)).reshape((sim.n_sounding, sim.n_layer)))\n", + "sigma_est_l0_qx2 = utils.mkvc((np.exp(mopt_l0_qx2)).reshape((sim.n_sounding, sim.n_layer)))\n", + "sigma_est_l0_ps0 = utils.mkvc((np.exp(mopt_l0_ps0)).reshape((sim.n_sounding, sim.n_layer)))" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAT4AAALICAYAAADmG5ypAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9f7CkVXnv+/l27x/zC2aYjVgESEDgcEVuECVoDlG5KiccREerJIonCQpXrh4wpk5uRTh64jl15aJUYikl6h2VoKUyARN1sCBIgRSlQQUEEZigI/5gZOKE5tfAzPTeu/u5f7zr7d397v719s/37X4+VV27v+9a73qf7r3nmbXW86y1ZGY4juNME4VxG+A4jjNq3PE5jjN1uONzHGfqcMfnOM7U4Y7PcZypwx2f4zhTR+Ycn6SzJD0iaaekS8dtj+M4k4eylMcnqQj8FDgT2AXcDZxnZg+P1TDHcSaKrPX4TgN2mtmjZrYIbAO2jNkmx3EmjJlxG5DgCOCxOr0LeEV9BUkXARcBrF+rlx/7u1n7CI4zfh54ZOkJM3vBuO3IKlnzGmpyrWEsbmZbga0AJ/9vc3bzNYeOwi7HyRVHnL77V+O2Ictkbai7CziqTh8JPD4mWxzHmVCy5vjuBo6XdIykOeDtwPYx2+Q4zoSRqaGumS1LugS4BSgC15jZQ2M2y3GcCSNTjg/AzG4Cbuq2/vzsIgDlpTnXQ9JZssV19zovSHoR8EFgo5m9dRTPzNpQ13GcHCHpGkl7JD2YuN71QoSQvnbhcC1tJFMJzGnxqK7jNOeI03ffa2anDvs5kl4NPAd8ycxOCteaLkQgmr66ItHEBWa2J9z3tVH1+DI31E3LuIcT06CzZIvrwQ91peMM9jUp2f0QcKDuwtaQTlbDzO6UdHTixtpChKh9bQO2mNkVwDmpjBsSuXZ8v5o/ine+6EoAiuUKAJX5ousB6yzZ4rpb/Ta6Zz9wcZPrHzrQY6+x40KEeiQtAJcDp0i6LDjIoZJrx+c4ziAoAgcPssGOCxEaCsxKwHsGaUAn3PE5ztRTANYOssHML0Rwx+c4U8/AHV9tIQLwG6KFCO8Y5AP6xdNZHGfqiR1f8tUZSdcBdwEnSNol6UIzWwbihQg7gOuzthDBe3yOM/WIXnt8ZnZei+upFiKMGnd8jjP1DDy4kXl8qOs4U0/Loe5GSVslvXGMxg0F7/E5ztTTMrjxjJldNGJjRoI7PseZegYe1c08+XZ8gv0LawBYW4pW1rgevM6SLa67193Te3Ajr+R6k4JNJx9rr7rdl6wNW2fJFtfd6W8e8bauNymQXmbwvSYl60ay0cE4yHePz3GcATB9Q12P6jqOM3W443McZ+rI91DXgxse3HDdf3BDwHyT6weiPD7gRjO7MV2j2caDG6476izZ4noIwY3ZU41D7lld8O/y4IbjOBOKgDXjNmK05Nvx+VDXh7qu+x/qFnDH5zjOlOGOL1+se/gxXnXo+ZGYCwesLC66HrTOki2uu9LfIgUFYEOaG/JPrh2f4zgDwHt8OaNahVIper+wEP10PXidJVtcd6+7ZQqDG7lOZ/mduTn7vw4OGyhmYHgxsTpLtrjuSv/P3d0fKK5DTjX+jybpLF/3dBbHcSYVH+rmDB/q+lDXdf9D3dbBjYlduZFvx+c4Tv+07vH5DsyO40woHtwYYMPSNcA5wB4zOylc2wz8A3A08EvgT8zsqVB2GXAhUAH+wsxu6fQMD26MSGfJlinQ9z3waWCEa3V/51Tj/2wS3Ph/Jje4Mcxtqa4FzkpcuxS4zcyOB24LGkknEp22/pJwz6clFYdom+M4MfHuLMnXBDO0oa6Z3Snp6MTlLcAZ4f0XgTuAD4Tr28ysDPxC0k7gNKIT2lvjwQ0PbkygjntuI1urWwQOSndL3hn1RqQvNLPdAOHnYeH6EcBjdfV2hWurkHSRpHsk3bN/qKY6zpQQz/ElXxNMVoIbanKt6eSjmW0FtkI0x8emTVFBPE8S/+/penA6S7ZMgY7n7OKeW6+6azyPb+j8VtLhZrZb0uHAnnB9F3BUXb0jgcdHbJvjdMV993wCGP7GoiNjAhyfpDcDbyAaRV5tZt9uV3/Ujm87cD7w0fDzm3XXvyrp48DvAMcDP+zYms/x+RzfGPSg5uAysx9fD+kskjYBnwdOIhqdXWBm7efkm7ezKvujruws4JNEs5CfN7OPtmrHzL4BfEPSIcDfAuNxfJKuIwpkHCppF/BhIod3vaQLgV8D5wajH5J0PfAwsAxcbGYj/m/PcaaUIr1sS/VJ4J/N7K2S5oB19YWSDgP2m9neumvHmdnORDvXAp8CvpS4vwhcDZxJNCK8W9L2YO0ViTYuMLN49PihcF9bhhnVPa9F0eta1L8cuHxY9jiO04LWPb6mS9YkHQy8GngngJktAouJe18DvFfS2WZ2QNK7gbcAZ9dXapH9AVFWx04zezQ8cxuwxcyuIOohNn4ESUQdq5vN7EcdPnFmghu9USjgwQ0PbjTT993ziaHPwfUbfBi27pr0S9ZeBPw78PeSTgbuBd5vZs/HFczsBknHANsk3QBcQNR765ZmmR6vaFP/fcDriZz1cWb22XaN+7m6jjPtxI6v+3SWGeBlwGfM7BTgecJihHrM7ErgAPAZ4E1m9lwKq7rO9AjPusrMXm5m7+nk9CDvPT4Pbnhwo4WuzBfHHlwYt+4aAWtSLV3dBewysx8E/TWaOD5JryIKfnydaI7/kpTPGFqmh/f4HGfaKVYpbNi36tUKM/s34DFJJ4RLryMKTNaQdArwOaJVWe8CNkv6SAqr7gaOl3RMCJ68nSj7YyC443OcKUcy5tcsrnp14H3AVyQ9ALwU+H8T5euAc83s52ZWJUpf+9XqZ+s6oqWpJ0jaFTI+MLNloh7iLcAO4Hoze6iPj9n4XN963nVHnSVbutSjCG5kWafZnWXm5SfbhrtWb4b0zPzhE7s7S77n+JzcMgrH5HSHZMzPdezhTRT5dnwe3MhtcMODD9kJbghjblUa3mSTb8fnOE7fFKiyjtbBjEnEHZ/jTDmiyhzlcZsxUtzxOc6UU8CYn7Khrkd1XXfWHnXNnU4T1d1w6gn2+/esXuxwl17rUV1nsmm3x5xHXSebNnN8fq5uJvGo7kj2mMtKlNL1MKO6Tef4/Fxdx3EmkwLVqZvjc8fnOFNOmx7fxOKOz3GmHE1hVNcdn+NMOQWqrPUE5hwxQTsw3/fAp4Hxp0Q029U3KzsKux7ODsw+x+c4ztThc3wtkHQb8HdmdlPdta1jD3VPUDpLlo8szJItroeTzjJtPb5uNyI9BviApA/XXZvIjG7HmTbi3VmSr0mmW8f3NNH20i+UdKOkjUO0yXGcERKv3Ei+Jplu5/gUtoL+r5LeCXwXOGRoVjmOMzIKvjtLS2ormM3sWkk/AS4ejkmO44ySaZzjm+rdWXyHkO50lmxxPfjdWY4+dcH+5p6zVl2/UF/Nze4skt4MvAE4DLjazL7drr6fsuY4U06Ux1de9eqEpKKk+yR9q9dnS7pG0h5JDzYpO0vSI5J2Slp1bm89ZvYNM3s38E7gbZ2em+88vj7TWfzcB09nmWTdLX2s3Hg/0dGPBycLJB0G7DezvXXXjjOznYmq1wKfAr6UuL8IXA2cSXS4+N2StgNF4IpEGxeY2Z7w/kPhvrZ4j89xppx4ji/5IuzHJ+mNq+6RjiQaWn6+RbOvAb4paU2o/27gqmQlM7sTeLLJ/acBO83sUTNbBLYBW8zsJ2Z2TuK1RxEfA242sx91+sz57vE5jtM3Pe7H9wngr4GDmhWa2Q2SjgG2SboBuICo99YtRwCP1eldwCva1H8f8HoiZ32cmX22Td3h9fgkHSXpO5J2SHpI0vvD9c2SbpX0s/DzkLp7Lgvj+Uck/fGwbHMcZ4V4rW6THl9TJJ0D7DGze9u1a2ZXAgeAzwBvMrPnUpilZk22edZVZvZyM3tPJ6cHwx3qLgN/ZWYvBl4JXCzpROBS4DYzOx64LWhC2duBlwBnAZ8O43zHcYZIDys3TgfeJOmXREPQ10r68qp2pVcBJwFfBz6cLO/ALuCoOn0k8HjKNloyNMdnZrvjsXaY4NxB1H3dAnwxVPsi8ObwfguwzczKZvYLYCfRON9xnCGSduWGmV1mZkea2dFEnZXbzexP6+tIOgX4HNG/63cBmyV9JIVZdwPHSzpG0lx4zvZ0n6w1I5njk3Q0cArwA+CFZrYbIucYoj8QOcXv1922K1xryb6X/B733H4l0FuuU7FcGfvWQXnQWbLF9eC3pRrS7izrgHPN7OcAks4nSjVpfLZ0HXAGcKikXcCHzewLZrYs6RLgFqJI7jVm9tCgjBu645O0AfhH4C/N7Fmp2dA9qtrk2qoxvaSLgIsA1h912KobHMdJRz8rN8zsDuCOJte/l9BLRD3AZL3z2rR9E3BTq/J+GKrjkzRL5PS+Ymb/FC7/VtLhobd3OBDn33Q1pjezrcBWgE0vPdbGnSs1DTpLtrgeTh7fpO/GkmSYUV0BXwB2mNnH64q2A+eH9+cD36y7/nZJ8yEMfjzww2HZ5zhORNTjS79yI88Ms8d3OvBnwE8k3R+u/Xfgo8D1ki4Efg2cC2BmD0m6HniYKCJ8sZmlm6xwHCc1BauytjzZ21AlGZrjM7Pv0nzeDqK9/Zrdczlw+bBschxnNarCfLk6bjNGiq/ccJwpRwYzkz2yXYU7PseZdqpE6yumiFzvx7fp5GPtVX3k8bn2/fgmVafZj+/Uk2T3fG31db2Y3OzHlxbv8TnOtGMw4UHcVeTb8Wn8uVLToLNki+vB5/FN41A3347PcZz+8R6f4zhTh/f4HMeZOqrA8+M2oj/8sCHHcdJRJRrqJl8tkLRG0g8l/ThsMvy/en20HzbkOM54MNIOdcvAa83subARyXcl3WxmtW3l/LAhx3GyTeseX9PDhiwi3kZ+NrySCcF+2JDjOBmmdVS35WFDoUd2L3Ac0ZzaDxqazPhhQ/l2fDb+XW6nQWfJFteD34G5l+BG2DnppZI2AV+XdJKZPZioc6WkbUSHDR077MOGaNKjbIUPdR1n2onTWZKvLjCzp4l2YD4rWZblw4by3ePzlRu+csN1/ys3UiYwS3oBsGRmT0taSzTE/FiiTnzY0BuAXwBflvQRM/tQl4+pHTYE/IbosKF3dG9le7zH5zjTTvoe3+HAdyQ9QOSgbjWzbyXq1A4bMrMq0W7rv0o2FA4bugs4QdKusEExZrYMxIcN7QCuz9VhQ47jZJyUPT4ze4Do1MR2dab3sCHHcXJAhdyv3EiLOz7HmXbSJzDnHnd8jjPtxAnMU4Q7PseZdnxbKsdxpo4p3JbKz9xw3VFnyRbXQzhzY73snhNXX9c9fuaG4ziTig91c4av3PCVG677X7kxhUPdfDs+x3H6x3t8juNMHd7jcxxn2qhWYb+v3HAcZ5qoVmG/D3Udx5kmDNi/PG4rRos7PseZcqrAvnEbMWKGth9fqyPoJG2WdKukn4Wfh9Tdc1k4Su4RSX88LNscx1mhAuxt8ppkhrkRaXwE3cnAS4GzJL0SuBS4zcyOB24LGkknEu2y+hKibaw/HQ40cRxniFSB/U1ek8xIlqxJWgd8F3gv0fmZZ5jZbkmHA3eY2QmSLgMwsyvCPbcA/9PM7mrVri9Z8yVrrvtfsvYfJPt0k+tnMrlL1oa69bykoqT7gT1E21P/AHihme0GCD8PC9WbHSd3RJM2L5J0j6R7lp9Kc2iT4zjNMKavxzfU4EazI+jaVO/qODkz2wpsBdj00mNt3MuCpkFnyRbXg1+yNo3BjZFEdcNpTHcQzd39VtLhdUPdPaHaUI+TcxynOXFwI89IejPRiW6HER1w/u129YcZ1X1B6OlRdwTdvwLbiU5cIvz8Zni/HXi7pPlwpNzxwA+HZZ/jOBFpgxuSjpL0HUk7QsbG+3t9tqRrJO2R9GCTsrNChsdOSZe2a8fMvmFm7wbeCbyt03OH2eM7HPhiiMwWiI6H+5aku4DrwzFyvwbOBTCzhyRdDzwMLAMXh6Gy4zhDJHZ8KVgG/srMfiTpIOBeSbea2cNxBUmHAfvNbG/dtePMbGeirWuBTxEFPamrWwSuBs4kGg3eLWk7UASuSLRxgZnFI8cPhfvaMjTH1+oIOjMrAa9rcc/lwOXDsslxnNX8Bm75ABzapEiStgI3mtmN8cUQlIwDlHsl7SAKRD5cd+9rgPdKOtvMDkh6N/AW4Oz6B5jZnZKObvLs04CdZvZoMGQbsCVkfZzTzFDgo8DNZvajTp/ZV244zpRjZmf1em9wWqcAP0i0eUOYstom6QbgAqLeW7c0y/J4RZv67yOaTtsYepafbde4Oz7HcXpC0gbgH4G/NLNnk+VmdmXoqX0GONbM0uSfdZXlUfesq4Crum18qHl8juNMJpJmiZzeV8zsn1rUeRVwEvB14MMpHzHULA93fI7jpCLMp30B2GFmH29R5xTgc8AW4F3AZkkfSfGYu4HjJR0jaY5oOev2/ixfwR2f4zhpOR34M+C1ku4Pr7MTddYB55rZz82sSpS69qtkQ5KuA+4CTpC0K2R7YGbLwCXALcAOoqyQhwb1AXyOz3GcVJjZd2k+B1df53sJvUTUA0zWO69NGzcBN/VoZlv8XF3XHXWWbHE9+E0KppFcOz5Je4FHxm1HGw4Fnhi3EW3Isn1Ztg2yb98JZnbQuI3IKnkf6j6S5f/VJN3j9vVGlm2DfNg3bhuyjAc3HMeZOtzxOY4zdeTd8W0dtwEdcPt6J8u2gduXa3Id3HAcx+mFvPf4HMdxUuOOz3GcqSO3ji/N7qwDfOaq3WJ7OSdY0ssl/SSUXRXWPg7CvqY742bBRg3wnOVhfX+h7aKk+yR9K2v2SfplaPf+OF0lS/blCjPL3YtoF9afAy8C5oAfAyeO4LmvBl4GPFh37Urg0vD+UuBj4f2Jwa554JhgbzGU/RD4Q6JlPzcD/3lA9h0OvCy8Pwj4abBj7DaGdjaE97NE+7e9Mgu2Jez8b8BXgW9l8Pf7S+DQxLXM2JenV157fLXdWc1sEdhGtAvEUDGzO4EnE5e3AF8M778IvLnu+jYzK5vZL4CdwGmKDlg62Mzusuiv8Et19/Rr324Lu89atOV3vDPu2G20iHg/ttnwsizYFiPpSKIDaz5fdzkz9rUg6/Zlkrw6vq7O4B0Rac8JPiK8T14fKGrcGTcTNmow5ywP8/v7BPDXRMdQxGTJPgO+LeleSRdl0L7ckNcla6l2Zx0TrWwcuu1K7IzbZgpnpDbaYM5ZHoptks4B9pjZvZLO6OaWFnYM8/d7upk9ruggn1sl/WubumP7+8sDee3xZekM3t+G4QPq7pzgXeF98vpAUPOdcTNlo5k9DdxB3TnLGbDtdOBNkn5JNHXyWklfzpB9mNnj4eceol2NT8uSfXkir45vqLuzpiTVOcFhOLJX0itDNO3P6+7pi9Bes51xx26jBnTO8rC+PzO7zMyONLOjif6ebjezP82KfZLWKzrKEUnrgf8EPJgV+3LHuKMrvb6Ijqn7KVG06oMjeuZ1RMfqLRH9z3khsADcBvws/NxcV/+Dwb5HqIucAacS/dH+nOhMUQ3Ivj8iGrY8ANwfXmdnwUbg94H7gm0PAn8Tro/dtia2nsFKVDcT9hFlMPw4vB6K/+azYl/eXr5kzXGcqSOvQ13HcZyeccfnOM7U4Y7PcZypwx2f4zhThzs+x3GmDnd8juNMHe74HMeZOtzxOX0h6Q8kPRD221sf9tprtwbXccaOJzA7fSPpI8AaYC2wy8yuGLNJjtMWd3xO34T10ncDB4D/aNEuLI6TWXyo6wyCzcAGol2f14zZFsfpiPf4nL6RtJ1oK6djgMPN7JIxm+Q4bcnrRqRORpD058CymX1VUhH4F0mvNbPbx22b47TCe3yO40wdPsfnOM7U4Y7PcZypwx2f4zhThzs+x3GmDnd8juNMHe74HMeZOtzxOY4zdbjjcxxn6nDH5zjO1OGOz3GcqcMdn+M4U0fmHJ+ksyQ9ImmnpEvHbY/jOJNHpjYpCLt7/BQ4E9hFtLnleWb28FgNcxxnoshaj+80YKeZPWpmi0R7vG0Zs02O40wYWXN8RwCP1eld4ZrjOM7AyNpGpGpyrWEsLuki4CKA9Wv18mOP6uMjNHvatJCdGQ5nCDzw06UnzOwF47Yjq2TN8e0CjqrTRwKP11cws63AVoCTT5izm7ceOjxrstQfro7bACdPHHHG7l+N24Ysk6V/2hAFM46XdEw4uevtwPZ2N8zPLDI/szgcXYX5wiLzhcXI8aTRndofdHtD1ON8tuvetdOaTPX4zGxZ0iXALUARuMbMHhqzWb1R7fDTGSzLLd6PQzuZJ1PpLGk5+YQ5u/nTfQx1x+n2/R+LM0SOeP3ue83s1HHb0Q2SXgR8ENhoZm8dxTOzNtR1HCdHSLpG0h5JDyaud70QIaSvXThcSxvJ1FA3LU+u2cS2l74ZACtHPlzz1YHpKkU0b0ErlGdTq1wd+OeP9TC+2zzrSnk26MH87irlIgAETSjvT3+CEXEt8CngS/GFsBDhauoWIoSzl4vAFYn7LzCzPaMxdYVcOz4BM2HSzEJ+hsLPwehKnVaifLh65Wf8+Qpj0+N8ditdpTDg3/WKXuowECpQaWtfhdm2969ur9rw/ArFVPf3i3Scwb4mJbsfAg7UXdgasipqmNmdko5O3FhbiBC1r23AFjO7AjhnYIb3Qa4dH6z87zlpuvaPslxIlI9PZ8mWSA/7dzFe++hXd81+4OIm1z90oMd5wmYLEV7RqrKkBeBy4BRJlwUHOVRy7/iyMtTsf6gafmZkOJf1oW6BaodpikLPv4uZcqVBL5VnUtlHGLr2+vxCbdqiz6Fw1xSAtSnvaUvHhQgNBWYl4D2DNKATuXd8eWVleNM4XHIGQ4HqqqHx6J7dOBROO/QdPQN3fB0XIowbd3yOM/UM3PHVFiIAvyFaiPCOQT6gX7ybMSKiPkeVApVaj8AZHfXffdzb7pYZKuFVrQXTJosicHCTV2ckXQfcBZwgaZekC81sGYgXIuwArs/aQgTv8TnO1CN67fGZ2Xktrt8E3NSHUUPFHd+IqNZSHhqjto4zfgY+1M08PtR1nKkndnzJFxslbZX0xjEaNxS8x+c4U0/LHt8zZnbRiI0ZCe74nJ6IggTRcL0afrbT1RGvRhgky8F2TWRgA1aCG9NDvh2fjOJCtM1JpRR9lLxoK0VzfTNBL4fyLOpmZQWMmYWloGdDeWttVDPxWWIt1PXvarlUCLoSykmlq6G9Qk0XU+lKeH5hoRrKu9Pd03twI6/k2/GZan+kcfZ73nT8R57U8UqO5Vr9wlB1/DwL/2jqdbOyKqo5uGqwvZ0W1rTtbnWV4kA/e2SPgm7/uyrGq2pq9QuhnC51+991J01NF1Lp7pm+4Ea+HZ/jOAPAHV++yPFQN2tD4bh31Wy42s1Qdth6mEPluGc1rKFvPoa6WV9WN1jy7fgmYKjb7VB42EPflfZXD1e7GcoOW6cdKqcbGqf93UzaUHf6yLfjcxynfwTMN7l+oMm1CSHfjm+Ch7qjHvpmfaibVqcZGk/9ULcArGly/UCUwAzcaGY3pms02+Tb8Q14qLtMsfZHvTIcaq1nqAxtqLsyfGuMJA4jagvth5vNyopUa//A4rYGqSsUBjo0bjf0Xf1d9zfUjbemrybu73ZoG++/V0k5tO15qCuaOz5PYHYcZ2KZvqBuzh3fgIe6opoqSVUMb6g96KFtu6FsJ92sTFSZDXoplA9SF1Bmh76dhrrjGtr2PNQtAhvS3ZJ38u34BjzUNQopInUFDBv6UHcUUdtOuvlQslBzWPGzBqnTJkh30kZhgFHebEZxhzDUnVhy7fgOefpp/ssNXwOgbHMAzGtxdLoA84Wgq6G8R/3EGw4CYJZILzHXVh8IY5O5oBdDeSu9P/xlx/eXw/2zhF5WyOOK9T7W1fQSsxxgDTOhbDnUrdcVCsyEU9KXmeE5DqIYNlytUGSR2QZdZk1tQ9YqRQ6wprZBaJUCB1hTWxurxClmCiuF05BcW5yltcMr2+KPaauyVsGNCSbXjk9UWZiN/pstLS0AjFYXBtfeM/NRPsEhC08B8FTpkLa6FHoHm4J+OpS30sulhaCfBuDJ0HvZGPQzpU0NOu59HbzwDM+WNrJMkYMW9gKwtxQ56XqtRHmRCusWngdgX2k9RQqsXYiOMNxfWkeBCmsWonyJA6XI6c0tlAFYLM13HEr3OxRuN/Qd9VB3UEPbnoe63uNzHGfq8B5fvjArUDoQ9VTioWipsrCiiys9q1r5IPVy4nnJ56fQS+VIxz27TjpOeXi2FG0ntBjK455eUlfDEYnPhfqVMC+1t7ShqSbqfLG/tA7K0bkTtZ5TOH6xXgtb6TmVl1nLPoqlqN7a8j5mmKVYinpM68r7KFKtlRfLVZaYrQV0iuVlhDWkt1QpNswBJsshXTpM+zm/xjm9+HjJZGpTr+krg0pXiXUl2Fcp9Xi85BQGN9Iu6nMcZ9KIh7rJl+/AnE1ElYWZMGe2HObM6rVGPOfXh047xzfoOb+nwxxfsznAeP7v4IVnAHi2tHGVLlDg4IVngz6YZWYa5vyqiA0LzwHwXGnDqjnAAlXmw5xfOcz5zS6EwE5pDkMDTYdJM8eX9Tm9uKc38JUbnsDsOM7E4sGNwSHpGuAcYI+ZnRSubQb+ATga+CXwJ2b2VCi7DLgQqAB/YWa3dHqGqUCpEOb4ZsKcWWGhUVeDVrb1gXKUXhL33OI5urS61RxfUi/V9KYWOuolPVPaxFJ5lgpFnqvNB0bPrNdVCjwfdLVcRBjlUtSLVdmYrVveN1uusEi11lNTuUqRKhb3tMpVqhRYKs2F9lbP6SXn/IC2c4DJOb/2S9ra5+0Ne06v1ZxdJ91zHp/P8Q2Ua4GzEtcuBW4zs+OB24JG0olEp62/JNzzaUnZSbRyJpos5fSNhXh3luRrghlaj8/M7pR0dOLyFuCM8P6LwB3AB8L1bWZWBn4haSdwGtEJ7S2RxpzHN0D91HyUMNztHF2/Ou0cX4EKG8Oc3jNhjq9eVyk2zPkZcFCY89tbOpgK1YY5vxmWWR/m+J4vradIhTUL+/m02VMAACAASURBVAE4UFq7ao4PGNqcX9wT63aOb9hzeq3m7Ia6O8uUrdUddVT3hWa2GyD8PCxcPwJ4rK7ernBtFZIuknSPpHueen6otjrOdOA9vrHRbFKi6fodM9sKbAU4+ffmrLQU5viqiTy7nOm0c3T96l7m+OKeXly3Xlcp1KK9S+VZlphlb8gZXCrPUqVYW/GxXJ5lmRmeL60PeoYKRQ6Uom5HPGdYP8cHNGhLuVa43drfzmt1+1uLO6i1t0NbqzuFPb5RO77fSjrczHZLOhzYE67vAo6qq3ck8HjH1gqs/M9UrbuWRb0UfipxPSe7hBepUKytpa1QScyLFajW1t4WKIb68VrcAkUqtXXAwliTWNu7j8Va/UIXc27R2tvYnsGuve33HN20a29XvssxrdWdgOCGpDcDbyAaRV5tZt9uV3/Ujm87cD7w0fDzm3XXvyrp48DvAMcDP+zUmKiyMBfmzBbDnFlW9XL78qzP8cXvga7m/MAa8vqAtnl+RSqJtbzt5/iSutOcX5o5vsVQ3mve3rjm9Ea5VlfSJuDzwElEHvsCM2s7J9+inVXZH3VlZwGfJHLNnzezj7Zqx8y+AXxD0iHA3wLjcXySriMKZBwqaRfwYSKHd72kC4FfA+cGox+SdD3wMLAMXGxmlWHZ5jhOHb2t1f0k8M9m9lZJcxC28wlIOgzYb2Z7664dZ2Y7E+1cC3wK+FLi/iJwNXAm0YjwbknbiZzgFYk2LjCzePT4oXBfW4YZ1T2vRdHrWtS/HLh8WPY4jtOC1o6v6Zkbkg4GXg28E8DMFiHsd7bCa4D3SjrbzA5IejfwFuDs+kotsj8gyurYaWaPhmduA7aY2RVEPcQGJImoY3Wzmf2owyfOTHCjJ4wCpcVEcGNxIZva2uusBzfi93FZp2DHEjO1IW58f71eZqYu2BEFN/aXok5DN8GNpO4U7EgX3Ohvo9FxBTNGeObGi4B/B/5e0snAvcD7zayWZ2FmN0g6Btgm6QbgAqLeW7c0y/R4RZv67wNeT+SsjzOzz7ZrPNeOL1fE89etgh8ZYyVQsUyBwqrgQadgR5FqXXm1di3WUXn0DKPQoEEU64IXwla1P0yqteBG2I0lRKBivTp4oYRuZHXwon391fd3el4r3SXpgxszwMuA95nZDyR9kmgxwv+or2RmV4ae2meAY83suRTP6DrTIzzrKuCqbhvPtePLVXCjg85acKNeP13aRJWZlpuWNgt2JBOaoXFTg+TGpkWWWReCG/tCcGMuBC8Wa8GL0QQ3VAs2ZCN4ET9PC/FpcHSlu0bAmlQR5V3ALjP7QdBfI6zCamhWehVR8OPrRHP8l6R8RvpMjy7JaH/DcZyRUTBYs7j61QIz+zfgMUknhEuvIwpM1pB0CvA5olVZ7wI2S/pICqvuBo6XdEwInrydKPtjIOS6x+c4Tv9IVWbXlFddb+36gGhO7SvBKT1K5NzqWQeca2Y/j56h8wnBkMZnr87+MLMvmNmypEuAW4gG49eY2UOpPlgb3PE5zpSjgjHXpIfXzvGZ2f3AqW3Kv5fQS0Q9wGS9VtkfmNlNwE1tzOiZXDs+o0CpEqK68TZP8dbu49CV3qO+o47qJreibxfljd/Xb1NfpdgQ5Y3aOii0XVy1jVVySVuVAvtCFLdaLlBhpqYr5RmqFFisi9r2u4StlyVr3W4r1e02Uiv1m7fXSdfm7rrU3VIoVFm3bt+q62kiEXkj144vU3i6tZNThNWOIZ0Wcu34pCoL8yFKWg5R0nHpSr6iummivM0ivv1GeZPbVmU5qtspips2attrlHZYUd0CVeZZPcc3yeTa8TmO0z/e43McZ+oQ5j0+x3GmiwJV1rJ/3GaMlFw7PrMCpXJirW55YTy6U9Q3Y1HdNFHeVhHffqK8Asph41GVAUS5FBaMljXWqG6vUdy0Udt4Li7+7qlFZRmM7pI2Pb6mmxRMArl2fI7j9E+Baqs5Pj9XN4tkKqrbZ9R33FHddlHedut4Y91vlLfZAePjiurSIUrbKYqbNmpb66nVtAaju8Tn+BzHmTo8qus4ztRRoMo6Vq/cmGTc8TnOlNNmjm9iybXjy1RUt1ud0ahuux2aO+/WPNc0qttux+bk2t0KRfaF4ybjtb3jiuoOagfk7tfWhp/x3NygdJf4HJ8zPFrtwJxR4t2SZ6jWdlCeqdtBuZLYyjE67nE5vA+T/XW6QIXZul7FEnMNx1HWH09paXcQHjKdjn9cvUNyI/0efdl5B+f+dmD2Ob4WSLoN+LuwTUx8beu4Q925iup2iPJmLapbr5uVLVPoavfmdro+yltkmfUhqvt8xqK6/UZx+4/ahp8LpNNdMo1zfN3uwHwM8AFJH6671nIvLsdx8kPc40u+JpluHd/TRNtLv1DSjZI2DtEmx3FGSLw7S/I1yXQ7xyczWwb+q6R3At8FDhmaVY7jjAyf42tN7YxKM7tW0k+Ai4djkuM4o8Sjui0ws/8voe8lOiB4rOQynaVFesu401fa6WZlFQpt01s66SXmGtJbKszwfC2dZbxbzw8+fSX87Dk9JfxMbIrQUXfJJOzOIunNwBuAw4Crzezb7ep7Osu4SKa3dKwep35UBqL7pUi1Ib0FSKWriQPJC1TqDhgfbzrLsNNX0qenDJded2CWVATuAX5jZuf08mxJ1wDnAHvM7KRE2VnAJ4n+tXzezD7aqh0z+wbwDUmHAH8LTK7jy3U6S0J3Smd5NmwXdUjQT4XyXnUpHKTTazrLIHT9JgYzGU5nGXz6So/pKUNKZ+ljju/9wA7g4FVtSocB+81sb92148xsZ6LqtcCngC8l7i8CVwNnEh0ufrek7URO8IpEGxeY2Z7w/kPhvrb4geKOM+XEc3xNorobJW2V9MZV90hHEg0tP9+i2dcA35S0JtR/N3BVspKZ3Qk82eT+04CdZvaomS0C24AtZvYTMzsn8dqjiI8BN5vZjzp95lz3+BzH6Z8e9+P7BPDXwEHNCs3sBknHANsk3UAUEzgzhVlHAI/V6V3AK9rUfx/weiJnfZyZfbZNXXd8jjPtpF25ISmek7tX0hmt6pnZlZK2AZ8BjjWzNEf1NpvobTmGN7OraNKjbMXQhrqSjpL0HUk7JD0k6f3h+mZJt0r6Wfh5SN09l0naKekRSX88LNscx1mhh5UbpwNvkvRLoiHoayV9eVW70quAk4CvAx9OlndgF3BUnT4SeDxlGy0Z5hzfMvBXZvZi4JXAxZJOBC4FbjOz44HbgiaUvR14CXAW8Okwwek4zhBpM8fXFDO7zMyONLOjif7N3m5mf9rQpnQK8DlgC/AuYLOkj6Qw627geEnHSJoLz9me7pO1ZmhDXTPbDewO7/dK2kE0bt8CnBGqfRG4A/hAuL7NzMrALyTtJJrgvKvlMyhQWg55fMxBNQN5eT3q+ICaOHqb1HEuXByd7Vd3el69TlM31hWKbXMEl5ht2LZquS6Pb7k8g4BKyKtTmVV5fFWKVEJkulneXlK3y+NT2ahSrOXxHVR+jr0c1JCnV6HQcFhQlWIteht//m7z7Kqhfi0aHHzMoHW3DGnlxjrgXDP7OYCk84F3rnq2dB2RPzhU0i7gw2b2BTNblnQJcAtRJPcaM3toUMaNZI5P0tHAKcAPgBcGp4iZ7Q5hb4ic4vfrbtsVriXbugi4COCoF8wOz2hnakjm3e1NzNcnt+Dqd5uprNFrHh+Amd1B1HlJXv9eQi8R9QCT9c5r0/ZNwE2tyvth6I5P0gbgH4G/NLNnpZbJqV1NZprZVmArwEtfNGNZycPrVz8zPw8MLk9vkLqXe4sUB5DHF/1jXCzNU6CaKm8vqfvblqoxb291nl66PLvaio5h6y6ZhJUbaRmq45M0S+T0vmJm/xQu/1bS4aG3dzgQJx4OdTLTcZzmTONa3WFGdQV8AdhhZh+vK9oOnB/enw98s+762yXNh/yf44EfDss+x3EihDFXWVz1mmSG2eM7Hfgz4CeS7g/X/jvwUeB6SRcCvwbOBTCzhyRdDzxMFBG+2MwGs7DUcZyWFKrGfHmyHV2SYUZ1v0vrzf9f1+Key4HLh2WT4zirURXmDozbitHiKzccZ9qpgp4ftxGjxR2f40w7RuojKfNOrh2fVQqUfhsSmC0kBGthRRegtC+RMFyvZ+oSii2RYGxzUFw5Da12f70uDi6B+UB5baRDUm6c9BvrOEl2UAnMaXSv97ZLcO6UwAz1G4PCMrOpEpYrFKiG+smE5WpIQI7TVMrlKJVoMZTH9sblS6G8VQJytZbATLi/0FCeNgHZBpTg3DVVwIe6juNMFd7jyxeiysJsSAheCgnB9bpA+3KtnGsbbwHfoAtdlOd0I9JhJzB30hWKHRKYK8yHBOZyaR5RHVjC8nJpFqNaS1iOe3rFhZBEEHp2apGgnEwYjnt6lii3hcalat3qWk9yIWyAWqr2pLvGe3yO40wdVcCDG47jTBUTMNRNe9iQbz3vONNOlcjxJV8tkLRG0g8l/Tjstfm/en20pGsk7ZH0YJOys8LenDslXdquHTP7hpm9m2gHmLd1eq73+Bxn2jHSzvGVgdea2XNhPf53Jd1sZrXdlbJ+2JA7PseZdiq0muPbKGkrcKOZ3RhfNDMD4m3kZ8MruZPSa4D3SjrbzA6Ew4beApxdX8nM7gzb1iWpHTYEELaw32JmVxAdR9lA2Bvgo/hhQ47jdEXrOb6Whw2FHtm9wHFEc2o/aGjSDxsaHkaB0qtDAvPiHNwJpVcvrOjvQun0Nvr7UHpFG303PPEHQS/Noe8n9N3wxCmRXvyXOewP4InZFV15JSzPhR2W72yvF8tz/Irfo1iKUiyOLP+mQf9e+dc8yova6p0cR7EUpWQcU/5FR/0IJ9TuP67881X6YV5MsVShUi5yIju4o3QGECXsnsSDq/TtpWgJdqVc5GR+zK2lM2vlp3Bfg34xO7iz9OqgCxzKE+wovbimZ1nmt6UXRr/ncoFZlni6tLGm17OPJ0sLQYuD2Mu/l14Q/WGUxQb28m/hfspiM0/yeCnsa1sm6N8BYGP5GZ7gBbW0lHXl53mGTbW0kvXlfTzDRiycj3tw+VmeZiPVoDeW97KXDTW9ofw8ezm4rv4zq/QzbKrVP6T8VIPeWH427ADdu05FD+ksYQORl0raBHxd0klm9mCizvQdNjQSNiT0qxP6jzroV7bX1kn/QfP3AJVXptO/4vfa6kd5UVu9k+NS6Uc4oa1+mBc36Ac5qa3+MSc36Ps4pa1+kJc06F0c2aCfYWODfp51DTq5S3Ky/pNsbtBP8IIG/e91Oln2DJvatv10Qu9N/CHuTZyvndSr22/Uyc/Wr+5I3OPrMrjRcKvZ00Q7MJ+VLMvyYUO57vGpUGVhU0gIfjokBA9QWwEWDgn6qVDepd6zN1394lLU06pP4k2j94blWeuC3hfKW+l4Oda6hX2hfF2DjpeHrV3Yx/5QtnYh2qV3f2ltU70m6AOltYCxZuFA0GtC+Yo2YD7ocmlN2HE52hppsTSH6hKMl0sziGotwbhSAlGgEHS0NM1qOyZHZ2VYLQF5JeE4TkgWYB0TkOOE4LinVlloXIpWWYiXqlUatEL95aBnQvlyrdyCngnly0PRXZOyxyfpBcCSmT0taS3REPNjiTrxYUNvAH4BfFnSR8zsQ10+pnbYEPAbosOG3tG9le3Jd4/PcZz+iROYk6/WHA58R9IDRA7qVjP7VqJO7bAhM6sSbTr8q2RD4bChu4ATJO0K+3RiZstAfNjQDuD63B025DhOhkmZwGxmD0Bi7mJ1nek+bMhxnIzja3Udx5k6JmDJWlrc8TnOtBMvWZsi3PE5zrTju7M4jjN1TOEcn6Jld/nk5JfM2e3fiJJDy4vRdufzc4sD01aE+dmgl0J5l3p/2Fp+LrS3uNhe/2g2SgAuzkc5WJWw/Xq3Ot7uvTgfcsrC9uWt9GKtfvP2Fuvaq5SLVClSCPfGW63X6wrFhmdVKXSoX6AwH/LuygUOsKZB72M9CtrKBRaZbdBVimg+5OmVRZUCBE1ZLDLboKsUIewgTxkqFGvl8XcXly+Vwxb2QS/XtIJ94WfQhbI16NrW8UErlFutvP39g9Bbj/iLe83sVLrg1A2ye/731df1fbpuI2/kusf3y5nf5R2bo7PKi+Xwj26+2LWuUmQ56JlQ3k4XqKRqvydN0GRHd1O3SJVKSAstUg3lw9NFKn19tsKI7R2H7pop7PHl2vEh2LcQrRpYV4pWDaTRFYrsWwgrFkphBUMbXUzZ/qTobuvuD3rtyPSaoA+k1gYcCHpNKJ803TUe1XUcZ+rw4IbjOFOHD3Udx5k2zGDJh7qO40wT1Srsd8fnOM40UTXY70Ndx3GmiSqQcs/m3DO0/fhaHUEnabOkWyX9LPw8pO6ey8JRco9I+uNh2eY4zgpVYH+T1yQzzI1I4yPoTgZeCpwl6ZXApcBtZnY8cFvQSDqRaJfVlxBtY/3pcKCJ4zhDxB3fALGIZkfQbQG+GK5/EXhzeL8F2GZmZTP7BbCT6Ig5x3GGyDQ6vqHO8TU7gk7SC81sN4CZ7Q4HD0N0nNz3627fFa61xlZWDcRLvtLoIpXaqWNxeSfdz/PypOfKS7XPXyxXE99Fc7221tbwdZFKbUVGbHsaXaBaW+EQtz9pultixzdNDNXxNTuCrk31ro6Tk3QRcBHAuqNeOBA7HWeamcbgxkiiuuE0pjuI5u5+K+nw0Ns7HNgTqnV1nJyZbQW2Amx86XGWhbWsk6jj3tz+hbUjXHvra3UHqbtlEnp8kt5MdKLbYUSjy2+3qz/MqO4LQk+PuiPo/hXYTnTiEuHnN8P77cDbJc2HI+WOB344LPscx4lIO8cn6ShJ35G0I2RsvL/XZ0u6RtIeSQ82KTsrZHjslHRpu3bM7Btm9m7gncDbOj13mD2+w4Evhnm+AtHxcN+SdBdwfThG7tfAuQBm9pCk64GHgWXg4jBUdhxniPTQ41sG/srMfiTpIOBeSbea2cNxhTB3v9/M9tZdO87Mdibauhb4FPCl+ovBb1wNnEk0Grxb0nagCFyRaOMCM4tHjh8K97VlaI6v1RF0ZlYCXtfinsuBy4dlk+M4q9kFt/wVHNqkSJK2Ajea2Y3xxRCcjAOUeyXtIApEPlx372uA90o628wOSHo38Bbg7PoHmNmdko5u8uzTgJ1m9mgwZBuwxcyuAM5pZijwUeBmM/tRp8/sKzccZ8oxs7N6vTc4rVOAHyTavCFMWW2TdANwAVHvrVuOAB6r07uAV7Sp/z6i6bSNoWf52XaNu+NzHKcnJG0A/hH4SzNbFRg2sytDT+0zwLF1eb1dNd/kWstzMszsKuCqbhsf5soNx3EmFEmzRE7vK2b2Ty3qvAo4Cfg68OGUj+gqy6NX3PE5jpOKMJ/2BWCHmX28RZ1TgM8Rrch6F7BZ0kdSPOZu4HhJx0iaI1rOur0/y1dwx+c4TlpOB/4MeK2k+8Pr7ESddcC5ZvZzM6sSpa79KtmQpOuAu4ATJO0K2R6Y2TJwCXALsIMoK+ShQX0An+NzHCcVZvZdms/B1df5XkIvEfUAk/XOa9PGTcBNPZrZllyfq7vx5OPslbf3fryk69Y6XqtbmS/U1n5W5sPxhRnQxT6P+ixQzdTnGbT++hHnTeyZuIMg145P0l7gkXHb0YZDgSfGbUQbsmxflm2D7Nt3gpkdNG4jskreh7qPZPl/NUn3uH29kWXbIB/2jduGLOPBDcdxpg53fI7jTB15d3xbx21AB9y+3smybeD25ZpcBzccx3F6Ie89PsdxnNS443McZ+rIreNLszvrAJ+5arfYXs4JlvRyST8JZVeFtY+DsK/pzrhZsFEDPGd5WN9faLso6T5J38qafZJ+Gdq9P05XyZJ9ucLMcvci2oX158CLgDngx8CJI3juq4GXAQ/WXbsSuDS8vxT4WHh/YrBrHjgm2FsMZT8E/pBo2c/NwH8ekH2HAy8L7w8CfhrsGLuNoZ0N4f0s0f5tr8yCbQk7/xvwVeBbGfz9/hI4NHEtM/bl6ZXXHl9td1YzWwS2Ee0CMVTM7E7gycTlVOcEKzpg6WAzu8uiv8Iv1d3Tr327Lew+a9GW3/HOuGO30SL6Pmd5mN+fpCOJDqz5fN3lzNjXgqzbl0ny6via7c7a/gze4dFwTjDRKU/Q2sYjwvvk9YGixp1xM2FjGEbeT3Sy3q1mlhnbAp8A/proGIqYLNlnwLcl3avomNWs2Zcb8rpkLdXurGOilY1Dt12JnXHbTOGM1EYbzDnLQ7FN0jnAHjO7V9IZ3dzSwo5h/n5PN7PHFR3kc6ukf21Td2x/f3kgrz2+oe7OmpLfhuED6u6c4F3hffL6QFDznXEzZaOZPQ3cQd05yxmw7XTgTZJ+STR18lpJX86QfZjZ4+HnHqJdjU/Lkn15Iq+Ob6i7s6Yk1TnBYTiyV9IrQzTtz+vu6YvQXrOdccduowZ0zvKwvj8zu8zMjjSzo4n+nm43sz/Nin2S1is6yhFJ64H/BDyYFftyx7ijK72+iI6p+ylRtOqDI3rmdUTH6i0R/c95IbAA3Ab8LPzcXFf/g8G+R6iLnAGnEv3R/pzoTFENyL4/Ihq2PADcH15nZ8FG4PeB+4JtDwJ/E66P3bYmtp7BSlQ3E/YRZTD8OLweiv/ms2Jf3l6+ZM1xnKkjr0Ndx3GcnnHH5zjO1OGOz3GcqcMdn+M4U4c7Psdxpg53fI7jTB3u+BzHmTrc8Tl9IekPJD0Q9ttbH/baa7cG13HGjicwO30j6SPAGmAtsMvMrhizSY7TFnd8Tt+E9dJ3AweA/2jRLiyOk1l8qOsMgs3ABqJdn9eM2RbH6Yj3+Jy+kbSdaCunY4DDzeySMZvkOG3J60akTkaQ9OfAspl9VVIR+BdJrzWz28dtm+O0wnt8juNMHT7H5zjO1OGOz3GcqcMdn+M4U4c7Psdxpg53fI7jTB3u+BzHmTrc8TmOM3W443McZ+pwx+c4ztThjs9xnKnDHZ/jOFOHOz7HcaaOzDk+SWdJekTSTkmXjtsex3Emj0ztzhK2NfopcCawi2hX3/PM7OGxGuY4zkSRtR7facBOM3vUzBaJNrfcMmabHMeZMLK2EekRwGN1ehfwivoKki4CLgJYv1YvP/aoAX4EpSzPTme5fzp99n7v7/Rd9ftdDrP9tJ+t3++iE13c/8DOpSfM7AV9PmliyZrja/Yn0/BrNrOtwFaAk0+Ys5s/fejgnj6X0MUOOs2ROv0ev9Pp2cnyftvv9/60n7ff+tWEXu6z/Xo6fTdpfxf9/i10cf8RZ+/+VZ9PmWiy5vh2AUfV6SOBx4f2tKx9+mnCz2FzxkjW5vjuBo6XdEw4svDtwPaBtV5JvBzHmUoy5fjMbBm4BLgF2AFcb2YPjdcqx3GGiaQXSfqCpK+N6pmZcnwAZnaTmf0HMzvWzC4f6sOWEy+nd7w33ZoJ/m4kXSNpj6QHE9e7zscNWRwXDtfSRnI9y/Xkmk1se+mbAbBy5MM1X63pGSpo3oJWKF/RyxQb6ifvT6vrn6eypbq/Up5psK/T/XF5IdSvhs/XSifbW7m/laamq+UCBaoU5iuh7WIo615XKdTarpYLVBK6/tlRebFBV1P+rqL2V76Ldvcnv/ulmo7LZxvKK+HzETThu26l4/bp8v6l8nyDjr9PC5fj302sq7X2CO0B/E9GxLXAp4AvxRdCPu7V1OXjhrOXi8AVifsvMLM9ozF1hVw7Pie/RK4wOFmgMuTBR+QKgyPBqNaFXgtUqWZv8JMLzOxOSUcnLtfycQEkbQO2mNkVwDmjtbA5uXd88f/erbU66E73d6dnwhim1rPE2tbvZG+n+0Xcm2r8PK10MdHeyv2FUJ7Ujb2x6H1jnkZ6XehLp/0uO303cf3Y6XX+20hkW41Yxz29Vpqk7hLpOIN9TUp2PwQcqLuwNaSTdaJjPm7j87UAXA6cIumy4CCHSu4dX+fhT+uhbnf3d6eXy8WGoW78R9jt/STs7XQ/taFod0PdZHvUDWU76ZWhaO9D3fq2mw1tu9Fpfzedvptuv3uC/cnyboe6yfrFcrVBrx76JtuPfrQa6q7UT+iuOQD8ZZPrHzhgZqembY0u8nEbCsxKwHt6eE7P5N7xZYWZSZu1dqaIArB2kA2ONh+3BybK8c1QWRkijng92TLFXDm/eGgbz7P5HNfoWJnPzMqaxyJw0CAbrOXjAr8hysd9xyAf0C/+1z4g8uT0HKeRuMeXfHVG0nXAXcAJknZJujAP+bgT1eMbNY09zH5X+TvOuCgA63q608zOa3H9JuCmPowaKu74HGfqEQOe48s8PtSdEqI8tgrF8Bo0RZZrbRebLIMpUK3ZUFi1lYozXloOdTdK2irpjWM0bijku8cnKC5E/4grpSj3rbiwHHT00dppUW24PyrvXrd7npWioe9M0MuhvJWuloqp7rdSyB9cWArls221StGQfHZhseF5c0EvluYadPx55hbKLJbmKVBhfiHKkyiXoryJel2gyvzCgaDXYB3qx21Hz57HErYYqtm6VNNLQc+Gz9JaF1Db78aotvzul8N3G/+uq+G7KNR+9yFdZiEEhjroSvjuV3RIn1kI0yThbyvWhPos0FDeShO0Ba24vGtaBjeeMbOL0raWB/Lt+Awq4Y/WygUMq/2DjfP02mmjUHNoce5XGt3uefESsOVaeaGDTnf/Snn0jzrOTWuli+XoH/VScHDx/bHDi3PlFmvlBD1fK4sdVpyXV6+FUS6tqbVVpdi2fpUCizVdCHquQS/VaaNQc3Dxd9FOV1Hb78YotPzuV/+uo/LYQVLThb507MCq8ZK22GHFeYCleLkhDfWTupZ3mNDdM/B0lsyTb8fnOM4A6D24kVfc8TnO1DN9wQ13fE5PFFmu22QgK4m400Gl73MCkgw8gTnz5NvxeXBjbMGNZDAD8OBGj8GN2txel8GNVsGM3oMbAmbT3pRr8u34EsGNJQq1P9p4ml8GXwAAIABJREFUf7xhBjc6Pa9ANTfBjXjCPH7+SrCjeXAjGcyIyle0sAZbK8xkNrihskXJNmMKbtSCEeE/u07BjVbBjN6DG9NHvh1fhkguWfNctfww9euURXNPsDRqQ0ZHvh2feh+KDmKoW68V/rfO61C3fmgL1HpjvQ51k7rZ0NeHuhkZ6gpY0+T6UpTADNxoZjembDXT5NvxJYa60H2e3SCGugAqRX/MS+WZhqFuL3l8Bao1h9ep/rCGuvXDz1h3O9SNn6VytANJMq8vObSMNWVGMtSN7e80zTCIoW6FYs3hDWKoW6FYl+cX/agf2lYo1NqbKaccbRSA9U2u7/UEZqcJ9cPbfndnyfvQuNjB/uQytlF/3ipFNKJnDjrq2qm95Lb9qbfxn7785Zw7vjEPdQcZ1U2rszbULVBhTdAHSmsw0g19CxSGOtStH9p2mmbod6ibHNquLk831O00tLWabuwpdk2B5kPdCSbfjm/MQ93BLllLp7M21BWRw4vLq4mhbnR/6yVtwx7qNi5RG/5Qtxvd7VC3UxS3dvZGIgrcNa3m+CaYXDu+zU89zflfuR6AskX/SOa1uKKLCZ0sn4X5QtDVOZhpcn99eVIXYL4YdCXcH5cXw/PichJ6LuiZoNcEPRv0TEJXG/UBNerng56rRvq5MGkzVwnlsaZRz4bQ3V42NOh9oXyGJZaZ5QDzteFqhRmWmGvQUXnoEVEM5fU6139qbVkZijbvaaXdcbl2+FGfdnWN9/jyhaiyUIz+2ytVon5/gxYszAS9HMrrdQEWZoNeCvXngl4M5Uk9H3R5AYp1Om5/TdDVoNfW3Q8srAs6jGMW1gddCPqgRHsbg34u6E2RfmJf0IdEeinozZsjvfhc1Ns5ZOHJqPzpSG9aeCoqD72pjQtPA3Ag9L4OXni2ofyghb3sLR1EkSIbFp4D4LnSBqoUWL/wPADPl9ZTZIa1C9FJXftL66hSYc3C/tD2WioUJnaom3Zou3o3lugHifKRDnU3pLsl7+Ta8TmOMwC8x5cvjAKlyiZgZSgb9/zKNge20nOqldfraujpsTJ0jXtmtfLFunKFnh4rQ8+aDkPN0oGgw1C3tD/oMNQthZ5ZPNQtPR90GOqW9gYdhrqlZxLPezrxvKcivRj0k08GHZ73VGlzpJcj/XTpEACWylEv6ZnSpgb9bOlgAJaD3ls6iOXyLBVmeK4UdQsq5RkqzPB8aX2dLrK/tC7oaDvSA6W1NZ2c85vGOb6VOb32c3xpV2r0Pcfnjs/pmWXSfZvFxM8RE89LFQa0G3ORat3OzqIadluOqVKoacGqp0aur1pXPtwvpkoBhXNSlsOz4nSXak0XanUjwjm4Heb0Oj+78bP1217ftA5ueAJzFsn1HF8x6A2J+iOa49sfel8bF56JykPvqNc5vipiXZjj21daR4UCa8Mc3/7SWgoUGtJdmu3oXJ9KU6A61Dk+oaHN6fWbvjKWOb7mjs8TmB3HmVA8uDE4JF0DnAPsMbOTwrXNwD8ARwO/BP7EzJ4KZZcBFxKNgv7CzG7p9Ixcz/GtDTr05Mqzo57ji/QzpY1B9zvHN8O+2hzfDFWK7A9zfNEcXjGR59dsjq9xt5ZhzvEZymzens/xDZ9hbktxLXBW4tqlwG1mdjxwW9BIOpHotPWXhHs+LWnwkzzFxGuQrD5YrD2VxGvAVAsFqoUClWL0yhqdTmVLS3R2WzzTON7PG58lF7+G1f5yePVN7PiSrwlmaD0+M7tT0tGJy1uAM8L7LwJ3AB8I17eZWRn4haSdwGlEJ7S3JPUcnxJzehOcx7d/f9R7OiTM6ZVC7yUrc3zJJW0Fqn3N8aXZjWXYc3xp8/bSzvG1mtPreY7PV24MnRea2W4AM9st6bBw/Qjg+3X1doVrjuMMmykc6mYluKEm15r+tyXpIuAigN/dPKZcEMeZJDy4MXR+K+nw0Ns7HNgTru8CjqqrdyTweLMGzGwrsBXg5N+ds1TBDasLZgw6uBHW6mYlgXmpEAc3omDGYnm8wQ1QLVhBWU0SmvsLbiSDGVWKtSFnsw0fBhncqIRzgystghnJc3Pj+vGQND53eKV+MVG/0FDeMpjRT3BjPuU9GUPSm4E3AIcBV5vZt9vVH/Us8Hbg/PD+fOCbddffLmle0jHA8cAPR2xbf2Sl7+w4aYn340u+2iBpk6SvSfpXSTsk/WEvj5Z0jaQ9kh5sUnaWpEck7ZR0abt2zOwbZvZu4J3A2zo9d5jpLNcRBTIOlbQL+DDwUeB6SRcCvwbOBTCzhyRdDzxMFB+92Mw6xjo9uJGf4AbQdtOCQQc32m1KMOjgRlaCGX0FN9L3+D4J/LOZvVXSHIkTycP8/X4z21t37Tgz25lo51rgU8CXEvcXgauBM4lGhHdL2k6Uj3FFoo0LzCwePX4o3NeWYUZ1z2tR9LoW9S8HLh+WPY7jtCDlsbqSDgZeTdS7wswWIex3tsJrgPdKOtvMDkh6N/AW4Oz6Si2yPyDK6thpZo+GZ24DtpjZFUT5wUmbRNSxutnMftTpM2QvwctxnNESp7OszuPbKGmrpDcm7ngR8O/A30u6T9LnJTWc2mFmNwD/DGyT9F+AC4A/SWHVEcBjdbpTpsf7gNcDb5X0nk6N53pmatXKjeLKELJcGEFwY6au/bBRaa09OgQ34pUbcTBkwCs3+g1ulMvR2KdSKrIcghftghugWrAintxfrAUz6GK3lnTBjQqFWvCh07m5Ftqr1nbrbr8bSzJYUQnBiXiImzaY0e9KjU7BDEsER1Kfq5t+re4M8DLgfWb2A0mfJFqM8D/qK5nZlaGn9hngWDN7LoVVXWd6hGddBVzVbePe4xsUnlnj5JXWPb5W7AJ2mdkPgv4akSNsbFZ6FXAS8HWiOf40dJ3p0Qu57vGtCm502o1l0MGNQl0wY6lFMGNMu7P0G9yIAxJxcKOK2gY3RJF1Qe8rradIIdWOzGmDG/2s1EgeDJUMbiytCl70G8xQQg82uFHraS6EIEwp7fGSBmu6XzZoZv8m6TFJJ5jZI0Tz9g/X15F0CvA5ohSTXwBflvQRM/tQl4+5Gzg+ZHn8hmhJ6zu6NrIDuXZ8juP0jwpVZjfsW3U9Ga1I8D7gKyGi+yjwrkT5OuBcM/s5gKTzCcGQhmc3yf4wsy+Y2bKkS4BbiMZT15jZQ6k+WBvc8TnOlKOCMbdmtZtr5/jM7H7g1Dbl30voJaIeYLJeq+wPzOwm4KY2ZvSMzMa06+sAOPl35+z2/ztMxndzqlqyvNDnKWtzKU5hS56ytrbDKWuJU9S6PmVtLtLPFqL8hNn5UL8cDV3ngn62fHBD+b7yuqDDqWvl6P6Z+WWWyzMsMUtxPgwVy+GUtTpdpUBxPuS9lYssMtugo/r1eobCfFjkXy6wxFyDXmS2QVcpoqDj4EZhPl75EA356nWyfpUCmo+DAWJ5VXmxVl5bWVHTMwndWF4LZsS5cHFwIejV9UMwIpTXghtB11Zu1O4vtK1vTdr7uyM+eK+ZtXRM9cycerJt+uFq/1IqHtl1G3nDe3yDIhnc8LBRbkhuBT9tFKgyV+gwsJ0wcu34Jiq4oaAPDvqABzeGGdwQ1YGt1Og3mDHu4IYw5lLnwOSbXDs+x3H6p0CVdewftxkjxR2f40w5wpj//9t79yDJyzLP9/PNrMrqezddXGwuLj3AsgI7gBdkhnFkcRwZhhEmdlh1zozXkDOz6NGzRoywGmtMHFmUOMczQ+jotspBw0svjKNcAhZZ1CB0GbkoItCijaC2MLQkt6bpzqrKfM4f7/vLynwrr1WVlZn1ez4RGZnP7/f+3t+TWZlPvZfn4iM+x3HyRJjq+hrf2LAgZK1bcaHlDlmrNYScZSFraYhar8WGsnx8zychacsUsnagEtb05srxfBKydjCer8a1wLm4Uxny8XUPWatR4MW6XFxEgfHOIWtzTHQMUUvz73UOUQshbYvNv9ctJC3Nt9ctRG2p+fey+2dre/3m4ytQy90an+89Lhf53hh0xpgw1Z1Z8KB9koKxZ6xHfL6r2/uu7kw5Kyj+bGgfR1PZrm5W+nFjm3x8w97VLWDLFqK21F3dfndxB51/b6m7umFzY2HkBl5Q3HGc1Yqv8TmOkzsK1HxX13GcfOEjvjFjpHZ11WYXd0R2dWfriUi3NMlpItJ99Spro7Wrm1ZRg86JR5urqC3vru7CxKKpnNS+WObEo8u9q+uRG3kjJA4OLHV/u4rv7K4SqvU/ZExKUP9ytE7okbZfbrJY4qz37CubyovFIzfaIOl24P+JaWKyYzuGveOz5F3ddBcX39X1XV3qI6neY3M77+IudVe33a5tN7lX8rjG1+s4ZzvwQUmN6aNXZboax8kb2Rpf+ljN9Gr4niWklz5C0o2SNg9QJ8dxVpBsjS99rGZ6XeOTmc0B/1HS24HvAocMTCvHcVaMLHIjT/Rq+D6TvTCzayT9GLhkMCo5jrOSdIjcWLX0ZPjM7L8l8r2EAsFDZcnuLJa4r+DuLO7OQlt3lgV1a3t0X1mqO0s7d5Vucq+EJAXjPeKTdCGhotvhwKfM7Jud2nuSguWiOtzbzxUL8SHmikt1cOhOgSrF+CgM+833wBxF5ijEx8r6HdUIhnz+EwuPWnwslbTfap99LnaNT1JR0g8l3bRY3SVdLWmvpAdanDtX0sOSdku6tFM/ZvYNM3s3oZLbm7rdd6z9+NydZd6d5UDlUAC2bn0agNkXwmhpUO4swprcWYzCSLuzNLqvZCO9lXJn6ea+oiW6syxH6vlFrvG9D9gFbFrQp3Q4cMDM9jUcO97MdidNrwE+CXwxub4IfAp4PaG4+N2SbiB4y16R9PFOM9sbX384XtcRH/E5Ts7J1vjSRyckHU2YWn6uTZPXAtdLWhPbvxu4Km1kZncAT7e4/gxgt5n93MxmgJ3ABWb2YzM7P3nsVeDjwC1m9oNu73msR3yO4yydDmt8myXtAG40sxuTc38H/A2wsdWFZnadpO3ATknXEfYEXt+HWkcBv2qQ9wCv7tD+vcAfRJ2PN7PPdGjrhs9x8k6Hmhst8/FJOh/Ya2b3Sjq7Xb9mdqWkncCngePM7IW+1GrRZYd7XUWLEWU7BjbVlXSMpG9L2iXpQUnvi8e3SrpN0s/i8yEN11wWFzIflvSGQenmOM48i4jcOAt4o6THCFPQcyR9aUG/0muAU4CvAx9Jz3dhD3BMg3w08HiffbRlkGt8c8AHzOxlwJnAJZJOAi4FbjezE4Dbo0w892bgZOBc4B/iAqfjOANEseZGr7u6ZnaZmR1tZscSfrPfMrO/aOpTOh34LHAB8A5gq6SP9qHW3cAJkrZLKsX73NDfO2vPwKa6ZvYE8ER8vU/SLsK8/QLg7NjsC8B3gA/G4zvNrAI8Kmk3YYHzzrb3cD++eT++ieAD9/TTWwGYtUH78RXrfnxzUR5lP75mv73w/36l/Pi6+e0t1Y8vK1a0eD8+G0R2lnXARWb2CICktxFcTZqQ9FWCPThU0h7gI2b2eTObk/Qe4FbCTu7VZvbgcim3Imt8ko4FTge+DxwRjSJm9kTc9oZgFP+54bI98Vja18XAxQDHTE8OTulWFGifeqrftFSZ69vgXe5aUouD/cX6kdUoUo1LLsvhi7aY+xvhh27RT07xwzTEHEXUcL7V9ap/Bs1pp5aahirrb7Fpo9qloRoUS8nOYmbfIQxe0uPfS+RZwggwbfeWDn3fDNzc7vxSGLjhk7QB+BrwfjN7Xmr7Z+xpMdPMdgA7AE576YStqB9fcRn9+KJT1/T6KE+urB9fJY6+NkU/vuz8uKSlWorfXrUMotC2uFB9pBb99OplHhfpt7dYP75e01Athx/fuEdu9MtADZ+kSYLR+7KZ/VM8/KSkbXG0tw3IHA8HupjpOE5r8piBeZC7ugI+D+wys080nLoBeFt8/Tbg+objb5Y0Ff1/TgDuGpR+juMEwlS3ZV3dVcsgR3xnAX8J/FjSffHYfwY+Blwr6V3AL4GLAMzsQUnXAg8RdoQvMbPRDwJ1nDGnUDPWveip55cFM/su7ddlX9fmmsuBywelk+M4C1ENSgeHrcXK4pEbjpN3rH8XmHHHDZ/j5J0a4CO+8cGsQHmmwYG5kDgsF6EcfQQqhWVwYJ6NbjM0ODQfbJCLHRyYJ5L+J6N8MGm/Yg7MwX3l+TFNRLo0h+XQPnNYLlQs5Mxr67DcWs7cWDIH4rrbS+KwnJ3P3FiqlULH9u0clNP+2rXve/RmkLNN3fE2fCOFB9eNLbXBOTeMBzVg/7CVWFnG2vB1TUSaOiwzxESktcSB2YabiNQdmJfPgblfh+U00WjWX7vEo4Ouq+tTXcdx8odPdR3HyR01xt7webEhx3H6wwhT3fTRBklrJN0l6Ucx1+bfLvbWXmzIcZzh0P/mRgU4x8xeiPH435V0i5nVsyuNerEhN3yOk3f6nOqamQFZGvnJ+EgzKb0W+GtJ55nZwVhs6E+B85K+7ohp61LqxYYAYgr7C8zsCuD8tHHMDfAxeiw25FNdx8k72a7uwqnuZkk7JP1JekmsqXsfIbvSbWb2/cbzZnYd8D8IxYb+N0Kxof/Qh1atig0tyM/ZQFZs6M8k/VW3zsd6xNc1A3PqsMwQMzBnDsxZBubMgXloGZjdgbn3jMudHZjbOSC3y7icZljulnG5XYblbnLPtN/VbVlsCCAmEDlN0hbg65JOMbMHkjYjW2xorA3fzNYJfvHWI4Dww61SZHJqti7XKDIR5bn4w26UqxSYmIq+YJWJntoXY/tqNAyNcpViU3/h+iDPVKaa2h+srG2S91c2RLla1x+gEOX6l7+bXErkmOp5lthfzEo8Gw1zdn4uOZ859RaoUaNAlULTuWC6FrbN5LT9wvPFJnmWSQr1jM5ijkkUZUPMUGqSgR7kQke5V/rNMF0dN2/2JbizmNmzkr5DqJPTZPhaFBt6Tx9dDzQ/51gbPsnYFB1uny9vokCt7oC7r7yJKjU2Tu+Lcij/2SiLYpNco9bkpAskcrHt+efLm5lgrsmpF6jL1Ti6yOTZOHpZF518s9FQ5uSbOdWuiU6+B+PoaLFydv+pBXL4xmejn0Yn4kyeKU9hQCk6FM+USwscjtNr0/YksqGODsrCEodkqzsc10PNlknu5sBM3SG5NwfmXjMsj4wDc5X5FbsekHQYMBuN3lrCFPPjSZus2NAfA48CX5L0UTP7cI+3qRcbAn5NKDb0571r2Rlf43OcvJON+NJHe7YB35Z0P8FA3WZmNyVt6sWGzKxGSDr8i7SjWGzoTuBESXtink7MbI4wQrwV2AVcO3bFhhzHGWH639W9n1A8rFObfBcbchxnxMkcmHOEGz7HyTuencVxnNyxCmJ1+8UNn+PkHU9L5ThO7vC0VI7j5A4f8Y0Xj9uR/J/lKwEoVqpUKdadUYuVGlUKdUfdYiVzVp2XaxSZi/JEPN8oF6h2vL5Irel+xYb2k5XZ2H7+fKOchRW16z+9fm3lYJM8VckcjwtN7WvJeYvyRGUung9OsoWKNcnZ+7e6PFs/X6gYRWr1c6oYk8w2hWgVqDbJpeT8JLPzjsCx/XyIlihSa5KBjnL4rJtDzBrlArW6o7LVQ9Jay1kUTjW5XxpyRnz/3ULW0hC1kQ9Z880NZ7EU8drnzpjiU90xQ3BgOoRmrS0fpEqBA9Nro3yAKkVejPK6cggFa5TD+XVRfjGen5eLSfv0eqB+v2L8b5vpUygHQ3gwymvKB5vkUnm2qf3aeL7d9aVyCO+qTIfwsMl4/cx0Kd6/GuXJpv5npyea+puL8kR5rknO9J+bzkYXMVxsugjlKgVENYZEFcs1jOYQKaM5BMugRUhXFvIlwJKaFlYPGaslIWSt5c7t+wlxy0Za2fX1UXleQtZ8V9dxnNzhDsyO4+QOH/E5jpM3qjV43jc3HMfJEzWDAz7VdRwnTxhwYNhKrDBu+Bwn59TIn+EbWCLSdrU3JW2VdJukn8XnQxquuSzW0HxY0hsGpZvjOPNkhi99rGYGmYE5q715KnAacK6kM4FLgdvN7ATg9igj6SRCeumTCfn7/yHW1nQcZ4BUgedbPFYzA5vqdqi9eQFwdjz+BeA7wAfj8Z1mVgEelbSbUFvzzvY3mXf8zUK+1kbH4ixEbF1dri6Qxbzj8kT9/LxcoNrx+iK1hvtl98/0Cfdf00bOwooW6t/5+qlyuLAQ5cyxeV6ejf0HeTI6ImchahNtZNXlatN5ylUKFQs1MOohUaFcT2OIlKApBEssrDo2H/IFoKRqmRZUOessd27fWEWtW8ha9yprqf6rK2TNp7rLTJvam0eY2RMA8fnw2LynOpqSLpZ0j6R75p7pp1rdYEkra4UaZAVqFPuu0uU4K0m2uZGnqe5ANzda1d7s0LynOppmtgPYAbDltONsVELWNpT3h1qyPYegeciah6yNRsjaahjxSbqQUNHtcOBTZvbNTu1XpMqamT1LmNKeCzwpaRtAfN4bmw20jqbjOK3pd3ND0jGSvi1pV9y4fN9i7y3pakl7JT3Q4ty5caNzt6RLO/VjZt8ws3cDbwfe1O2+g9zVPSyO9GiovfkT4AZCqTni8/Xx9Q3AmyVNxVqaJwB3DUo/x3ECi9jcmAM+YGYvA84ELombk3UkHS5pY3Ls+BZ9XUMYEDURNzY/BfwRcBLwFkknSfq3km5KHoc3XPrheF1HBjnV3QZ8Ib6BAqEu5k2S7gSujfUzfwlcBGBmD0q6FniI8MFeEqfKjuMMkH6nunFtPlun3ydpF2E9/qGGZq8F/lrSeWZ2UNK7gT8Fzkv6ukPSsS1ucwaw28x+DiBpJ3CBmV0BnJ82liTgY8AtZvaDbu9hkLu6LWtvmlkZeF2bay4HLh+UTo7jLORxuPXDcGiLU5K0A7jRzG5sdW00WqcD3288bmbXxZnbTknXAe8EXt+HWq02O1/dof17CbPKzZKON7PPdOrcIzccJ+eY2YKpZi9I2gB8DXi/mS2YHZvZlXGk9mngODPrxw2jp83OhntdBVzVa+crsrnhOM7qQtIkweh92cz+qU2b1wCnAF8HPtLnLQa62emGz3GcvojraZ8HdpnZJ9q0OR34LCEw4R3AVkkf7eM2dwMnSNouqUSI6rphaZrP44bPcZx+OQv4S+AcSffFx3lJm3XARWb2iJnVCB4cv0g7kvRVQnTWiZL2xE1PzGwOeA9wK7CLsDn64HK9AV/jcxynL8zsu7Reg2ts871EniWMANN2b+nQx83AzYtUsyPjbfhGOla3c+ytx+p6rO6oxOrmEYVcAuOJpH3Aw8PWowOHAk8NW4kOjLJ+o6wbjL5+J5rZxu7N8sl4j/jgYTN75bCVaIeke1y/xTHKusF46DdsHUYZ39xwHCd3uOFzHCd3jLvh2zFsBbrg+i2eUdYNXL+xZqw3NxzHcRbDuI/4HMdx+sYNn+M4uWNsDV8/2VmX8Z4LssUuplympFdI+nE8d1WMfVwO/Vpmxh0FHbWM5UYH9fnFvouSfijpplHTT9Jjsd/7MneVUdJvrDCzsXsAReAR4LeAEvAj4KQVuO/vAy8HHmg4diVwaXx9KfDx+PqkqNcUsD3qW4zn7gJ+hxDgcAvwR8uk3zbg5fH1RuCnUY+h6xj72RBfTxLyt505Crolev4n4CvATSP4930MODQ5NjL6jdNjXEd89eysZjYD7CRkgRgoZnYH8HRy+AJCmUzi84UNx3eaWcXMHgV2A2co1BnZZGZ3WvgWfrHhmqXq94TF7LNmto8Q3H3UKOhogXblRkfi85N0NKFgzecaDo+Mfm0Ydf1GknE1fD2Volwh+i2XeVR8nR5fVtScGXckdNTylBsd5Of3d8DfELKxZ4ySfgZ8U9K9ki4eQf3GhnENWesrO+uQaKfjwHVXkhm3wxLOiupoy1NudCC6STof2Gtm90o6u5dL2ugxyL/vWWb2uEJxndsk/aRD26F9/8aBcR3xjVIpyn7LZe6Jr9Pjy4JaZ8YdKR1taeVGB6XbWcAbJT1GWDo5R9KXRkg/zOzx+LyXkNX4jFHSb5wYV8M30OysfdJXucw4Hdkn6cy4m/bWhmuWROyvVWbcoeuoZSo3OqjPz8wuM7OjzexYwvfpW2b2F6Oin6T1iuUaJa0H/hB4YFT0GzuGvbuy2AehTN1PCbtVH1qhe36VUFZvlvCf813ANHA78LP4vLWh/Yeifg/TsHMGvJLwpX0E+CQxgmYZ9Ps9wrTlfuC++DhvFHQEfhv4YdTtAeC/xOND162Frmczv6s7EvoRPBh+FB8PZt/5UdFv3B4esuY4Tu4Y16mu4zjOonHD5zhO7nDD5zhO7nDD5zhO7nDD5zhO7nDD5zhO7nDD5zhO7nDD5ywJSa+SdH/Mt7c+5trrFIPrOEPHHZidJSPpo8AaYC2wx8yuGLJKjtMRN3zOkonx0ncDB4HftZCFxXFGFp/qOsvBVmADIevzmiHr4jhd8RGfs2Qk3UBI5bQd2GZm7xmySo7TkXFNROqMCJLeCsyZ2VckFYH/JekcM/vWsHVznHb4iM9xnNzha3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+QON3yO4+SOkTN8ks6V9LCk3ZIuHbY+juOsPkYqO0tMa/RT4PXAHkJW37eY2UNDVcxxnFXFqI34zgB2m9nPzWyGkNzygiHr5DjOKmPUEpEeBfyqQd4DvLqxgaSLgYsB1q0vvOLY4ybnzyWdFWdrzQcSkXSwW0zk9N9Ct8FxY6WJ5Npa8kmbmrWVdT5fTTosJMqk54vJmy1Ys1xVc/sKU03yXPLVmGWyST7A2mZ9F3z6zajLh1dipkmeZLZJLiTvJz1fpLnMx5RVmq9v7r75b5n+3VO6fQ8SuTrZ+YJiNf1jd7n/XCL3UNHk/kdmnzKzw7q3zCejZvha/XqavhZmtgPYAXDqKSW7+b9hS0pNAAAgAElEQVRvrZ+bKzVfOPlc0tPziZx+Pzc3iwc2dx4Ql2aaf4zFA+3bWqKb0rbpD3NDs7h/c7PhWf908w+/2myHKKb9PZ3I6T+BtFLGU4m8J5GfP9gsp/dL31/6Y00+jwW8JLFGRyby2ubPI7HbUNnYLL+QnG98/4ck59JfxfpETg1l2vfWZtGS9gv+9inpZ5V+tun9WnDUG574RfdW+WXUDN8e4JgG+Wjg8bat94P+eV6c3JScT3/cqSFMjEtqGNc+l3SQ/ljT/hq/sMmlC77sv0nkLoZv/ZpmQ8eTzWIx/XGmJHaqq2H6ZSI/lsipIU36qyTyXJdRylTy2U5sTxock8jJP6kFf8v0fGqsGvVL26b/77YkcmJzF/xDTb6xStun38tuC05dvqdO/4ya4bsbOEHSduDXwJuBP2/b+hngGw1y+p+7m6FKJwLJqGnBDyLtL/3xN/640h96eu/EcC1on47A0r/UvyRy+t7T95KSGtr0/olhnkt+zNU+C0hOJIbn+cQwvpjoc1j6jyG9X2pM0hHfkYmc/u0aR03dPqvU8KTtO30PFiOnvCSRexjxOZ0ZKcNnZnOS3gPcSvg6XG1mD7ZrXzsA+++bl9enX9BUTo3PEYmcfqHXJXL6Y0v7a/zxpV/mtG23H0uqS2IY9ieGb31qxFOjnRrSZAC54L0lTGzoLC+YDqafXTKqOSwdtaSGLe0/pZLI6TpYatg7TU/TtumILB0dp7qlywKpLimpEU7lbv9UUsPXzXA6CxgpwwdgZjcDN/fStrAJtr4ufGsrKkEJpqxBXpvIzyXyYTAVv/UVYvtGuQhTirLF/hvltL8NDdeXwre53v7FRN4X5az95kQmkQ80y/wmytn9tyXt1yb3m0zkuUReF+W4C1CpzJ+vWAlmkve+taFtrQSbYCouLFaqJdgMUxMN9yol8gtJ+1oik8gHkvs9l+hDIh+SXD+VyE839DeRvPf9iTyVyKVEv2eS8y8kci2RJ7ucn03ez7bkfs8n7YstPq9PMDZI+i3gQ8BmM/uzlbjnyBm+fvjFkcfw9iuvBKBYCf8mq1PFtvIG9lGbCkOPQqXGC2zs2L6bXKBGNfZXrNSoUej5+snKbJTD9YojmF6vn6qERbvs/dQqxb7171Vezr5cHvx3I8hvYiWQdDVwPrDXzE5pOH4u8PeE8ejnzOxj7fows58D75L0j4PWN2OsDR/M/9F7lQuVWsfz/cuhvxqFHtsv7/WF+vXFntovRR5k3y4v/3djhbgG+CTwxexADET4FA2BCLHofBG4Irn+nWa2d2VUnWfsDV8//wVfZH3TCK3f61O5nxFeKrOo/+LzcqGu/1JGBT7iG0V5qd+Nfg2gdLzBiy3OPPEgzf4AO6I7WR0zu0PSscmF9UCE0L92AheY2RWE0eHQGXvD5zjOUjkIvL/F8Q8eNLNXLqLDroEIjUiaBi4HTpd0WTSQA2XsDd9ipw+Lv37U5KVOtX2qu1rl3inQ3aenL7oGIjSdMCsDf7WcCnRj7A3fSk1NR01erumQT3VXr9w7y274+gtEGAJjb/gcx1kqy274+gtEGAKjlp3FcZwVJzN86aM7kr4K3AmcKGmPpHeZ2RyQBSLsAq7tFIgwDMZ7xCc4MB1CEtaWw+aTy8svj5IuLvcu904BSAPde8PM3tLmeM+BCMNgpBKR9suWU4+z13yrdwdml32NLy/y9Ue96d5ed2Slf2Pw+RZnfq/nPsYNn+o6Tu5pO9XdLGmHpD8ZonIDYbynuo7jLANtNzeeM7OLV1iZFcENn+PknmXf1R153PA5Tu5Z/ObGuOKGz8k9a2I4ala35AzuBubrhGznUQAKMVHemug9XoyJ9/5VTFc9GVOCrflVuG5qMqaJeiqmjZpI0lJl8ouJvL7UdP2LMWVYaTbI1eeazz+5OaSIzuqWzFDi+r4+AR/xjRfuzuLuLMsgrymHTKOV6ZBJVuVguArTwdAVyuF57fSBKIcwwfXT+wGYLAeDc8j0MwDUfhGysE5vKgNQfnY6yOujXIvyxijPRHlDlCemm66fK0T5kCA/92KUtwT5mVK435Z4/2fLaTrubuTP8Lk7i8td5VHSZRDy+sr+KMcRXyWO+KbiiK8SR3xTccRXiSO+qTjiq8QR31Qc8e0e0Iiv1GXEF+8/Uylx8lGP9OHO8kqDe1qdWbXuLOM94nNywwb21RMxFKjx7/lavaRklSKvfuq+eUMzW4Jft8i43Ci/0JDBeG+X7NhZRugs2/VUIj8e5Vpzf/UU8llq+ywl/aE0ny8lclYSIebTKMb22Y+1mvUXxyxbjn6xWX/rlvveGW/D51Pd3Ex1axSYmY4jn/IMRaqsnQ4/+APldUxNztSnfuVnp6HYMLXcH+WpKFemoQDTk1FWnDoqykTZomxtZJKp62yUq1F+Melvf5QPifKBKBejfDDpb66LPrVE/2Lz/XumwMKaKQD7gh8fcKOZ3dhfp6ONT3Vd7iqPgi5p2YB/z9coxqlntTKaI76pODSrzER5LsqHJudLiXxE0t+hiT4zyf2PXlhz5KgPPNH7VHfylcYhLaa6v/Gp7lhSoFZPAlaI84ZGudYlcGWC2fpOXoEac11KkR3P7nr/r4prJtn1h8VSXBOxvNkjHN+k1ze4sEm/lHUxQ26m80ycH7V7f6fzw6brX8ftTfd/6WOhvmXdWPykfcGcSi0WA2os5vNoi0JO2Q+1kPxwC7FYUaM82/BDL5ZgTdJfMWm/P2n/EEzNzq+ZPfovEN8Ks6Uwq4xLZvVC843yBPPtn03Or0/luO6ftV/70vihZpXqKs3y0y82t4+1g+ryxu3N7eueJHOJnKWOTKa29euWa8wiFlbhW+WMt+HrMtU14GB95y6cb5RrFDteX6DKwbjTt6Zcodqh/anlH2FAbTqOSuJO4Jrp0G6iHL6tG6ZfiOfDt7o0HX411XKhSb9SbJ/1v74cFuArcbpXS9qn7y/OwmDamu6/cXofMG/w6juL2c5hNh3Mdg4ny5Rnp8EapoaZbA1TsVrD1GwimapNxPPZVHByGqowPRPlUuyv8XzaX9p+Fqafj/KmaSZnYGM5yPumw/07yZMN8gvx/PooT0R5U5QLhwf5kKeDbNvi+9uXTDWfDfJTcWq6JV7/7HSzPHF0cv26KL+QTHVn2kxtM7m6jFNdN3yO4+SKAt3rGK8yxnqN7+hSyd6/KcwLrFQKk8GZOC+I6yad5JOBQpRrpRJ7AUXZSiV+k7TflJyf6tK+2/0b5WOjnOnzYiI/3uX6TVFu1KdRfq5PfZrkpVw7ovJUg7wu+axOjPJElI/ZEDdVojx5UrJmN9FF3pCs4WXXZ1P76WSN7uSkTu5Lmt1XKgcTd5aXLNGdZcMrjd9uscZ3p6/xOV34zbAVcJzF4lPd8UK1GoW4blKL6yhEmR7kArA2ygempxEwGeXZFu0FFKNcTdr3cr9OciHKpSgfjHKv/SvKjfo1ykvSb4nvbVTlQvLZTSRrfNmaX6kU1/ieid+NucQ9ZX0XeW3ivtLOHSVzp8ncW9Y1rHnSEAlSbZafmVpi5EYONzd8qrtMU929S5x++VR3ZWWf6s6jQ15p/LsWU92v+1R3JKkB+5dwfb9FAJ5fwr268dgSrx+kbquBqUQ+FSjG10fG58xZaeMZ8ZoYSVF5WZTjGKGSmYLMGyrbGMg6zG6W/bo2Nt/gZ5uDP8xEDHn7deXocHm84Z2V3wHAYj+PVILrU1e/x6hAiGh5Ez2Tw82NsTZ81GpDny7lQh4lXZYgNy6LFJmfyk6m7ibZVDKdmmbuO5nrz5pkappFimSRFlnSgWyqGiNLJkrHAvOuRcW661NIghBvU3eNqpaDQRtYzY32a3yrNnJjvA2f4zhLp73h8wzMI0mhAFvC+kZ9HSf7b+/y8smjpMsS5FqDXAX2R3lzPJ85Gm8sBjnblKgoynEkV6lF+WCU45peeX+UY0hb+YUob4xyTE81tzn87PaVwxy4WgkjuoPlECKiGAmSOblnU9lsJNer3DM53NwYmOGTdDVwPrDXzE6Jx7YC/x04lrCs9R/M7Jl47jLgXYQcFf+Hmd06KN2c8Wcd4fcKIXLrSOaX3GrAazZAzOLETAkmtkNcUqMyAZzasGb3b8LzVOzw2dfFKWYpHLjHTgPm1+C+XTkn3DeuwT1WCTFofcciN63JdZcHhruzLCvXAJ8Evthw7FLgdjP7mKRLo/xBSScRqq2fTPgO/09J/9rMOv/FfY0vt2t8onnNrgBMRbkyPU1phnoIWXnLNJNzzGdLWTfdHHKXuZOUgvxiKeSB2rr1aQCKL2SJSEMQ7nKtwY1MXd0cbm4MrLykmd0BPJ0cvgD4Qnz9BYiR+eH4TjOrmNmjwG7gjEHp5jhOA9mIL32sYla6ru4RZvYEQHw+PB4/CvhVQ7s98dgCJF0s6R5J9xwYqKqOkxOyNb4cGb5R2dxQi2MtPavNbAewA+DIUsl8c2N1bG6czHz0Sq1U4ne3w9Rs3ByYLMU1uYbNhq2JfAxMFeY3H2qvgOejG0lttsRTR07x3FRYlJutlHiYE+up46uVCX7G8WgqbCbcUTk7HH8hWZMrd5b73XwYtNwzOVzjW+kR35OStgHE573x+B7gmIZ2RwOPr7BuTk75WcyNmFtWwVRX0oWSPivpekl/2K39So/4bgDeBnwsPl/fcPwrkj5B2Nw4Abira2++ubFqNjfSuOmpWebz022ImxGN+fmM+dTvNt2cSn52GiaZj219fpqDU6pXQXumfAhF5lgXNyuUuY1MN4/khr05saKbG61Sz3dA0hbgc8AphNnZO83szv56ae390XDuXODvCTExnzOzj7Xrx8y+AXxD0iHA/w18s9N9B+nO8lXgbOBQSXuAjxAM3rWS3gX8ErgoKv2gpGuBhwh5aC/puqPrOM7ysLjqkn8P/A8z+zNJJYKHUR1JhwMHzGxfw7HjzWx30s81LPT+QFIR+BTwesKM8G5JNxCM4BVJH+80s2z2+OF4XUcGZvjM7C1tTr2uTfvLgcsHpY/jOG1o78DcMmRN0ibg94G3A5jZDPMJ8jNeC/y1pPPM7KCkdwN/CpzX2MjM7pB0bIt7nwHsNrOfx3vuBC4wsysII8TmtyCJMLC6xcx+0OUdj8zmxuLwyI2ByYdlGUump7G4+ZCla5qLkQ+N8jTzMa+zpRKHpZsTL4GpGANbKZbg5TAV/ecqVoJ/B1NxM6IyW+KuY1/WtPnwPc6qOwyrAr/i6KbiQ8+xpb3D8FQVKt03J0Z9s2IImxvtQtZ+i5CC8v+TdCpwL/A+M6vnDDGz6yRtB3ZKug54J2H01iutPD1e3aH9e4E/IBjr483sM506X+nNDcdxRo3+NzcmgJcDnzaz0wlJki5NG5nZlcBB4NPAG83shT606tnTI97rKjN7hZn9VTejB+M+4vPNjYHJWXLOyXKZ2elpJmgu1iNgQ5RfmA7FezZH+blWmxNV5uvGrpkG0VzHdpL5wkf7pilOzbF+Ogwg9pfXh298VNHKxDq7Ic9TqTzbsRBUXuWeKRhs6KsI+R5gj5l9P8r/SAvDJ+k1hM2PrxPW+N/T5z0G5unhIz7HyTsFo7CmsuDRDjP7F+BXkk6Mh15H2JisI+l04LOEqKx3AFslfbQPre4GTpC0PW6evJng/bEsuOFznJwjGVNrZhY8uvBe4MuS7gdOA/5rcn4dcJGZPWJmNYL72i8W3ltfBe4ETpS0J3p8YGZzhBHircAu4Foz6zd3cFvGOvX8kaWS/e8x9fwopDNfTXJ9c2NmZn5zI56rb240yNPAZJTnNzdiqvT65kaU65sbUa5vbkR5tsSPlnNzI4fy9Ue9qee08ROvONU23LkwGdJzU9s89bwzWLJsDVn68w0xW0aWWunX8Tn7g8XvOJPxeW0MPqinXnpplGtRjvnV26Viqvyr5n4rL4nyJFRm4V8O3cpkrOkwWylRpMrk1GyUJ9nPuib5AbZTiDevVQo8zXQ9JMwqBR7gFGrx5oWK8SRHjG7aplWOZExlX7ScMN6GbxVtbmSuINkGQXFDkLPUSk9ONJ+vHh7kQ54OsmWVv7INhVqUKw3RDbCwslcW7ZCmT29Il15+dprJqRk2Tz8HwHPlzRSpsXn62ShvYZJZNk6Hyh/7ypsoUGNqOiyyV8prEDUmpoNVnitPUEPMTYev30R5zjcnBiD3SoEaa0Oprtww3obPcZwlI4ypBf7Hqxs3fI6Tc0SNEu13cVcjbvgcJ+cUfMQ3ZqyikLXZKD8X5Q1RLm+JYWEzzeen4vlntgZ5bVbwJq4NVgpRnopyVjAny1lnUc7CyqpJwZyGAjmV2RKzlRLPlTcHXSslalR5rrwlypPMMsm+8qa6XKNApRzWnGqVAkaBuXL4ulmlQAFjohzW/AoVo0h16CFeq03uFV/jGzPWA6+Kr6uEfFbZG5oDtq6FUtylnCnB1AaIG49UJoF/21A0OrZrkgsNu6IF4LCGXVERkmFmu6IGbGiQY5qfunxclKOCd20PVaozl43/qxJCIjMXjVpUKNvpnKzMRjmcL1ZqTXJWmWsQLhKL3WX1XdnxoMMan9fVHUlqNdbFXc4XY1hVY9hUqQhbnwny04fEMKrn4q7l5hhGNRPlUtzF7CRbw65oIQm7ynZhi60L2JTjrmxWZDozeFlYVq0cDNjB6eCsViwHC5vt1BVi0emDUV4T/7tncqk829R+OXcKR2WX0uXB7OoKa7fG53V1HcdZnRSo+Rqf4zj5osOIb9Xihs9xck6BGuvIV81CN3yOk3N8xDdmPHXyS/l/vxXqjxQrNWoURipQvCe5nAXHxjdVVjwfNj+yheps1zbbxEjlQbpIjIp7hsuDc2fJ2xpfT2mpJN0u6bzk2I7BqOQ4zkqSjfjSx2qm1xHfduCDkl5lZn8bjw09XY1JTe4dtTEOdC+VZ6Icyl0VY8nDUdBv2J+Ny4N3Z/ERX2ueJWRZPULSjZI2D1Anx3FWkCxyI32sZnod8SlmRP2Pkt4OfBc4ZGBaOY6zYuRxxNer4ftM9sLMrpH0Y+CSwajkOM5KUvDsLK0xs/+WyPcS6mQ6jjPm+Ihv3LBm945xzvCR/cNdWz4wEvq4O8v4y70SdnXH2/BJuhD4Y+Bw4FNm9s1O7b3KmuPknBC58eKCRzckFSX9UNJNi723pKsl7ZX0QItz50p6WNJuSZd26sfMvmFm7wbeDryp233He8Sn4bsMuDuLy6Mq98oS1vjeRyj9uCk9Ielw4ICZ7Ws4dryZ7U6aXgN8Evhicn0R+BTwekJx8bsl3QAUgSuSPt5pZnvj6w/H6zriIz7HyTnZGl/6IObjk/QnC66RjiZMLT/XptvXAtdLWhPbvxu4Km1kZncAT7e4/gxgt5n93MxmgJ3ABWb2YzM7P3nsVeDjwC1m9oNu73m8R3yO4yyZRebj+zvgb4CNrU6a2XWStgM7JV1H2Ax9fR9qHQX8qkHeA7y6Q/v3An9AMNbHm9lnOrQd3IhP0jGSvi1pl6QHJb0vHt8q6TZJP4vPhzRcc1mczz8s6Q2D0s1xnHmyWN0WI76WSDof2Bu9O9piZlcCB4FPA280sxf6UEutuuxwr6vM7BVm9lfdjB4Mdqo7B3zAzF4GnAlcIukk4FLgdjM7Abg9ysRzbwZOBs4F/iHO8x3HGSDqP3LjLOCNkh4jTEHPkfSlBf1KrwFOAb4OfKRPtfYAxzTIRwOP99lHWwZm+MzsiWyuHRc4dxGGrxcAX4jNvgBcGF9fAOw0s4qZPQrsJszzHccZIIX2a3wtMbPLzOxoMzuWMFj5lpn9RWMbSacDnyX8rt8BbJX00T7Uuhs4QdJ2SaV4nxv6e2ftWZE1PknHAqcD3weOMLMnIBjHuPsDwSj+c8Nle+Kx9tjwfaXy4sdXpVjfeWbMfSbzIvfKgPLxrQMuMrNHACS9jeBq0nxv6avA2cChkvYAHzGzz5vZnKT3ALcSdnKvNrMHl0u5gRs+SRuArwHvN7PnpVZT99C0xbEFc3pJFwMXA6w/5vAFFziO0x9Lidwws+8A32lx/HuJPEsYAabt3tKh75uBmxelWBcGavgkTRKM3pfN7J/i4SclbYujvW1A5n/T05zezHYAOwC2nHacDdtXKi9+fFUKdd2yUeko6ObycvnxjXfkRr8McldXwOeBXWb2iYZTNwBvi6/fBlzfcPzNkqbiNvgJwF2D0s9xnMBiIzfGmUGO+M4C/hL4saT74rH/DHwMuFbSu4BfAhcBmNmDkq4FHiLsCF9iZv0tVjiO0zcyo1Tx7CzLgpl9l9brdhCSmra65nLg8kHp5DjOQlSDqUpt2GqsKB654Tg5RwYT+RrwueFznNxTBfqJqVgFyKxtFMjIs+XU4+w137oSmPddGnq5yEXKmRtVdSrsN5UqsyOjX+bHl+lWrNQoUh0J3VxuLV9/1JvuNbOeCoK98hTZPf+48LheRs99jBs+4htRqhTjczQ2+D6PMyAMcpZ5fswN3yrOxzfvKzd8vz734xtPuWdqhFQCOWK8DZ/jOEvHR3yO4+SOKrB/2EqsLG74HCfvGGM/1fViQ47j9EeNMNVNH22QtEbSXZJ+FJMM/+1ib+3FhhzHGQ79j/gqwDlm9kJMRPJdSbeYWT2tnBcbchxntGk/4mtZbMgCmcvzZHykDsFebMhxnBGmRrvNjbbFhuKI7F7geMKa2vcbz496saHxNnyrOANzFrmR+e8NOwNzo25Z5MaofHYuLy0D82LcWWLmpNMkbQG+LukUM3sgaXOlpJ2EYkPHDbrYEC1GlO3wqa7j5J3MgTl99ICZPUvIwHxuem6Uiw2N94hvFUdueAZml1cscqPPEZ+kw4BZM3tW0lrCFPPjSZus2NAfA48CX5L0UTP7cI+3qRcbAn5NKDb0571r2Rkf8TlO3ul/xLcN+Lak+wkG6jYzuylpUy82ZGY1Qrb1X6QdxWJDdwInStoTExRjZnNAVmxoF3DtWBUbchxnxGm/udESM7ufUDWxU5v8FhtyHGcMyNxZcoQbPsfJO6sgZK1f3PA5Tt7xEZ/jOLnD01I5jpM7vObGeOE1N/JTc2PY9x83ua+aG+tl95y08Lju8ZobjuOsVnyqO2Z45EZuIjeGff9xlHvGa244jpM7+nRgXg244XOcvOPuLI7j5I2awQGf6jqOkydqNTjgIz7HcfKEAQfmhq3FyuKGz3FyThV4fthKrDADy8fXrgSdpK2SbpP0s/h8SMM1l8VScg9LesOgdHMcZ54acKDFYzUzyESkWQm6U4HTgHMlnQlcCtxuZicAt0cZSScRsqyeTEhj/Q+xoInjOAMkj4ZvYFNdC7FwrUrQXQCcHY9/gZCv/4Px+E4zqwCPStpNKDF3Z/ubDL+gy3LJabGhYeszmsWGhn3/8ZJ7JTN8eWKgqeclFSXdB+wlpKf+PnCEmT0BEJ8Pj81blZM7qkWfF0u6R9I9c890jqyuUqRKIT588Lia8b/14jF8xLestCpB16F5T+XkzGwHsANgy2nH2WoJc/KQtaWFrA1bv1GUe8U3NwZEUoLuSUnbAOLz3thsoOXkHMdpzWpY45N0oaTPSrpe0h92az/IXd3D4kiPhhJ0PwFuIFRcIj5fH1/fALxZ0lQsKXcCcNeg9HMcJ9Cv4ZN0jKRvS9oVPTbet9h7S7pa0l5JD7Q4d2708Ngt6dJO/ZjZN8zs3cDbgTd1u+8gp7rbgC/EndkCoTzcTZLuBK6NZeR+CVwEYGYPSroWeAiYAy6JU2XHcQbIIjY35oAPmNkPJG0E7pV0m5k9lDWQdDhwwMz2NRw73sx2J31dA3wS+GLjwWg3PgW8njAbvFvSDUARuCLp451mls0cPxyv68ggd3VblqAzszLwujbXXA5cPiidHMdZyK/h1g/CoS1OSdIO4EYzuzE7GDclsw3KfZJ2ETYiH2q49rXAX0s6z8wOSno38KfAeY03MLM7JB3b4t5nALvN7OdRkZ3ABWZ2BXB+K0WBjwG3mNkPur1nj9xwnJxjZucu9tpotE4Hvp/0eV1cstop6TrgnYTRW6+08vJ4dYf27yUsp22OI8vPdOrcDZ/jOItC0gbga8D7zWzBxrCZXRlHap8GjjOzfip79OTl0XCvq4Creu18RXZ1HcdZXUiaJBi9L5vZP7Vp8xrgFODrwEf6vMVAvTzc8DmO0xdxPe3zwC4z+0SbNqcDnyVEZL0D2Crpo33c5m7gBEnbJZUI4aw3LE3zedzwOY7TL2cBfwmcI+m++DgvabMOuMjMHjGzGsF17RdpR5K+SghLPVHSnujtgZnNAe8BbgV2EbxCHlyuN+BrfI7j9IWZfZfWa3CNbb6XyLOEEWDa7i0d+rgZuHmRanZkVdfVHadarF5Xd2l1dYet36jJ/dTVzSNjbfgk7QMeHrYeHTgUeGrYSnRglPUbZd1g9PU70cw2DluJUWXcp7oPj/J/NUn3uH6LY5R1g/HQb9g6jDK+ueE4Tu5ww+c4Tu4Yd8O3Y9gKdMH1WzyjrBu4fmPNWG9uOI7jLIZxH/E5juP0jRs+x3Fyx9gavn6ysy7jPRdki11MnWBJr5D043juqhj7uBz6tcyMOwo6ahnrLA/q84t9FyX9UNJNo6afpMdiv/dl7iqjpN9YYWZj9yBkYX0E+C2gBPwIOGkF7vv7wMuBBxqOXQlcGl9fCnw8vj4p6jUFbI/6FuO5u4DfIYT93AL80TLptw14eXy9Efhp1GPoOsZ+NsTXk4T8bWeOgm6Jnv8J+Apw0wj+fR8DDk2OjYx+4/QY1xFfPTurmc0AOwlZIAaKmd0BPJ0cvoBQH5j4fGHD8Z1mVjGzR4HdwBkKBZY2mdmdFr6FX2y4Zqn6PWEx+6yFlN9ZZtyh62iBdnWWR+Lzk3Q08MfA5xoOj4x+bRh1/UaScTV8PdXgXSH6rRN8VHydHl9W1JwZdyR01PLUWR7k5/d3wN8QylBkjJJ+BnxT0r2SLh5B/caGceOUyQQAAAIfSURBVA1Z6ys765Bop+PAdVeSGbfDEs6K6mjLU2d5ILpJOh/Ya2b3Sjq7l0va6DHIv+9ZZva4QiGf2yT9pEPboX3/xoFxHfGNUg3efusE74mv0+PLglpnxh0pHW1pdZYHpdtZwBslPUZYOjlH0pdGSD/M7PH4vJeQ1fiMUdJvnBhXwzfQ7Kx90led4Dgd2SfpzLib9taGa5ZE7K9VZtyh66hlqrM8qM/PzC4zs6PN7FjC9+lbZvYXo6KfpPUKpRyRtB74Q+CBUdFv7Bj27spiH4QydT8l7FZ9aIXu+VVCWb1Zwn/OdwHTwO3Az+Lz1ob2H4r6PUzDzhnwSsKX9hFCTVEtk36/R5i23A/cFx/njYKOwG8DP4y6PQD8l3h86Lq10PVs5nd1R0I/ggfDj+Ljwew7Pyr6jdvDQ9Ycx8kd4zrVdRzHWTRu+BzHyR1u+BzHyR1u+BzHyR1u+BzHyR1u+BzHyR1u+BzHyR1u+JwlIelVku6P+fbWx1x7nWJwHWfouAOzs2QkfRRYA6wF9pjZFUNWyXE64obPWTIxXvpu4CDwuxaysDjOyOJTXWc52ApsIGR9XjNkXRynKz7ic5aMpBsIqZy2A9vM7D1DVslxOjKuiUidEUHSW4E5M/uKpCLwvySdY2bfGrZujtMOH/E5jpM7fI3PcZzc4YbPcZzc4YbPcZzc4YbPcZzc4YbPcZzc4YbPcZzc4YbPcZzc8f8DT+ieCMSDmKgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1284,7 +916,7 @@ " sigma_est_l0_qx2,\n", " sigma_est_l0_ps0\n", "]\n", - "fig, axs = plt.subplots(4,1, figsize=(5, 10))\n", + "fig, axs = plt.subplots(4,1, figsize=(10, 10))\n", "for ii in range(4):\n", " cb = plt.colorbar(\n", " mesh.plotImage(\n", @@ -1303,20 +935,19 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "ename": "NameError", + "evalue": "name 'sigma_est_l2_ps0' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0msigma_est_l2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0msigma_est_l2_qx2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0msigma_est_l2_ps0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m ]\n\u001b[0;32m 7\u001b[0m \u001b[0mfig\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfigsize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'sigma_est_l2_ps0' is not defined" + ] } ], "source": [ @@ -1327,7 +958,7 @@ " sigma_est_l2_ps0\n", "]\n", "fig, axs = plt.subplots(4,1, figsize=(5, 10))\n", - "for ii in range(4):\n", + "for ii in range(3):\n", " cb = plt.colorbar(\n", " mesh.plotImage(\n", " sigmas[ii], grid=True, clim=(1./50, 1e-1), ax=axs[ii], \n", @@ -1367,7 +998,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/Test_global_em1d_inversion_td.ipynb b/notebooks/examples/Test_global_em1d_inversion_td.ipynb index 27a8419..ec8a14d 100644 --- a/notebooks/examples/Test_global_em1d_inversion_td.ipynb +++ b/notebooks/examples/Test_global_em1d_inversion_td.ipynb @@ -2,23 +2,16 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Populating the interactive namespace from numpy and matplotlib\n" - ] - } - ], + "outputs": [], "source": [ - "from SimPEG import Mesh, Maps\n", + "from discretize import TensorMesh\n", + "from SimPEG import maps, data\n", "import numpy as np\n", "from matplotlib.colors import LogNorm\n", "from simpegEM1D import (\n", - " GlobalEM1DProblemTD, GlobalEM1DSurveyTD, get_vertical_discretization_time, EM1DSurveyTD\n", + " GlobalEM1DSimulationTD, GlobalEM1DSurveyTD, get_vertical_discretization_time, EM1DSurveyTD\n", ")\n", "from pymatsolver import PardisoSolver\n", "%pylab inline" @@ -33,22 +26,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from simpegEM1D import skytem_HM_2015\n", "wave = skytem_HM_2015()\n", @@ -65,7 +45,7 @@ "n_sounding = 10\n", "dx = 100.\n", "hx = np.ones(n_sounding) * dx\n", - "mesh = Mesh.TensorMesh([hx, hz], x0='00')\n", + "mesh = TensorMesh([hx, hz], x0='00')\n", "inds = mesh.gridCC[:,1]<25\n", "sigma = np.ones(mesh.nC) * 1./20.\n", "sigma[inds] = 1./20.\n", @@ -88,31 +68,21 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from SimPEG import (\n", - " Regularization, Directives, Inversion, InvProblem, Optimization, DataMisfit, Utils\n", + " regularization, directives, inversion, inverse_problem, optimization, data_misfit, utils\n", ")\n", "from simpegEM1D import get_2d_mesh, LateralConstraint" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">> Set parameters\n", - ">> Serial version is used\n", - "SimPEG.Survey assigned new std of 3.00%\n" - ] - } - ], + "outputs": [], "source": [ "x = mesh.vectorCCx\n", "y = np.zeros_like(x)\n", @@ -121,7 +91,7 @@ "src_locations = np.c_[x, y, z]\n", "topo = np.c_[x, y, z-30.].astype(float)\n", "\n", - "mapping = Maps.ExpMap(mesh)\n", + "mapping = maps.ExpMap(mesh)\n", "\n", "survey = GlobalEM1DSurveyTD(\n", " rx_locations = rx_locations,\n", @@ -138,58 +108,34 @@ " base_frequency = np.array([20.]).repeat(n_sounding),\n", ")\n", "\n", - "prob = GlobalEM1DProblemTD(\n", - " [], sigmaMap=mapping, hz=hz, parallel=False, n_cpu=2,\n", + "sim = GlobalEM1DSimulationTD(\n", + " mesh, sigmaMap=mapping, survey=survey, hz=hz, parallel=False, n_cpu=2,\n", " Solver=PardisoSolver\n", ")\n", - "prob.pair(survey)\n", + "\n", "m = np.log(sigma_em1d)\n", - "dobs = survey.makeSyntheticData(m, std=0.03, force=True)" + "d_true = sim.dpred(m)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "DOBS = dobs.reshape(( prob.n_sounding, time.size))\n", + "DOBS = d_true.reshape(( sim.n_sounding, time.size))\n", "for i_time in range(time.size):\n", " plt.semilogy(mesh.vectorCCx, -DOBS[:,i_time], 'k')" ] }, { "cell_type": "code", - "execution_count": 153, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 153, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mesh_reg = get_2d_mesh(n_sounding, hz)\n", - "regmap = Maps.IdentityMap(mesh_reg)\n", + "regmap = maps.IdentityMap(mesh_reg)\n", "# mapping is required ... for IRLS\n", "reg = LateralConstraint(\n", " mesh_reg, mapping=regmap,\n", @@ -197,54 +143,29 @@ " alpha_x = 1.,\n", " alpha_y = 1, \n", ")\n", - "xy = Utils.ndgrid(np.arange(n_sounding), np.r_[0.])\n", + "xy = utils.ndgrid(np.arange(n_sounding), np.r_[0.])\n", "reg.get_grad_horizontal(xy, hz, dim=2)" ] }, { "cell_type": "code", - "execution_count": 154, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SimPEG.DataMisfit.l2_DataMisfit assigning default eps of 1e-5 * ||dobs||\n", - "SimPEG.InvProblem will set Regularization.mref to m0.\n", - "\n", - " SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", - " ***Done using same Solver and solverOpts as the problem***\n", - "model has any nan: 0\n", - "============================ Inexact Gauss Newton ============================\n", - " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", - "-----------------------------------------------------------------------------\n", - "x0 has any nan: 0\n", - " 0 3.16e+01 3.96e+03 0.00e+00 3.96e+03 3.71e+03 0 \n", - " 1 1.58e+01 8.10e+02 1.89e+01 1.11e+03 5.24e+02 0 \n", - " 2 7.91e+00 4.54e+02 3.34e+01 7.18e+02 2.59e+02 0 Skip BFGS \n", - " 3 3.95e+00 2.85e+02 4.88e+01 4.78e+02 1.60e+02 0 Skip BFGS \n", - " 4 1.98e+00 1.91e+02 6.60e+01 3.22e+02 9.59e+01 0 Skip BFGS \n", - " 5 9.88e-01 1.41e+02 8.38e+01 2.24e+02 5.73e+01 0 Skip BFGS \n", - " 6 4.94e-01 1.15e+02 1.02e+02 1.65e+02 5.45e+01 0 Skip BFGS \n", - "------------------------- STOP! -------------------------\n", - "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 3.9595e+02\n", - "1 : |xc-x_last| = 2.9761e-01 <= tolX*(1+|x0|) = 5.2888e+00\n", - "0 : |proj(x-g)-x| = 5.4504e+01 <= tolG = 1.0000e-01\n", - "0 : |proj(x-g)-x| = 5.4504e+01 <= 1e3*eps = 1.0000e-02\n", - "0 : maxIter = 30 <= iter = 7\n", - "------------------------- DONE! -------------------------\n" - ] - } - ], + "outputs": [], "source": [ + "std = 0.03\n", + "floor = 0.\n", "std = 0.03\n", "floor = 0.\n", "np.random.seed(1)\n", - "uncert = std*abs(dobs)+floor\n", - "survey.dobs = dobs.copy()\n", + "uncert = std*abs(d_true)+floor\n", + "noise = std*np.abs(d_true)*np.random.randn(len(d_true))\n", + "d_obs = d_true + noise\n", + "\n", + "dataObj = data.Data(survey, dobs=d_obs, noise_floor=uncert)\n", + "\n", "m0 = np.ones(mesh.nC) * np.log(1./20.)\n", - "dmisfit = DataMisfit.l2_DataMisfit(survey)\n", + "dmisfit = data_misfit.L2DataMisfit(dataObj, sim)\n", "dmisfit.W = 1./uncert\n", "# p = 0\n", "# qx, qz = 1., 1.\n", @@ -253,14 +174,14 @@ "# maxIRLSiter=5, minGNiter=1, fix_Jmatrix=True,\n", "# betaSearch=False\n", "# )\n", - "opt = Optimization.InexactGaussNewton(maxIter = 30)\n", - "invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)\n", - "beta = Directives.BetaSchedule(coolingFactor=2, coolingRate=1)\n", - "betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", - "target = Directives.TargetMisfit()\n", - "inv = Inversion.BaseInversion(invProb, directiveList=[beta,betaest,target])\n", + "opt = optimization.InexactGaussNewton(maxIter = 30)\n", + "invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)\n", + "beta = directives.BetaSchedule(coolingFactor=2, coolingRate=1)\n", + "betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.)\n", + "target = directives.TargetMisfit()\n", + "inv = inversion.BaseInversion(invProb, directiveList=[beta,betaest,target])\n", "# inv = Inversion.BaseInversion(invProb, directiveList=[IRLS,betaest])\n", - "prob.counter = opt.counter = Utils.Counter()\n", + "# prob.counter = opt.counter = Utils.Counter()\n", "opt.LSshorten = 0.5\n", "opt.remember('xc')\n", "mopt = inv.run(m0)" @@ -268,17 +189,17 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "sigma_est = Utils.mkvc((np.exp(mopt)).reshape((prob.n_sounding, prob.n_layer)))\n", + "sigma_est = utils.mkvc((np.exp(mopt)).reshape((sim.n_sounding, sim.n_layer)))\n", "# sigma_est_l2 = Utils.mkvc((np.exp(invProb.l2model)).reshape((prob.n_sounding, prob.n_layer)))" ] }, { "cell_type": "code", - "execution_count": 115, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -288,44 +209,9 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Laterally-contrained model: L0 L2')" - ] - }, - "execution_count": 116, - "metadata": {}, - "output_type": "execute_result" - }, - { - "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" - } - ], + "outputs": [], "source": [ "cb = plt.colorbar(\n", " mesh.plotImage(\n", @@ -355,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -364,32 +250,19 @@ }, { "cell_type": "code", - "execution_count": 156, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "n_time = time.size\n", - "PRED = invProb.dpred.reshape((prob.n_sounding, n_time))" + "PRED = invProb.dpred.reshape((sim.n_sounding, n_time))" ] }, { "cell_type": "code", - "execution_count": 157, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for i_time in range(n_time):\n", " plt.semilogy(mesh.vectorCCx, -DOBS[:,i_time], 'k')\n", @@ -398,17 +271,17 @@ }, { "cell_type": "code", - "execution_count": 158, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "J_sigma = prob.getJ_sigma(m)\n", + "J_sigma = sim.getJ_sigma(m)\n", "J = J_sigma" ] }, { "cell_type": "code", - "execution_count": 159, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -417,20 +290,9 @@ }, { "cell_type": "code", - "execution_count": 160, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 160, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "reg = LateralConstraint(\n", " mesh_reg, mapping=regmap,\n", @@ -438,13 +300,13 @@ " alpha_x = 1.,\n", " alpha_y = 1., \n", ")\n", - "xy = Utils.ndgrid(np.arange(n_sounding), np.r_[0.])\n", + "xy = utils.ndgrid(np.arange(n_sounding), np.r_[0.])\n", "reg.get_grad_horizontal(xy, hz, dim=2)" ] }, { "cell_type": "code", - "execution_count": 161, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -453,27 +315,16 @@ }, { "cell_type": "code", - "execution_count": 162, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "24.06444818614206" - ] - }, - "execution_count": 162, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "betaest.beta0 " ] }, { "cell_type": "code", - "execution_count": 163, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -492,7 +343,7 @@ }, { "cell_type": "code", - "execution_count": 164, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -503,28 +354,15 @@ }, { "cell_type": "code", - "execution_count": 165, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig = plt.figure(figsize=(10, 5))\n", "ax1 = plt.subplot(121)\n", "ax2 = plt.subplot(122)\n", "ii = 2\n", - "sigma_est = Utils.mkvc((np.exp(mopt)).reshape((prob.n_sounding, prob.n_layer)))\n", + "sigma_est = utils.mkvc((np.exp(mopt)).reshape((sim.n_sounding, sim.n_layer)))\n", "cb = plt.colorbar(\n", " mesh.plotImage(\n", " 1./sigma_est, grid=True, clim=(20, 50),pcolorOpts={\"norm\":LogNorm()},\n", @@ -532,7 +370,7 @@ " )[0],\n", " fraction=0.02, pad=0.04, ax=ax1\n", ")\n", - "sigma_est = Utils.mkvc((np.exp(mopt+x[:,ii])).reshape((prob.n_sounding, prob.n_layer)))\n", + "sigma_est = utils.mkvc((np.exp(mopt+x[:,ii])).reshape((sim.n_sounding, sim.n_layer)))\n", "cb = plt.colorbar(\n", " mesh.plotImage(\n", " 1./sigma_est, grid=True, clim=(20, 50),pcolorOpts={\"norm\":LogNorm()},\n", @@ -548,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 166, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -558,39 +396,9 @@ }, { "cell_type": "code", - "execution_count": 167, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1000\n" - ] - }, - { - "data": { - "text/plain": [ - "(2, 200)" - ] - }, - "execution_count": 167, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ii=1\n", "n_samples = [3, 5, 20, 50, 80, 100, 200, 300, 400, 500, 600, 700, 1000, 10000]\n", @@ -625,27 +433,14 @@ }, { "cell_type": "code", - "execution_count": 168, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ii = 12\n", - "dpred = survey.dpred(mopt+x[:,ii])\n", + "dpred = sim.dpred(mopt+x[:,ii])\n", "n_time = time.size\n", - "PRED = dpred.reshape((prob.n_sounding, n_time))\n", + "PRED = dpred.reshape((sim.n_sounding, n_time))\n", "\n", "for i_time in range(n_time):\n", " plt.semilogy(mesh.vectorCCx, -DOBS[:,i_time], 'k')\n", @@ -676,7 +471,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/depth-of-investigation-christiansen-2012.ipynb b/notebooks/examples/depth-of-investigation-christiansen-2012.ipynb index 27873a5..d990658 100644 --- a/notebooks/examples/depth-of-investigation-christiansen-2012.ipynb +++ b/notebooks/examples/depth-of-investigation-christiansen-2012.ipynb @@ -91,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -153,21 +153,17 @@ " base_frequency_dual_moment=210, \n", " )\n", " \n", - " expmap = Maps.ExpMap(mesh1D)\n", + " expmap = maps.ExpMap(mesh1D)\n", "\n", - " prob = EM1D(mesh1D, sigmaMap=expmap, verbose=False)\n", - " if prob.ispaired:\n", - " prob.unpair()\n", - " if TDsurvey.ispaired:\n", - " TDsurvey.unpair()\n", - " prob.pair(TDsurvey)\n", + " sim = EM1D(mesh1D, survey=TDsurvey, sigmaMap=expmap, verbose=False)\n", + " \n", " prob.chi = np.zeros(TDsurvey.n_layer)\n", - " return TDsurvey, prob" + " return TDsurvey, sim" ] }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -187,22 +183,18 @@ " \n", " expmap = Maps.ExpMap(mesh1D)\n", " \n", - " prob = EM1D(\n", - " mesh1D, sigmaMap=expmap,\n", + " sim = EM1D(\n", + " mesh1D, survey=FDsurvey, sigmaMap=expmap,\n", " chi= np.zeros(FDsurvey.n_layer),\n", " verbose=False\n", " )\n", - " if prob.ispaired:\n", - " prob.unpair()\n", - " if FDsurvey.ispaired:\n", - " FDsurvey.unpair()\n", - " prob.pair(FDsurvey) \n", - " return FDsurvey, prob" + " \n", + " return FDsurvey, sim" ] }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -211,13 +203,13 @@ "(0.5, 100)" ] }, - "execution_count": 116, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAFgCAYAAACljfyxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAaLElEQVR4nO3df7RdZX3n8fdnkiYCnUpSYAFJhKgBmyAFvAbHFgULJDAjqT+mDQOKSJtqE2WVcVUQBvyVVRSwoyNQQxvBJZCJLpUIkZQ4DdRWSi6/k0jgEqBcgngjFEE0EPjOH/u5cnKyz73nPvf8zPm81jor5zzPs/f53s29H/Z+zj57KyIwMxur/9TuAsysOzk8zCyLw8PMsjg8zCyLw8PMsjg8zCxL14eHpPmSNksakHRuu+sx6xXq5vM8JE0AHgROAAaB9cCpEbGprYWZ9YBu3/OYCwxExJaIeBFYASxoc01mPWFiuwsYp2nA4xWvB4GjKwdIWgQsAthrr73e8qY3val11Vnbbd68GYBDDz20zZV0njvvvHNbROybu3y3h4dK2nY6DouIZcAygL6+vujv729FXdYhjj32WADWrVvX1jo6kaTHxrN8tx+2DAIzKl5PB7a2qRazntLt4bEemCVppqRJwEJgVZtrMusJXX3YEhE7JC0B1gATgOURsbHNZZn1hK4OD4CIWA2sbncdZr2m2w9bzKxNHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZOiI8JP13SRslvSKpr6rvPEkDkjZLmlfRPj+1DUg6t/VVm/W2jggPYAPwXuC2ykZJs4GFwBxgPnCFpAmSJgCXAycBs4FT01gza5GJ7S4AICJ+AiCpumsBsCIitgOPSBoA5qa+gYjYkpZbkcZuak3FZtYpex61TAMer3g9mNpqte9C0iJJ/ZL6h4aGmlaoWa9p2Z6HpLXA/iVd50fEDbUWK2kLykMvylYQEcuAZQB9fX2lY8xs7FoWHhFxfMZig8CMitfTga3pea12M2uBTj9sWQUslDRZ0kxgFnAHsB6YJWmmpEkUk6qr2linWc/piAlTSe8B/g+wL3CTpHsiYl5EbJS0kmIidAewOCJeTsssAdYAE4DlEbGxTeWb9aSOCI+I+C7w3Rp9S4GlJe2rgdVNLs3Mauj0wxYz61AODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL4vAwsywODzPL0hHhIekSSQ9Iuk/SdyXtXdF3nqQBSZslzaton5/aBiSd257KzXpXR4QHcAtwWEQcDjwInAcgaTawEJgDzAeukDRB0gTgcuAkYDZwahprZi3SEeEREf8YETvSy9uB6en5AmBFRGyPiEeAAWBuegxExJaIeBFYkcaaWYt0RHhU+TDwg/R8GvB4Rd9gaqvVvgtJiyT1S+ofGhpqQrlmvWliq95I0lpg/5Ku8yPihjTmfGAHcO3wYiXjg/LQi7L3jYhlwDKAvr6+0jFmNnYtC4+IOH6kfklnAP8N+KOIGP4jHwRmVAybDmxNz2u1m1kLdMRhi6T5wCeBUyLihYquVcBCSZMlzQRmAXcA64FZkmZKmkQxqbqq1XWb9bKW7XmM4qvAZOAWSQC3R8RHImKjpJXAJorDmcUR8TKApCXAGmACsDwiNrandLPe1BHhERFvHKFvKbC0pH01sLqZdZlZbR1x2GJm3cfhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZ6rrpk6TXA+8EDgb2AIaAu4B/iYhfN606M+tYI4aHpNOAs4E+4CmKm0n/CpgKfB74taRrgS9ExGNNrtXMOkjN8JB0N8X9Ya8G3hcRj1f1Twb+C8VNpvsl/WVEfKuJtZpZBxlpz+OCiLipVmdEbAfWAeskXQDMbHBtZtbBaobHSMFRMnYbsK0hFZlZV6hrwnSYpKnAflR9ShMRmxpZlJl1vno/bTkS+Drw5uouIIAJDa7LzDpcvXsey4EnKD55eYoiMMysh9V7ktgs4OyIuDUiHoiIzZWP8RYh6XOS7pN0j6R/lHRgapekr0gaSP1HVSxzhqSH0uOM8dZgZmNTb3j8CPi9JtZxSUQcHhFHADcCF6b2kyiCaxawCLgSfjP3chFwNDAXuEjSlCbWZ2ZV6j1sOQv4+3Sm6QbgpcrOiLhtPEVExC8qXu7Fq4dFC4BvREQAt0vaW9IBwLHALRHxNICkW4D5wPXjqcPM6ldveMwCjgDmlfQ1ZMJU0lLgg8CzwHGpeRpQeXLaYGqr1W5mLVLvYcvXgB9SfNqyH7BvxWO/elYgaa2kDSWPBQARcX5EzACuBZYML1ayqhihvex9F0nql9Q/NDRUT6lmVod69zymAydHxMO5bxQRx9c59DrgJoo5jUFgRlUdW1P7sVXt62q87zJgGUBfX58/JTJrkHr3PG4B3tKsIiTNqnh5CvBAer4K+GD61OVtwLMR8SSwBjhR0pQ0UXpiajOzFql3z+Nm4DJJhwP3s+uE6XfGWcfFkg4FXgEeAz6S2lcDJwMDwAvAmen9npb0OWB9GvfZ4clTM2uNesPjivTvp0r6xj1hGhHvq9EewOIafcspTl4zszaoKzwiwlccM7OdOBTMLEvN8JB0uqSyj0TLxh4s6ZjGlWVmnW6kPY8PA5slfUrSYdVBImmqpFMkrQTuAF7bzELNrLPUDI+IeBfwVxQXPr4XeF7SI5J+IumnFBdB/hrFJyFzIuLGVhRsZp1hxAnTdDWxmyTtA/whcBDF1dO3AXcDd0fEK02v0sw6Tr2ftmwDvtfkWsysi/jTFjPL4vAwsywODzPL4vAwsywODzPLUvd9WyQdDfwR5fdt+XiD6zKzDlfvfVs+AXyR4oSwrex81S5fYMesB9W753E28PGI+GozizGz7lHvnMfvUFyYx8wMqD88rqe4tYGZGTDCYYukcypePg58RtIfAPex62UIv9Sc8sysU4005/GxqtfPA29Pj0oBODzMekzN8IiIma0sxMy6S11zHpIulLRnSfseki4sW8bMdm/1TpheBPx2Sfueqc/Meky94SHKTwY7EvD9Usx60IgniUl6jiI0AtgiqTJAJgCvAf6ueeWZWaca7QzTJRR7HcuB8ynuYD/sReDRiPhxk2ozsw422jVMrwGQ9AjwrxHx0kjjzax31HsN01slvUbSB4DZqXkTcH1E/Kpp1ZlZx6r3o9qjgC3AZcDc9LiUYh7kqOaVZ2adqt5PW5YBPwKmR8Q7IuIdwAzgttRnZj2m3q/kzwE+GBG/HG6IiF9K+izQ35TKzKyj1bvn8QBwYEn7AcCDjSvHzLpFvXseFwBfSXsat6e2t6X2cyVNHR4YET5pzKwH1Bse30//XserZ5oO3/j6horXQXHymJnt5uoNj+OaWkWSrpV6CbBvRGyTJODLwMnAC8CHIuKuNPYMij0fgM8Pn5NiZq1R93kezS5E0gzgBODfK5pPAmalx9HAlcDR6TDpIqCPYm/nTkmrIuKZZtdpZoW679si6c2SvirpB5IOSG1/LOnIBtXyt8Bfs/MX8BYA34jC7cDe6b3nAbdExNMpMG7Bl0k0a6l6TxI7EVgPTAPeBeyRut5AA76SL+kU4ImIuLeqaxrFJRCHDaa2Wu1l614kqV9S/9DQ0HhLNbOk3jmPzwHnRMQV6Zu2w9YB/7OeFUhaC+xf0nU+8CngxLLFStpihPZdGyOWkU5k6+vr8z1mzBpkLCeJld164Wlgakn7LiLi+LJ2SW8GZgL3FvOjTAfukjSXYo9iRsXw6RQ3nRoEjq1qX1dPHWbWGPXOeTxD+WHBURR/yNki4v6I2C8iDo6Ig9P6joqInwKrgA+q8Dbg2Yh4ElgDnChpiqQpFHsta8ZTh5mNTb17HtcBl0j6E4rDg4mS3knx5bivN6s4ir2dkyluc/kCcCYUJ6JJ+hzFPAzAZ31ymllrjeUM06uBxyjmGzalf68DljayoLT3Mfw8gMU1xi2nuEiRmbVBved5vASclq6UfiTF4c7dEfFQM4szs85V754HABHxMPBwk2oxsy4y6oRpujfLRZLuk/S8pOck3SvpAkl7jLa8me2eRrt6+kTg/1F8qnIzcBPFXMds4ELgJEnvjIgdzS7UzDrLaIcti4A3Unx0urGyQ9JhwD+lMVc0pzwz61SjHba8H1haHRwAEbEB+Js0xsx6zGjhMYfisKWWtcBhjSvHzLrFaOExBRjp22RDwN6NK8fMusVo4TEBGGky9BV85TCznjTahKmAb0raXqN/coPrMbMuMVp41HNpv280ohAz6y6j3av2zFYVYmbdpe7LEJqZVXJ4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFkWh4eZZXF4mFmWjggPSZ+W9ISke9Lj5Iq+8yQNSNosaV5F+/zUNiDp3PZUbta7Rrv1Qiv9bURcWtkgaTawkOK2lwcCayUdkrovB04ABoH1klZFxKZWFmzWyzopPMosAFZExHbgEUkDwNzUNxARWwAkrUhjHR5mLdIRhy3JEkn3SVouaUpqmwY8XjFmMLXVat+FpEWS+iX1Dw2NdNtdMxuLloWHpLWSNpQ8FgBXAm8AjgCeBC4bXqxkVTFC+66NEcsioi8i+vbdd98G/CRmBi08bImI4+sZJ+kq4Mb0chCYUdE9HdiantdqN7MW6IjDFkkHVLx8D7AhPV8FLJQ0WdJMYBZwB7AemCVppqRJFJOqq1pZs1mv65QJ0y9KOoLi0ONR4C8AImKjpJUUE6E7gMUR8TKApCXAGmACsDwiNrajcLNe1RHhEREfGKFvKbC0pH01sLqZdZlZbR1x2GJm3cfhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZHB5mlsXhYWZZOiY8JH1M0mZJGyV9saL9PEkDqW9eRfv81DYg6dz2VG3Wuya2uwAASccBC4DDI2K7pP1S+2xgITAHOBBYK+mQtNjlwAnAILBe0qqI2NT66s16U0eEB/BR4OKI2A4QET9L7QuAFan9EUkDwNzUNxARWwAkrUhjHR5mLdIphy2HAMdI+jdJt0p6a2qfBjxeMW4wtdVqN7MWadmeh6S1wP4lXeenOqYAbwPeCqyU9HpAJeOD8tCLGu+7CFgE8LrXvW7shZtZqZaFR0QcX6tP0keB70REAHdIegXYh2KPYkbF0OnA1vS8Vnv1+y4DlgH09fWVBoyZjV2nHLZ8D3gXQJoQnQRsA1YBCyVNljQTmAXcAawHZkmaKWkSxaTqqrZUbtajOmXCdDmwXNIG4EXgjLQXslHSSoqJ0B3A4oh4GUDSEmANMAFYHhEb21O6WW/qiPCIiBeB02v0LQWWlrSvBlY3uTQzq6FTDlvMrMs4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLI4PMwsi8PDzLJ0RHhI+r+S7kmPRyXdU9F3nqQBSZslzaton5/aBiSd257KzXrXxHYXABARfzr8XNJlwLPp+WxgITAHOBBYK+mQNPRy4ARgEFgvaVVEbGpp4WY9rCPCY5gkAX8CvCs1LQBWRMR24BFJA8Dc1DcQEVvScivSWIeHWYt0xGFLhWOApyLiofR6GvB4Rf9gaqvVvgtJiyT1S+ofGhpqQslmvallex6S1gL7l3SdHxE3pOenAtdXLlYyPigPvSh734hYBiwD6OvrKx1jZmPXsvCIiONH6pc0EXgv8JaK5kFgRsXr6cDW9LxWe0133nnnLyQ9VKP7taS5ljraq9uqX+8DbButngaoVXMjlx1t3Ej9HbNNiyPiuvTSNj105DJHEREd8QDmA7dWtc0B7gUmAzOBLcAEitDbktompTFz6niPZWPtK2uvbit53d+ibVbz52nUsqON8zbt3W3aSROmC9n5kIWI2ChpJcVE6A5gcUS8DCBpCbCGIkyWR8TGOt7j+xl9Ze3VbSOtt5nG8771LjvaOG/TsS+7W2xTpQSyBpLUHxF97a5jd+Jt2njj3aad9mnL7mJZuwvYDXmbNt64tqn3PMwsi/c8zCyLw8PMsjg8zCyLw8PMsjg8WkDSXpKukXSVpNPaXc/uQNLrJf2DpG+3u5bdhaQ/Tr+jN0g6cbTxDo9MkpZL+pmkDVXtZdcZeS/w7Yj4c+CUlhfbJcayTSNiS0Sc1Z5Ku8cYt+n30u/oh4A/LVndThwe+a6mOKX+NyRNoLjOyEnAbODUdE2S6bz6LeCXW1hjt7ma+rep1edqxr5NL0j9I3J4ZIqI24Cnq5rnkq4zEhEvAsPXGRmkCBDwNq9pjNvU6jCWbarCF4AfRMRdo63bv8iNVes6I98B3ifpStr3nY1uVbpNJf2upL8DjpR0XntK61q1fk8/BhwPvF/SR0ZbSSd9MW53UHr9kYj4JXBmq4vZTdTapj8HRv0Ft1K1tulXgK/UuxLveTTWSNcfsTzepo3XkG3q8Gis9cAsSTMlTaK4zMCqNtfU7bxNG68h29ThkUnS9cCPgUMlDUo6KyJ2AMPXGfkJsLLO64wY3qbN0Mxt6m/VmlkW73mYWRaHh5llcXiYWRaHh5llcXiYWRaHh5llcXiYWRaHh5llcXj0OElXS7qxletoxHuOsO4pkp6S9IZmrL/Ge35b0jmter9O4TNMO5ikq4Ez0suXKb68dBPwqYh4pkHv8VqK34P/qGPsOmBDRCzJXUfZ+FrrzSHpEmCfiDizqv0w4CLgOOA/A49R3N704oj41Tjf883ArcDMiMi9SXbX8Z5H51sLHAAcDPwZ8G7gikatPCKerfePvlHraMR7lpG0J8U2+oeq9j8E/g0IiktCHkZxtazTgX+StMd43jci7qe48frp41lP1xnPXbL9aO6D4hJyN1a1XQb8vOK1gL8GHgZ+BdwPnF61zDuA24HngWcp/pAOK3uPWmPTuKh6HFy9DuAvgKeAiVU1XAfcUDK+bL0XAj8HJlet41pg1Qjb6/1pOVW0TQAeAq4vGb8f8AzwmfR6HXBl2sZPA0PA2cBkisvy/Qfw78AHStZ1IfCjdv/OtPLhPY8uIun1FNejfKmi+fPAWcBiiutR/g3wNUn/NS0zEbgB+BHw+8DRwJcpuZbqKGPPpvh25tcp9oQOYOerUQ1bCexNcUWq4fXuRXHpwG+WjC9b72UUe8ULKtbxWuA9VO1VVDkGuDPSX3PyVuCNwBeqB0fEz4BrgFMrmk8DnqP42S8G/jfwPeBBoC+N/3tJB1at7g5g7nj3YrqJryTW+eZLep7i/6CvSW3nwG/+KM8BToyIf059j0iaSxEmNwG/Q/HH/P2IeDiNeaDGe404VtKLwAsR8dNaxUbEM5JWU/wR3pya3wPsoOQSjBHxbNl6JV0LfJgijAD+B/CL9DPVchDwZFXbzPTvgzWWeRD4aMXrjRHx6VTDl4BzgZci4sup7bPAJ4G3A5W3fdgK/BZwIMVe4G7P4dH5bgMWAXsAfw68gVcvFTebIlBullT5f9vfAh4FiIin08TrGkk/BH4IfCsidtlrGMvYUXwTuFrSnhHxAkWQfDsifj2GdVwF3CVpekQMUgTJNVFci6KWPSgOmSo9l/6dCrxQssxUilAadt/wk4gIST+jOBQcbntJ0jMUhzyVhidde2bPw4ctne+FiBiIiPsj4uPAnsD/Sn3D//3eDRxR8ZgD/OamPVF88nA0RRCdAjwoaV7Zm41l7AhupNjTWCBpP4pDmLJDlpoi4l7gLuBD6ZOSPmD5KIttA6ZUtf2Y4jDv3TWWeTfFYdqwl6r6o0Zb9d/O1PTv0Cg17jYcHt3nM8An0zH3JmA7cFAKmMrHY5ULRcS9EfGFiDiWYmLwjOoV1zH2RYrDpxFFxHaKXfrTKG4e9FOKjzJrqbXeqyhuQPRnwL9ExOZR3vpuir2xylp+TrGndkH1PIWkDwFvoZg3Gq/DgK0RUb3ns9tyeHSZiFgHbAQuiIjngEuBSyV9WNIbJR0h6SOSFgGk61ReLOntkg6SdBxwOEXw7KSOsY9STAoeLGkfSSP9/nwTmEdxhfPrIuKVEcbWWu/1wP4UcxIjTZQOWwP8nqTfrfiZfpsiPB6h+Fj2qNT+V8DXgPOBJ9KNkMbjGF6d4+kJDo/u9CXgLEkHURzCfBr4BEWo3AK8j+KPBYrj/EOAb1FMDl5D8ZHnLp8+1DH2Uoq9hE0Uu+evG6HG24AnKPYERjtkKV1vCseVqW9lzaWTKM63uIPigr7DPkFxQtgfpJ/t46n9S8Akik9UnmTnq4mPiaTXUEwKX5W7jm7kM0yto0n6ATAYxT1U6xk/n+Lj5dkR0ZJbe0paDCyIiFFvDr078act1pEkTaWYaD2R4pyTukTEzZIup7gXyWOjjW+QlyjuttZTvOdhHUnSoxSfYCyNiLJDLGszh4eZZfGEqZllcXiYWRaHh5llcXiYWRaHh5llcXiYWRaHh5ll+f/WwMFkMY/MMAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -239,9 +231,22 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "TypeError", + "evalue": "'module' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msurvey_skytem\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprob_skytem\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mget_skytem_survey_problem\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmesh1D\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm_true\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0msurvey_resolve\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprob_resolve\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mget_resolve_survey_problem\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmesh1D\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm_true\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m\u001b[0m in \u001b[0;36mget_skytem_survey_problem\u001b[1;34m(mesh1D, m_true)\u001b[0m\n\u001b[0;32m 31\u001b[0m \u001b[0mexpmap\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmaps\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mExpMap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmesh1D\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 32\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 33\u001b[1;33m \u001b[0msim\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mEM1D\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmesh1D\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msurvey\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mTDsurvey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msigmaMap\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mexpmap\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 34\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 35\u001b[0m \u001b[0mprob\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mchi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mTDsurvey\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn_layer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: 'module' object is not callable" + ] + } + ], "source": [ "survey_skytem, prob_skytem = get_skytem_survey_problem(mesh1D, m_true)\n", "survey_resolve, prob_resolve = get_resolve_survey_problem(mesh1D, m_true)" @@ -249,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -264,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 119, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -278,22 +283,9 @@ }, { "cell_type": "code", - "execution_count": 120, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = subplots(1,1, figsize = (6,4))\n", "axes.plot(survey_skytem.time, -survey_skytem.dobs[:survey_skytem.n_time], '-', lw=2)\n", @@ -308,22 +300,9 @@ }, { "cell_type": "code", - "execution_count": 121, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axes = subplots(1,1, figsize = (6,4))\n", "axes.plot(survey_resolve.frequency, survey_resolve.dobs[:survey_resolve.n_frequency], '-', lw=2)\n", @@ -338,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -347,27 +326,16 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "312.6502800164722" - ] - }, - "execution_count": 123, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "doi_skytem" ] }, { "cell_type": "code", - "execution_count": 99, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -376,20 +344,9 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "79.94504332369223" - ] - }, - "execution_count": 100, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "doi_resolve" ] @@ -420,7 +377,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/notebooks/examples/resistivity.png b/notebooks/examples/resistivity.png new file mode 100644 index 0000000..6bfa589 Binary files /dev/null and b/notebooks/examples/resistivity.png differ diff --git a/simpegEM1D/.libs/libm_rTE_Fo.GJJ4AYK2AYSJ7CBWPHQAFWIN6WGRAIYI.gfortran-win_amd64.dll b/simpegEM1D/.libs/libm_rTE_Fo.GJJ4AYK2AYSJ7CBWPHQAFWIN6WGRAIYI.gfortran-win_amd64.dll new file mode 100644 index 0000000..d9dd09b Binary files /dev/null and b/simpegEM1D/.libs/libm_rTE_Fo.GJJ4AYK2AYSJ7CBWPHQAFWIN6WGRAIYI.gfortran-win_amd64.dll differ diff --git a/simpegEM1D/.libs/libm_rTE_Fo.SCBVWIJUD5OFZKEAKP4Z75X5N7TGU6NN.gfortran-win_amd64.dll b/simpegEM1D/.libs/libm_rTE_Fo.SCBVWIJUD5OFZKEAKP4Z75X5N7TGU6NN.gfortran-win_amd64.dll new file mode 100644 index 0000000..1b5b93e Binary files /dev/null and b/simpegEM1D/.libs/libm_rTE_Fo.SCBVWIJUD5OFZKEAKP4Z75X5N7TGU6NN.gfortran-win_amd64.dll differ diff --git a/simpegEM1D/EM1D.py b/simpegEM1D/EM1D.py deleted file mode 100644 index 026d6fe..0000000 --- a/simpegEM1D/EM1D.py +++ /dev/null @@ -1,604 +0,0 @@ -from SimPEG import Maps, Utils, Problem, Props -import numpy as np -from .Survey import BaseEM1DSurvey -from scipy.constants import mu_0 -from .RTEfun_vec import rTEfunfwd, rTEfunjac -from scipy.interpolate import InterpolatedUnivariateSpline as iuSpline - -from empymod import filters -from empymod.transform import dlf, get_dlf_points -from empymod.utils import check_hankel - -try: - from simpegEM1D.m_rTE_Fortran import rte_fortran -except ImportError as e: - rte_fortran = None - - -class EM1D(Problem.BaseProblem): - """ - Pseudo analytic solutions for frequency and time domain EM problems - assumingLayered earth (1D). - """ - surveyPair = BaseEM1DSurvey - mapPair = Maps.IdentityMap - chi = None - hankel_filter = 'key_101_2009' # Default: Hankel filter - hankel_pts_per_dec = None # Default: Standard DLF - verbose = False - fix_Jmatrix = False - _Jmatrix_sigma = None - _Jmatrix_height = None - _pred = None - - sigma, sigmaMap, sigmaDeriv = Props.Invertible( - "Electrical conductivity at infinite frequency(S/m)" - ) - - chi = Props.PhysicalProperty( - "Magnetic susceptibility", - default=0. - ) - - eta, etaMap, etaDeriv = Props.Invertible( - "Electrical chargeability (V/V), 0 <= eta < 1", - default=0. - ) - - tau, tauMap, tauDeriv = Props.Invertible( - "Time constant (s)", - default=1. - ) - - c, cMap, cDeriv = Props.Invertible( - "Frequency Dependency, 0 < c < 1", - default=0.5 - ) - - h, hMap, hDeriv = Props.Invertible( - "Receiver Height (m), h > 0", - ) - - def __init__(self, mesh, **kwargs): - Problem.BaseProblem.__init__(self, mesh, **kwargs) - - # Check input arguments. If self.hankel_filter is not a valid filter, - # it will set it to the default (key_201_2009). - - ht, htarg = check_hankel( - 'dlf', - { - 'dlf': self.hankel_filter, - 'pts_per_dec': 0 - }, - 1 - ) - - self.fhtfilt = htarg['dlf'] # Store filter - self.hankel_pts_per_dec = htarg['pts_per_dec'] # Store pts_per_dec - if self.verbose: - print(">> Use "+self.hankel_filter+" filter for Hankel Transform") - - # if self.hankel_pts_per_dec != 0: - # raise NotImplementedError() - - def hz_kernel_vertical_magnetic_dipole( - self, lamda, f, n_layer, sig, chi, depth, h, z, - flag, I, output_type='response' - ): - - """ - Kernel for vertical magnetic component (Hz) due to - vertical magnetic diopole (VMD) source in (kx,ky) domain - - """ - u0 = lamda - coefficient_wavenumber = 1/(4*np.pi)*lamda**3/u0 - - n_frequency = self.survey.n_frequency - n_layer = self.survey.n_layer - n_filter = self.n_filter - - if output_type == 'sensitivity_sigma': - drTE = np.zeros( - [n_layer, n_frequency, n_filter], - dtype=np.complex128, order='F' - ) - if rte_fortran is None: - drTE = rTEfunjac( - n_layer, f, lamda, sig, chi, depth, self.survey.half_switch - ) - else: - rte_fortran.rte_sensitivity( - f, lamda, sig, chi, depth, self.survey.half_switch, drTE, - n_layer, n_frequency, n_filter - ) - - kernel = drTE * np.exp(-u0*(z+h)) * coefficient_wavenumber - else: - rTE = np.empty( - [n_frequency, n_filter], dtype=np.complex128, order='F' - ) - if rte_fortran is None: - rTE = rTEfunfwd( - n_layer, f, lamda, sig, chi, depth, - self.survey.half_switch - ) - else: - rte_fortran.rte_forward( - f, lamda, sig, chi, depth, self.survey.half_switch, - rTE, n_layer, n_frequency, n_filter - ) - - kernel = rTE * np.exp(-u0*(z+h)) * coefficient_wavenumber - if output_type == 'sensitivity_height': - kernel *= -2*u0 - - return kernel * I - - # Note - # Here only computes secondary field. - # I am not sure why it does not work if we add primary term. - # This term can be analytically evaluated, where h = 0. - # kernel = ( - # 1./(4*np.pi) * - # (np.exp(u0*(z-h))+rTE * np.exp(-u0*(z+h)))*lamda**3/u0 - # ) - - # TODO: make this to take a vector rather than a single frequency - def hz_kernel_circular_loop( - self, lamda, f, n_layer, sig, chi, depth, h, z, I, a, - flag, output_type='response' - ): - - """ - - Kernel for vertical magnetic component (Hz) at the center - due to circular loop source in (kx,ky) domain - - .. math:: - - H_z = \\frac{Ia}{2} \int_0^{\infty} [e^{-u_0|z+h|} + - \\r_{TE}e^{u_0|z-h|}] - \\frac{\lambda^2}{u_0} J_1(\lambda a)] d \lambda - - """ - - n_frequency = self.survey.n_frequency - n_layer = self.survey.n_layer - n_filter = self.n_filter - - w = 2*np.pi*f - u0 = lamda - radius = np.empty([n_frequency, n_filter], order='F') - radius[:, :] = np.tile(a.reshape([-1, 1]), (1, n_filter)) - - coefficient_wavenumber = I*radius*0.5*lamda**2/u0 - - if output_type == 'sensitivity_sigma': - drTE = np.empty( - [n_layer, n_frequency, n_filter], - dtype=np.complex128, order='F' - ) - if rte_fortran is None: - drTE[:, :] = rTEfunjac( - n_layer, f, lamda, sig, chi, depth, - self.survey.half_switch - ) - else: - rte_fortran.rte_sensitivity( - f, lamda, sig, chi, depth, self.survey.half_switch, - drTE, n_layer, n_frequency, n_filter - ) - - kernel = drTE * np.exp(-u0*(z+h)) * coefficient_wavenumber - else: - rTE = np.empty( - [n_frequency, n_filter], dtype=np.complex128, order='F' - ) - if rte_fortran is None: - rTE[:, :] = rTEfunfwd( - n_layer, f, lamda, sig, chi, depth, self.survey.half_switch - ) - else: - rte_fortran.rte_forward( - f, lamda, sig, chi, depth, self.survey.half_switch, - rTE, n_layer, n_frequency, n_filter - ) - - if flag == 'secondary': - kernel = rTE * np.exp(-u0*(z+h)) * coefficient_wavenumber - else: - kernel = rTE * ( - np.exp(-u0*(z+h)) + np.exp(u0*(z-h)) - ) * coefficient_wavenumber - - if output_type == 'sensitivity_height': - kernel *= -2*u0 - - return kernel - - def hz_kernel_horizontal_electric_dipole( - self, lamda, f, n_layer, sig, chi, depth, h, z, - flag, output_type='response' - ): - - """ - Kernel for vertical magnetic field (Hz) due to - horizontal electric diopole (HED) source in (kx,ky) domain - - """ - n_frequency = self.survey.n_frequency - n_layer = self.survey.n_layer - n_filter = self.n_filter - - u0 = lamda - coefficient_wavenumber = 1/(4*np.pi)*lamda**2/u0 - - if output_type == 'sensitivity_sigma': - drTE = np.zeros( - [n_layer, n_frequency, n_filter], dtype=np.complex128, - order='F' - ) - if rte_fortran is None: - drTE = rTEfunjac( - n_layer, f, lamda, sig, chi, depth, self.survey.half_switch - ) - else: - rte_fortran.rte_sensitivity( - f, lamda, sig, chi, depth, self.survey.half_switch, - drTE, n_layer, n_frequency, n_filter - ) - - kernel = drTE * np.exp(-u0*(z+h)) * coefficient_wavenumber - else: - rTE = np.empty( - [n_frequency, n_filter], dtype=np.complex128, order='F' - ) - if rte_fortran is None: - rTE = rTEfunfwd( - n_layer, f, lamda, sig, chi, depth, - self.survey.half_switch - ) - else: - rte_fortran.rte_forward( - f, lamda, sig, chi, depth, self.survey.half_switch, - rTE, n_layer, n_frequency, n_filter - ) - - kernel = rTE * np.exp(-u0*(z+h)) * coefficient_wavenumber - if output_type == 'sensitivity_height': - kernel *= -2*u0 - - return kernel - - # make it as a property? - - def sigma_cole(self): - """ - Computes Pelton's Cole-Cole conductivity model - in frequency domain. - - Parameter - --------- - - n_filter: int - the number of filter values - f: ndarray - frequency (Hz) - - Return - ------ - - sigma_complex: ndarray (n_layer x n_frequency x n_filter) - Cole-Cole conductivity values at given frequencies - - """ - n_layer = self.survey.n_layer - n_frequency = self.survey.n_frequency - n_filter = self.n_filter - f = self.survey.frequency - - sigma = np.tile(self.sigma.reshape([-1, 1]), (1, n_frequency)) - if np.isscalar(self.eta): - eta = self.eta - tau = self.tau - c = self.c - else: - eta = np.tile(self.eta.reshape([-1, 1]), (1, n_frequency)) - tau = np.tile(self.tau.reshape([-1, 1]), (1, n_frequency)) - c = np.tile(self.c.reshape([-1, 1]), (1, n_frequency)) - - w = np.tile( - 2*np.pi*f, - (n_layer, 1) - ) - - sigma_complex = np.empty( - [n_layer, n_frequency], dtype=np.complex128, order='F' - ) - sigma_complex[:, :] = ( - sigma - - sigma*eta/(1+(1-eta)*(1j*w*tau)**c) - ) - - sigma_complex_tensor = np.empty( - [n_layer, n_frequency, n_filter], dtype=np.complex128, order='F' - ) - sigma_complex_tensor[:, :, :] = np.tile(sigma_complex.reshape( - (n_layer, n_frequency, 1)), (1, 1, n_filter) - ) - - return sigma_complex_tensor - - @property - def n_filter(self): - """ Length of filter """ - return self.fhtfilt.base.size - - def forward(self, m, output_type='response'): - """ - Return Bz or dBzdt - """ - - self.model = m - - n_frequency = self.survey.n_frequency - flag = self.survey.field_type - n_layer = self.survey.n_layer - depth = self.survey.depth - I = self.survey.I - n_filter = self.n_filter - - # Get lambd and offset, will depend on pts_per_dec - if self.survey.src_type == "VMD": - r = self.survey.offset - else: - # a is the radius of the loop - r = self.survey.a * np.ones(n_frequency) - - # Use function from empymod - # size of lambd is (n_frequency x n_filter) - lambd = np.empty([self.survey.frequency.size, n_filter], order='F') - lambd[:, :], _ = get_dlf_points( - self.fhtfilt, r, self.hankel_pts_per_dec - ) - - # TODO: potentially store - f = np.empty([self.survey.frequency.size, n_filter], order='F') - f[:, :] = np.tile( - self.survey.frequency.reshape([-1, 1]), (1, n_filter) - ) - # h is an inversion parameter - if self.hMap is not None: - h = self.h - else: - h = self.survey.h - - z = h + self.survey.dz - - chi = self.chi - - if np.isscalar(self.chi): - chi = np.ones_like(self.sigma) * self.chi - - # TODO: potentially store - sig = self.sigma_cole() - - if output_type == 'response': - # for simulation - if self.survey.src_type == 'VMD': - hz = self.hz_kernel_vertical_magnetic_dipole( - lambd, f, n_layer, - sig, chi, depth, h, z, - flag, I, output_type=output_type - ) - - # kernels for each bessel function - # (j0, j1, j2) - PJ = (hz, None, None) # PJ0 - - elif self.survey.src_type == 'CircularLoop': - hz = self.hz_kernel_circular_loop( - lambd, f, n_layer, - sig, chi, depth, h, z, I, r, - flag, output_type=output_type - ) - - # kernels for each bessel function - # (j0, j1, j2) - PJ = (None, hz, None) # PJ1 - - # TODO: This has not implemented yet! - elif self.survey.src_type == "piecewise_line": - # Need to compute y - hz = self.hz_kernel_horizontal_electric_dipole( - lambd, f, n_layer, - sig, chi, depth, h, z, I, r, - flag, output_type=output_type - ) - # kernels for each bessel function - # (j0, j1, j2) - PJ = (None, hz, None) # PJ1 - - else: - raise Exception("Src options are only VMD or CircularLoop!!") - - elif output_type == 'sensitivity_sigma': - - # for simulation - if self.survey.src_type == 'VMD': - hz = self.hz_kernel_vertical_magnetic_dipole( - lambd, f, n_layer, - sig, chi, depth, h, z, - flag, I, output_type=output_type - ) - - PJ = (hz, None, None) # PJ0 - - elif self.survey.src_type == 'CircularLoop': - - hz = self.hz_kernel_circular_loop( - lambd, f, n_layer, - sig, chi, depth, h, z, I, r, - flag, output_type=output_type - ) - - PJ = (None, hz, None) # PJ1 - - else: - raise Exception("Src options are only VMD or CircularLoop!!") - - r = np.tile(r, (n_layer, 1)) - - elif output_type == 'sensitivity_height': - - # for simulation - if self.survey.src_type == 'VMD': - hz = self.hz_kernel_vertical_magnetic_dipole( - lambd, f, n_layer, - sig, chi, depth, h, z, - flag, I, output_type=output_type - ) - - PJ = (hz, None, None) # PJ0 - - elif self.survey.src_type == 'CircularLoop': - - hz = self.hz_kernel_circular_loop( - lambd, f, n_layer, - sig, chi, depth, h, z, I, r, - flag, output_type=output_type - ) - - PJ = (None, hz, None) # PJ1 - - else: - raise Exception("Src options are only VMD or CircularLoop!!") - - # Carry out Hankel DLF - # ab=66 => 33 (vertical magnetic src and rec) - # For response - # HzFHT size = (n_frequency,) - # For sensitivity - # HzFHT size = (n_layer, n_frequency) - - HzFHT = dlf(PJ, lambd, r, self.fhtfilt, self.hankel_pts_per_dec, - ang_fact=None, ab=33) - - if output_type == "sensitivity_sigma": - return HzFHT.T - - return HzFHT - - # @profile - def fields(self, m): - f = self.forward(m, output_type='response') - self.survey._pred = Utils.mkvc(self.survey.projectFields(f)) - return f - - def getJ_height(self, m, f=None): - """ - - """ - if self.hMap is None: - return Utils.Zero() - - if self._Jmatrix_height is not None: - return self._Jmatrix_height - else: - - if self.verbose: - print(">> Compute J height ") - - dudz = self.forward(m, output_type="sensitivity_height") - - self._Jmatrix_height = ( - self.survey.projectFields(dudz) - ).reshape([-1, 1]) - - return self._Jmatrix_height - - # @profile - def getJ_sigma(self, m, f=None): - - if self.sigmaMap is None: - return Utils.Zero() - - if self._Jmatrix_sigma is not None: - return self._Jmatrix_sigma - else: - - if self.verbose: - print(">> Compute J sigma") - - dudsig = self.forward(m, output_type="sensitivity_sigma") - - self._Jmatrix_sigma = self.survey.projectFields(dudsig) - if self._Jmatrix_sigma.ndim == 1: - self._Jmatrix_sigma = self._Jmatrix_sigma.reshape([-1, 1]) - return self._Jmatrix_sigma - - def getJ(self, m, f=None): - return ( - self.getJ_sigma(m, f=f) * self.sigmaDeriv + - self.getJ_height(m, f=f) * self.hDeriv - ) - - def Jvec(self, m, v, f=None): - """ - Computing Jacobian^T multiplied by vector. - """ - - J_sigma = self.getJ_sigma(m, f=f) - J_height = self.getJ_height(m, f=f) - Jv = np.dot(J_sigma, self.sigmaMap.deriv(m, v)) - if self.hMap is not None: - Jv += np.dot(J_height, self.hMap.deriv(m, v)) - return Jv - - def Jtvec(self, m, v, f=None): - """ - Computing Jacobian^T multiplied by vector. - """ - - J_sigma = self.getJ_sigma(m, f=f) - J_height = self.getJ_height(m, f=f) - Jtv = self.sigmaDeriv.T*np.dot(J_sigma.T, v) - if self.hMap is not None: - Jtv += self.hDeriv.T*np.dot(J_height.T, v) - return Jtv - - @property - def deleteTheseOnModelUpdate(self): - toDelete = [] - if self.fix_Jmatrix is False: - if self._Jmatrix_sigma is not None: - toDelete += ['_Jmatrix_sigma'] - if self._Jmatrix_height is not None: - toDelete += ['_Jmatrix_height'] - return toDelete - - def depth_of_investigation_christiansen_2012(self, std, thres_hold=0.8): - pred = self.survey._pred.copy() - delta_d = std * np.log(abs(self.survey.dobs)) - J = self.getJ(self.model) - J_sum = abs(Utils.sdiag(1/delta_d/pred) * J).sum(axis=0) - S = np.cumsum(J_sum[::-1])[::-1] - active = S-thres_hold > 0. - doi = abs(self.survey.depth[active]).max() - return doi, active - - def get_threshold(self, uncert): - _, active = self.depth_of_investigation(uncert) - JtJdiag = self.get_JtJdiag(uncert) - delta = JtJdiag[active].min() - return delta - - def get_JtJdiag(self, uncert): - J = self.getJ(self.model) - JtJdiag = (np.power((Utils.sdiag(1./uncert)*J), 2)).sum(axis=0) - return JtJdiag - -if __name__ == '__main__': - main() diff --git a/simpegEM1D/EM1DSimulation.py b/simpegEM1D/EM1DSimulation.py deleted file mode 100644 index 981beaa..0000000 --- a/simpegEM1D/EM1DSimulation.py +++ /dev/null @@ -1,223 +0,0 @@ -import numpy as np -from SimPEG import Mesh, Maps, Utils -from .EM1DAnalytics import skin_depth, diffusion_distance -from .EM1D import EM1D -from .Survey import EM1DSurveyFD, EM1DSurveyTD - - -def get_vertical_discretization_frequency( - frequency, sigma_background=0.01, - factor_fmax=4, factor_fmin=1., n_layer=19, - hz_min=None, z_max=None -): - if hz_min is None: - hz_min = skin_depth(frequency.max(), sigma_background) / factor_fmax - if z_max is None: - z_max = skin_depth(frequency.min(), sigma_background) * factor_fmin - i = 4 - hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) - z_sum = hz.sum() - - while z_sum < z_max: - i += 1 - hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) - z_sum = hz.sum() - return hz - - -def get_vertical_discretization_time( - time, sigma_background=0.01, - factor_tmin=4, facter_tmax=1., n_layer=19, - hz_min=None, z_max=None -): - if hz_min is None: - hz_min = diffusion_distance(time.min(), sigma_background) / factor_tmin - if z_max is None: - z_max = diffusion_distance(time.max(), sigma_background) * facter_tmax - i = 4 - hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) - z_sum = hz.sum() - while z_sum < z_max: - i += 1 - hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) - z_sum = hz.sum() - return hz - - -def set_mesh_1d(hz): - return Mesh.TensorMesh([hz], x0=[0]) - - -def run_simulation_FD(args): - """ - args - - rx_location: Recevier location (x, y, z) - src_location: Source location (x, y, z) - topo: Topographic location (x, y, z) - hz: Thickeness of the vertical layers - offset: Source-Receiver offset - frequency: Frequency (Hz) - field_type: - rx_type: - src_type: - sigma: - jac_switch : - """ - - rx_location, src_location, topo, hz, offset, frequency, field_type, rx_type, src_type, sigma, eta, tau, c, chi, h, jac_switch, invert_height, half_switch = args - mesh_1d = set_mesh_1d(hz) - depth = -mesh_1d.gridN[:-1] - FDsurvey = EM1DSurveyFD( - rx_location=rx_location, - src_location=src_location, - topo=topo, - frequency=frequency, - offset=offset, - field_type=field_type, - rx_type=rx_type, - src_type=src_type, - depth=depth, - half_switch=half_switch - ) - if not invert_height: - # Use Exponential Map - # This is hard-wired at the moment - expmap = Maps.ExpMap(mesh_1d) - prob = EM1D( - mesh_1d, sigmaMap=expmap, chi=chi, hankel_filter='key_101_2009', - eta=eta, tau=tau, c=c - ) - if prob.ispaired: - prob.unpair() - if FDsurvey.ispaired: - FDsurvey.unpair() - prob.pair(FDsurvey) - if jac_switch == 'sensitivity_sigma': - drespdsig = prob.getJ_sigma(np.log(sigma)) - return Utils.mkvc(drespdsig * prob.sigmaDeriv) - # return Utils.mkvc(drespdsig) - else: - resp = FDsurvey.dpred(np.log(sigma)) - return resp - else: - wires = Maps.Wires(('sigma', mesh_1d.nC), ('h', 1)) - expmap = Maps.ExpMap(mesh_1d) - sigmaMap = expmap * wires.sigma - prob = EM1D( - mesh_1d, sigmaMap=sigmaMap, hMap=wires.h, chi=chi, hankel_filter='key_101_2009', - eta=eta, tau=tau, c=c - ) - if prob.ispaired: - prob.unpair() - if FDsurvey.ispaired: - FDsurvey.unpair() - prob.pair(FDsurvey) - m = np.r_[np.log(sigma), h] - if jac_switch == 'sensitivity_sigma': - drespdsig = prob.getJ_sigma(m) - return Utils.mkvc(drespdsig * Utils.sdiag(sigma)) - # return Utils.mkvc(drespdsig) - elif jac_switch == 'sensitivity_height': - drespdh = prob.getJ_height(m) - return Utils.mkvc(drespdh) - else: - resp = FDsurvey.dpred(m) - return resp - - -def run_simulation_TD(args): - """ - args - - rx_location: Recevier location (x, y, z) - src_location: Source location (x, y, z) - topo: Topographic location (x, y, z) - hz: Thickeness of the vertical layers - time: Time (s) - field_type: 'secondary' - rx_type: - src_type: - wave_type: - offset: Source-Receiver offset (for VMD) - a: Source-loop radius (for Circular Loop) - time_input_currents: - input_currents: - n_pulse: - base_frequency: - sigma: - jac_switch: - """ - - rx_location, src_location, topo, hz, time, field_type, rx_type, src_type, wave_type, offset, a, time_input_currents, input_currents, n_pulse, base_frequency, use_lowpass_filter, high_cut_frequency, moment_type, time_dual_moment, time_input_currents_dual_moment, input_currents_dual_moment, base_frequency_dual_moment, sigma, eta, tau, c, h, jac_switch, invert_height, half_switch = args - - mesh_1d = set_mesh_1d(hz) - depth = -mesh_1d.gridN[:-1] - TDsurvey = EM1DSurveyTD( - rx_location=rx_location, - src_location=src_location, - topo=topo, - depth=depth, - time=time, - field_type=field_type, - rx_type=rx_type, - src_type=src_type, - wave_type=wave_type, - offset=offset, - a=a, - time_input_currents=time_input_currents, - input_currents=input_currents, - n_pulse=n_pulse, - base_frequency=base_frequency, - high_cut_frequency=high_cut_frequency, - moment_type=moment_type, - time_dual_moment=time_dual_moment, - time_input_currents_dual_moment=time_input_currents_dual_moment, - input_currents_dual_moment=input_currents_dual_moment, - base_frequency_dual_moment=base_frequency_dual_moment, - half_switch=half_switch, - ) - if not invert_height: - # Use Exponential Map - # This is hard-wired at the moment - expmap = Maps.ExpMap(mesh_1d) - prob = EM1D( - mesh_1d, sigmaMap=expmap, hankel_filter='key_101_2009', - eta=eta, tau=tau, c=c - ) - if prob.ispaired: - prob.unpair() - if TDsurvey.ispaired: - TDsurvey.unpair() - prob.pair(TDsurvey) - if jac_switch == 'sensitivity_sigma': - drespdsig = prob.getJ_sigma(np.log(sigma)) - return Utils.mkvc(drespdsig * prob.sigmaDeriv) - else: - resp = TDsurvey.dpred(np.log(sigma)) - return resp - else: - wires = Maps.Wires(('sigma', mesh_1d.nC), ('h', 1)) - expmap = Maps.ExpMap(mesh_1d) - sigmaMap = expmap * wires.sigma - prob = EM1D( - mesh_1d, sigmaMap=sigmaMap, hMap=wires.h, - hankel_filter='key_101_2009', - eta=eta, tau=tau, c=c - ) - if prob.ispaired: - prob.unpair() - if TDsurvey.ispaired: - TDsurvey.unpair() - prob.pair(TDsurvey) - m = np.r_[np.log(sigma), h] - if jac_switch == 'sensitivity_sigma': - drespdsig = prob.getJ_sigma(m) - return Utils.mkvc(drespdsig * Utils.sdiag(sigma)) - elif jac_switch == 'sensitivity_height': - drespdh = prob.getJ_height(m) - return Utils.mkvc(drespdh) - else: - resp = TDsurvey.dpred(m) - return resp - diff --git a/simpegEM1D/Fortran/m_rTE_Fortran.f90 b/simpegEM1D/Fortran/m_rTE_Fortran.f90 index a77c08e..363e2e5 100644 --- a/simpegEM1D/Fortran/m_rTE_Fortran.f90 +++ b/simpegEM1D/Fortran/m_rTE_Fortran.f90 @@ -27,7 +27,7 @@ subroutine rTE_forward(nLayers, nFrequencies, nFilter, frequencies, lambda, sig, !f2py intent(in) :: lambda complex(kind=8), intent(in) :: sig(nLayers, nFrequencies, nFilter) !f2py intent(in) :: sig - real(kind=8), intent(in) :: chi(nLayers) + complex(kind=8), intent(in) :: chi(nLayers, nFrequencies, nFilter) !f2py intent(in) :: chi real(kind=8), intent(in) :: depth(nLayers) !f2py intent(in) :: depth @@ -47,15 +47,15 @@ subroutine rTE_forward(nLayers, nFrequencies, nFilter, frequencies, lambda, sig, real(kind=8) :: tmp0 complex(kind=8) :: uTmp0, uTmp1, cTmp real(kind=8) :: thickness(nLayers - 1) - complex(kind=8) :: c1(nLayers) + complex(kind=8) :: c1(nLayers, nFrequencies, nFilter) if (halfSpace .or. nLayers == 1) then - cTmp = mu0 * (1.d0 + chi(1)) do jj = 1, nFilter do i = 1, nFrequencies omega = pi2 * frequencies(i, jj) uTmp0 = lambda(i, jj) + cTmp = mu0 * (1.d0 + chi(1, i, jj)) uTmp1 = sqrt(uTmp0**2.d0 + j * omega * cTmp * sig(1, i, jj)) c = mu0 * uTmp1 / (cTmp * uTmp0) @@ -72,9 +72,15 @@ subroutine rTE_forward(nLayers, nFrequencies, nFilter, frequencies, lambda, sig, do k = 1, nLayers - 1 thickness(k) = -(depth(k+1) - depth(k)) - c1(k) = 1.d0 + chi(k) enddo - c1(nLayers) = 1.d0 + chi(nLayers) + + do k = 1, nLayers + do jj = 1, nFilter + do i = 1, nFrequencies + c1(k, i, jj) = 1.d0 + chi(k, i, jj) + enddo + enddo + enddo do jj = 1, nFilter do i = 1, nFrequencies @@ -83,8 +89,8 @@ subroutine rTE_forward(nLayers, nFrequencies, nFilter, frequencies, lambda, sig, lam2 = lambda(i, jj)**2.d0 ! Set up first layer - uTmp1 = sqrt(lam2 + j * tmp0 * c1(1) * sig(1, i, jj)) - c = uTmp1 / (c1(1) * lambda(i, jj)) + uTmp1 = sqrt(lam2 + j * tmp0 * c1(1, i, jj) * sig(1, i, jj)) + c = uTmp1 / (c1(1, i, jj) * lambda(i, jj)) s0 = 0.5d0 * (1.d0 + c) s1 = 0.5d0 * (1.d0 - c) @@ -93,9 +99,9 @@ subroutine rTE_forward(nLayers, nFrequencies, nFilter, frequencies, lambda, sig, do k = 1, nLayers - 1 cTmp = j * tmp0 - uTmp0 = sqrt(lam2 + cTmp * c1(k) * sig(k, i, jj)) - uTmp1 = sqrt(lam2 + cTmp * c1(k + 1) * sig(k+1, i, jj)) - c = (c1(k) * uTmp1) / (c1(k + 1) * uTmp0) + uTmp0 = sqrt(lam2 + cTmp * c1(k, i, jj) * sig(k, i, jj)) + uTmp1 = sqrt(lam2 + cTmp * c1(k + 1, i, jj) * sig(k+1, i, jj)) + c = (c1(k, i, jj) * uTmp1) / (c1(k + 1, i, jj) * uTmp0) h = thickness(k) diff --git a/simpegEM1D/GlobalEM1D.py b/simpegEM1D/GlobalEM1D.py deleted file mode 100644 index 37dbc47..0000000 --- a/simpegEM1D/GlobalEM1D.py +++ /dev/null @@ -1,966 +0,0 @@ -try: - from multiprocessing import Pool -except ImportError: - print("multiprocessing is not available") - PARALLEL = False -else: - PARALLEL = True - import multiprocessing - -import numpy as np -import scipy.sparse as sp -from SimPEG import Problem, Props, Utils, Maps, Survey -from .Survey import EM1DSurveyFD, EM1DSurveyTD -from .EM1DSimulation import run_simulation_FD, run_simulation_TD -import properties -import warnings - - -def dot(args): - return np.dot(args[0], args[1]) - - -class GlobalEM1DProblem(Problem.BaseProblem): - """ - The GlobalProblem allows you to run a whole bunch of SubProblems, - potentially in parallel, potentially of different meshes. - This is handy for working with lots of sources, - """ - sigma, sigmaMap, sigmaDeriv = Props.Invertible( - "Electrical conductivity (S/m)" - ) - - h, hMap, hDeriv = Props.Invertible( - "Receiver Height (m), h > 0", - ) - - chi = Props.PhysicalProperty( - "Magnetic susceptibility (H/m)", - ) - - eta = Props.PhysicalProperty( - "Electrical chargeability (V/V), 0 <= eta < 1" - ) - - tau = Props.PhysicalProperty( - "Time constant (s)" - ) - - c = Props.PhysicalProperty( - "Frequency Dependency, 0 < c < 1" - ) - - _Jmatrix_sigma = None - _Jmatrix_height = None - run_simulation = None - n_cpu = None - hz = None - parallel = False - parallel_jvec_jtvec = False - verbose = False - fix_Jmatrix = False - invert_height = None - - def __init__(self, mesh, **kwargs): - Utils.setKwargs(self, **kwargs) - self.mesh = mesh - if PARALLEL: - if self.parallel: - print(">> Use multiprocessing for parallelization") - if self.n_cpu is None: - self.n_cpu = multiprocessing.cpu_count() - print((">> n_cpu: %i") % (self.n_cpu)) - else: - print(">> Serial version is used") - else: - print(">> Serial version is used") - if self.hz is None: - raise Exception("Input vertical thickness hz !") - if self.hMap is None: - self.invert_height = False - else: - self.invert_height = True - - # ------------- For survey ------------- # - @property - def n_layer(self): - return self.hz.size - - @property - def n_sounding(self): - return self.survey.n_sounding - - @property - def rx_locations(self): - return self.survey.rx_locations - - @property - def src_locations(self): - return self.survey.src_locations - - @property - def data_index(self): - return self.survey.data_index - - @property - def topo(self): - return self.survey.topo - - @property - def offset(self): - return self.survey.offset - - @property - def a(self): - return self.survey.a - - @property - def I(self): - return self.survey.I - - @property - def field_type(self): - return self.survey.field_type - - @property - def rx_type(self): - return self.survey.rx_type - - @property - def src_type(self): - return self.survey.src_type - - @property - def half_switch(self): - return self.survey.half_switch - - # ------------- For physical properties ------------- # - @property - def Sigma(self): - if getattr(self, '_Sigma', None) is None: - # Ordering: first z then x - self._Sigma = self.sigma.reshape((self.n_sounding, self.n_layer)) - return self._Sigma - - @property - def Chi(self): - if getattr(self, '_Chi', None) is None: - # Ordering: first z then x - if self.chi is None: - self._Chi = np.zeros( - (self.n_sounding, self.n_layer), dtype=float, order='C' - ) - else: - self._Chi = self.chi.reshape((self.n_sounding, self.n_layer)) - return self._Chi - - @property - def Eta(self): - if getattr(self, '_Eta', None) is None: - # Ordering: first z then x - if self.eta is None: - self._Eta = np.zeros( - (self.n_sounding, self.n_layer), dtype=float, order='C' - ) - else: - self._Eta = self.eta.reshape((self.n_sounding, self.n_layer)) - return self._Eta - - @property - def Tau(self): - if getattr(self, '_Tau', None) is None: - # Ordering: first z then x - if self.tau is None: - self._Tau = 1e-3*np.ones( - (self.n_sounding, self.n_layer), dtype=float, order='C' - ) - else: - self._Tau = self.tau.reshape((self.n_sounding, self.n_layer)) - return self._Tau - - @property - def C(self): - if getattr(self, '_C', None) is None: - # Ordering: first z then x - if self.c is None: - self._C = np.ones( - (self.n_sounding, self.n_layer), dtype=float, order='C' - ) - else: - self._C = self.c.reshape((self.n_sounding, self.n_layer)) - return self._C - - @property - def JtJ_sigma(self): - return self._JtJ_sigma - - def JtJ_height(self): - return self._JtJ_height - - @property - def H(self): - if self.hMap is None: - return np.ones(self.n_sounding) - else: - return self.h - - @property - def Sigma(self): - if getattr(self, '_Sigma', None) is None: - # Ordering: first z then x - self._Sigma = self.sigma.reshape((self.n_sounding, self.n_layer)) - return self._Sigma - - # ------------- Etcetra .... ------------- # - @property - def IJLayers(self): - if getattr(self, '_IJLayers', None) is None: - # Ordering: first z then x - self._IJLayers = self.survey.set_ij_n_layer() - return self._IJLayers - - @property - def IJHeight(self): - if getattr(self, '_IJHeight', None) is None: - # Ordering: first z then x - self._IJHeight = self.survey.set_ij_n_layer(n_layer=1) - return self._IJHeight - - # ------------- For physics ------------- # - def fields(self, m): - if self.verbose: - print("Compute fields") - self.survey._pred = self.forward(m) - return [] - - def forward(self, m): - self.model = m - - if self.verbose: - print(">> Compute response") - - if self.survey.__class__ == GlobalEM1DSurveyFD: - run_simulation = run_simulation_FD - else: - run_simulation = run_simulation_TD - - if self.parallel: - pool = Pool(self.n_cpu) - # This assumes the same # of layer for each of soundings - result = pool.map( - run_simulation, - [ - self.input_args(i, jac_switch='forward') for i in range(self.n_sounding) - ] - ) - pool.close() - pool.join() - else: - result = [ - run_simulation(self.input_args(i, jac_switch='forward')) for i in range(self.n_sounding) - ] - return np.hstack(result) - - def getJ_sigma(self, m): - """ - Compute d F / d sigma - """ - if self._Jmatrix_sigma is not None: - return self._Jmatrix_sigma - if self.verbose: - print(">> Compute J sigma") - self.model = m - - if self.survey.__class__ == GlobalEM1DSurveyFD: - run_simulation = run_simulation_FD - else: - run_simulation = run_simulation_TD - - if self.parallel: - pool = Pool(self.n_cpu) - self._Jmatrix_sigma = pool.map( - run_simulation, - [ - self.input_args(i, jac_switch='sensitivity_sigma') for i in range(self.n_sounding) - ] - ) - pool.close() - pool.join() - if self.parallel_jvec_jtvec is False: - # self._Jmatrix_sigma = sp.block_diag(self._Jmatrix_sigma).tocsr() - self._Jmatrix_sigma = np.hstack(self._Jmatrix_sigma) - # self._JtJ_sigma_diag = - self._Jmatrix_sigma = sp.coo_matrix( - (self._Jmatrix_sigma, self.IJLayers), dtype=float - ).tocsr() - else: - # _Jmatrix_sigma is block diagnoal matrix (sparse) - # self._Jmatrix_sigma = sp.block_diag( - # [ - # run_simulation(self.input_args(i, jac_switch='sensitivity_sigma')) for i in range(self.n_sounding) - # ] - # ).tocsr() - self._Jmatrix_sigma = [ - run_simulation(self.input_args(i, jac_switch='sensitivity_sigma')) for i in range(self.n_sounding) - ] - self._Jmatrix_sigma = np.hstack(self._Jmatrix_sigma) - self._Jmatrix_sigma = sp.coo_matrix( - (self._Jmatrix_sigma, self.IJLayers), dtype=float - ).tocsr() - - return self._Jmatrix_sigma - - def getJ_height(self, m): - """ - Compute d F / d height - """ - if self.hMap is None: - return Utils.Zero() - - if self._Jmatrix_height is not None: - return self._Jmatrix_height - if self.verbose: - print(">> Compute J height") - - self.model = m - - if self.survey.__class__ == GlobalEM1DSurveyFD: - run_simulation = run_simulation_FD - else: - run_simulation = run_simulation_TD - - if self.parallel: - pool = Pool(self.n_cpu) - self._Jmatrix_height = pool.map( - run_simulation, - [ - self.input_args(i, jac_switch="sensitivity_height") for i in range(self.n_sounding) - ] - ) - pool.close() - pool.join() - if self.parallel_jvec_jtvec is False: - # self._Jmatrix_height = sp.block_diag(self._Jmatrix_height).tocsr() - self._Jmatrix_height = np.hstack(self._Jmatrix_height) - self._Jmatrix_height = sp.coo_matrix( - (self._Jmatrix_height, self.IJHeight), dtype=float - ).tocsr() - else: - # self._Jmatrix_height = sp.block_diag( - # [ - # run_simulation(self.input_args(i, jac_switch='sensitivity_height')) for i in range(self.n_sounding) - # ] - # ).tocsr() - self._Jmatrix_height = [ - run_simulation(self.input_args(i, jac_switch='sensitivity_height')) for i in range(self.n_sounding) - ] - self._Jmatrix_height = np.hstack(self._Jmatrix_height) - self._Jmatrix_height = sp.coo_matrix( - (self._Jmatrix_height, self.IJHeight), dtype=float - ).tocsr() - - return self._Jmatrix_height - - def Jvec(self, m, v, f=None): - J_sigma = self.getJ_sigma(m) - J_height = self.getJ_height(m) - # This is deprecated at the moment - # if self.parallel and self.parallel_jvec_jtvec: - # # Extra division of sigma is because: - # # J_sigma = dF/dlog(sigma) - # # And here sigmaMap also includes ExpMap - # v_sigma = Utils.sdiag(1./self.sigma) * self.sigmaMap.deriv(m, v) - # V_sigma = v_sigma.reshape((self.n_sounding, self.n_layer)) - - # pool = Pool(self.n_cpu) - # Jv = np.hstack( - # pool.map( - # dot, - # [(J_sigma[i], V_sigma[i, :]) for i in range(self.n_sounding)] - # ) - # ) - # if self.hMap is not None: - # v_height = self.hMap.deriv(m, v) - # V_height = v_height.reshape((self.n_sounding, self.n_layer)) - # Jv += np.hstack( - # pool.map( - # dot, - # [(J_height[i], V_height[i, :]) for i in range(self.n_sounding)] - # ) - # ) - # pool.close() - # pool.join() - # else: - Jv = J_sigma*(Utils.sdiag(1./self.sigma)*(self.sigmaDeriv * v)) - if self.hMap is not None: - Jv += J_height*(self.hDeriv * v) - return Jv - - def Jtvec(self, m, v, f=None): - J_sigma = self.getJ_sigma(m) - J_height = self.getJ_height(m) - # This is deprecated at the moment - # if self.parallel and self.parallel_jvec_jtvec: - # pool = Pool(self.n_cpu) - # Jtv = np.hstack( - # pool.map( - # dot, - # [(J_sigma[i].T, v[self.data_index[i]]) for i in range(self.n_sounding)] - # ) - # ) - # if self.hMap is not None: - # Jtv_height = np.hstack( - # pool.map( - # dot, - # [(J_sigma[i].T, v[self.data_index[i]]) for i in range(self.n_sounding)] - # ) - # ) - # # This assumes certain order for model, m = (sigma, height) - # Jtv = np.hstack((Jtv, Jtv_height)) - # pool.close() - # pool.join() - # return Jtv - # else: - # Extra division of sigma is because: - # J_sigma = dF/dlog(sigma) - # And here sigmaMap also includes ExpMap - Jtv = self.sigmaDeriv.T * (Utils.sdiag(1./self.sigma) * (J_sigma.T*v)) - if self.hMap is not None: - Jtv += self.hDeriv.T*(J_height.T*v) - return Jtv - - def getJtJdiag(self, m, W=None, threshold=1e-8): - """ - Compute diagonal component of JtJ or - trace of sensitivity matrix (J) - """ - J_sigma = self.getJ_sigma(m) - J_matrix = J_sigma*(Utils.sdiag(1./self.sigma)*(self.sigmaDeriv)) - - if self.hMap is not None: - J_height = self.getJ_height(m) - J_matrix += J_height*self.hDeriv - - if W is None: - W = Utils.speye(J_matrix.shape[0]) - - J_matrix = W*J_matrix - JtJ_diag = (J_matrix.T*J_matrix).diagonal() - JtJ_diag /= JtJ_diag.max() - JtJ_diag += threshold - return JtJ_diag - - @property - def deleteTheseOnModelUpdate(self): - toDelete = [] - if self.sigmaMap is not None: - toDelete += ['_Sigma'] - if self.fix_Jmatrix is False: - if self._Jmatrix_sigma is not None: - toDelete += ['_Jmatrix_sigma'] - if self._Jmatrix_height is not None: - toDelete += ['_Jmatrix_height'] - return toDelete - - -class GlobalEM1DProblemFD(GlobalEM1DProblem): - - def run_simulation(self, args): - if self.verbose: - print(">> Frequency-domain") - return run_simulation_FD(args) - - @property - def frequency(self): - return self.survey.frequency - - @property - def switch_real_imag(self): - return self.survey.switch_real_imag - - def input_args(self, i_sounding, jac_switch='forward'): - output = ( - self.rx_locations[i_sounding, :], - self.src_locations[i_sounding, :], - self.topo[i_sounding, :], - self.hz, - self.offset, - self.frequency, - self.field_type, - self.rx_type, - self.src_type, - self.Sigma[i_sounding, :], - self.Eta[i_sounding, :], - self.Tau[i_sounding, :], - self.C[i_sounding, :], - self.Chi[i_sounding, :], - self.H[i_sounding], - jac_switch, - self.invert_height, - self.half_switch - ) - return output - - -class GlobalEM1DProblemTD(GlobalEM1DProblem): - - @property - def wave_type(self): - return self.survey.wave_type - - @property - def input_currents(self): - return self.survey.input_currents - - @property - def time_input_currents(self): - return self.survey.time_input_currents - - @property - def n_pulse(self): - return self.survey.n_pulse - - @property - def base_frequency(self): - return self.survey.base_frequency - - @property - def time(self): - return self.survey.time - - @property - def use_lowpass_filter(self): - return self.survey.use_lowpass_filter - - @property - def high_cut_frequency(self): - return self.survey.high_cut_frequency - - @property - def moment_type(self): - return self.survey.moment_type - - @property - def time_dual_moment(self): - return self.survey.time_dual_moment - - @property - def time_input_currents_dual_moment(self): - return self.survey.time_input_currents_dual_moment - - @property - def input_currents_dual_moment(self): - return self.survey.input_currents_dual_moment - - @property - def base_frequency_dual_moment(self): - return self.survey.base_frequency_dual_moment - - def input_args(self, i_sounding, jac_switch='forward'): - output = ( - self.rx_locations[i_sounding, :], - self.src_locations[i_sounding, :], - self.topo[i_sounding, :], - self.hz, - self.time[i_sounding], - self.field_type[i_sounding], - self.rx_type[i_sounding], - self.src_type[i_sounding], - self.wave_type[i_sounding], - self.offset[i_sounding], - self.a[i_sounding], - self.time_input_currents[i_sounding], - self.input_currents[i_sounding], - self.n_pulse[i_sounding], - self.base_frequency[i_sounding], - self.use_lowpass_filter[i_sounding], - self.high_cut_frequency[i_sounding], - self.moment_type[i_sounding], - self.time_dual_moment[i_sounding], - self.time_input_currents_dual_moment[i_sounding], - self.input_currents_dual_moment[i_sounding], - self.base_frequency_dual_moment[i_sounding], - self.Sigma[i_sounding, :], - self.Eta[i_sounding, :], - self.Tau[i_sounding, :], - self.C[i_sounding, :], - self.H[i_sounding], - jac_switch, - self.invert_height, - self.half_switch - ) - return output - - def run_simulation(self, args): - if self.verbose: - print(">> Time-domain") - return run_simulation_TD(args) - - # def forward(self, m, f=None): - # self.model = m - - # if self.parallel: - # pool = Pool(self.n_cpu) - # # This assumes the same # of layer for each of soundings - # result = pool.map( - # run_simulation_TD, - # [ - # self.input_args(i, jac_switch=False) for i in range(self.n_sounding) - # ] - # ) - # pool.close() - # pool.join() - # else: - # result = [ - # run_simulation_TD(self.input_args(i, jac_switch=False)) for i in range(self.n_sounding) - # ] - # return np.hstack(result) - - # def getJ(self, m): - # """ - # Compute d F / d sigma - # """ - # if self._Jmatrix is not None: - # return self._Jmatrix - # if self.verbose: - # print(">> Compute J") - # self.model = m - # if self.parallel: - # pool = Pool(self.n_cpu) - # self._Jmatrix = pool.map( - # run_simulation_TD, - # [ - # self.input_args(i, jac_switch=True) for i in range(self.n_sounding) - # ] - # ) - # pool.close() - # pool.join() - # if self.parallel_jvec_jtvec is False: - # self._Jmatrix = sp.block_diag(self._Jmatrix).tocsr() - # else: - # # _Jmatrix is block diagnoal matrix (sparse) - # self._Jmatrix = sp.block_diag( - # [ - # run_simulation_TD(self.input_args(i, jac_switch=True)) for i in range(self.n_sounding) - # ] - # ).tocsr() - # return self._Jmatrix - - -class GlobalEM1DSurvey(Survey.BaseSurvey, properties.HasProperties): - - # This assumes a multiple sounding locations - rx_locations = properties.Array( - "Receiver locations ", dtype=float, shape=('*', 3) - ) - src_locations = properties.Array( - "Source locations ", dtype=float, shape=('*', 3) - ) - topo = properties.Array( - "Topography", dtype=float, shape=('*', 3) - ) - - half_switch = properties.Bool("Switch for half-space", default=False) - - _pred = None - - @Utils.requires('prob') - def dpred(self, m, f=None): - """ - Return predicted data. - Predicted data, (`_pred`) are computed when - self.prob.fields is called. - """ - if f is None: - f = self.prob.fields(m) - - return self._pred - - @property - def n_sounding(self): - """ - # of Receiver locations - """ - return self.rx_locations.shape[0] - - @property - def n_layer(self): - """ - # of Receiver locations - """ - return self.prob.n_layer - - def read_xyz_data(self, fname): - """ - Read csv file format - This is a place holder at this point - """ - pass - - @property - def nD(self): - # Need to generalize this for the dual moment data - if getattr(self, '_nD', None) is None: - self._nD = self.nD_vec.sum() - return self._nD - - def set_ij_n_layer(self, n_layer=None): - """ - Compute (I, J) indicies to form sparse sensitivity matrix - This will be used in GlobalEM1DProblem when after sensitivity matrix - for each sounding is computed - """ - I = [] - J = [] - shift_for_J = 0 - shift_for_I = 0 - if n_layer is None: - m = self.n_layer - else: - m = n_layer - - for i in range(self.n_sounding): - n = self.nD_vec[i] - J_temp = np.tile(np.arange(m), (n, 1)) + shift_for_J - I_temp = ( - np.tile(np.arange(n), (1, m)).reshape((n, m), order='F') + - shift_for_I - ) - J.append(Utils.mkvc(J_temp)) - I.append(Utils.mkvc(I_temp)) - shift_for_J += m - shift_for_I = I_temp[-1, -1] + 1 - J = np.hstack(J).astype(int) - I = np.hstack(I).astype(int) - return (I, J) - - def set_ij_height(self): - """ - Compute (I, J) indicies to form sparse sensitivity matrix - This will be used in GlobalEM1DProblem when after sensitivity matrix - for each sounding is computed - """ - I = [] - J = [] - shift_for_J = 0 - shift_for_I = 0 - m = self.n_layer - for i in range(n_sounding): - n = self.nD_vec[i] - J_temp = np.tile(np.arange(m), (n, 1)) + shift_for_J - I_temp = ( - np.tile(np.arange(n), (1, m)).reshape((n, m), order='F') + - shift_for_I - ) - J.append(Utils.mkvc(J_temp)) - I.append(Utils.mkvc(I_temp)) - shift_for_J += m - shift_for_I = I_temp[-1, -1] + 1 - J = np.hstack(J).astype(int) - I = np.hstack(I).astype(int) - return (I, J) - - -class GlobalEM1DSurveyFD(GlobalEM1DSurvey, EM1DSurveyFD): - - @property - def nD_vec(self): - if getattr(self, '_nD_vec', None) is None: - self._nD_vec = [] - if self.switch_real_imag == "all": - nD_for_sounding = int(self.n_frequency * 2) - elif ( - self.switch_real_imag == "imag" or self.switch_real_imag == "real" - ): - nD_for_sounding = int(self.n_frequency) - - for ii in range(self.n_sounding): - self._nD_vec.append(nD_for_sounding) - self._nD_vec = np.array(self._nD_vec) - return self._nD_vec - - # @property - # def nD(self): - # if self.switch_real_imag == "all": - # return int(self.n_frequency * 2) * self.n_sounding - # elif ( - # self.switch_real_imag == "imag" or self.switch_real_imag == "real" - # ): - # return int(self.n_frequency) * self.n_sounding - - def read_xyz_data(self, fname): - """ - Read csv file format - This is a place holder at this point - """ - pass - - -class GlobalEM1DSurveyTD(GlobalEM1DSurvey): - - # --------------- Essential inputs ---------------- # - src_type = None - - rx_type = None - - field_type = None - - time = [] - - wave_type = None - - moment_type = None - - time_input_currents = [] - - input_currents = [] - - # --------------- Selective inputs ---------------- # - n_pulse = properties.Array( - "The number of pulses", - default=None - ) - - base_frequency = properties.Array( - "Base frequency (Hz)", - dtype=float, default=None - ) - - offset = properties.Array( - "Src-Rx offsets", dtype=float, default=None, - shape=('*', '*') - ) - - I = properties.Array( - "Src loop current", dtype=float, default=None - ) - - a = properties.Array( - "Src loop radius", dtype=float, default=None - ) - - use_lowpass_filter = properties.Array( - "Switch for low pass filter", - dtype=bool, default=None - ) - - high_cut_frequency = properties.Array( - "High cut frequency for low pass filter (Hz)", - dtype=float, default=None - ) - - # ------------- For dual moment ------------- # - - time_dual_moment = [] - - time_input_currents_dual_moment = [] - - input_currents_dual_moment = [] - - base_frequency_dual_moment = properties.Array( - "Base frequency for the dual moment (Hz)", - dtype=float, default=None - ) - - def __init__(self, **kwargs): - GlobalEM1DSurvey.__init__(self, **kwargs) - self.set_parameters() - - def set_parameters(self): - # TODO: need to put some validation process - # e.g. for VMD `offset` must be required - # e.g. for CircularLoop `a` must be required - - print(">> Set parameters") - if self.n_pulse is None: - self.n_pulse = np.ones(self.n_sounding, dtype=int) * 1 - - if self.base_frequency is None: - self.base_frequency = np.ones( - (self.n_sounding), dtype=float - ) * 30 - - if self.offset is None: - self.offset = np.empty((self.n_sounding, 1), dtype=float) - - if self.I is None: - self.I = np.empty(self.n_sounding, dtype=float) - - if self.a is None: - self.a = np.empty(self.n_sounding, dtype=float) - - if self.use_lowpass_filter is None: - self.use_lowpass_filter = np.zeros(self.n_sounding, dtype=bool) - - if self.high_cut_frequency is None: - self.high_cut_frequency = np.empty(self.n_sounding, dtype=float) - - if self.moment_type is None: - self.moment_type = np.array(["single"], dtype=str).repeat( - self.n_sounding, axis=0 - ) - - # List - if not self.time_input_currents: - self.time_input_currents = [ - np.empty(1, dtype=float) for i in range(self.n_sounding) - ] - # List - if not self.input_currents: - self.input_currents = [ - np.empty(1, dtype=float) for i in range(self.n_sounding) - ] - - # List - if not self.time_dual_moment: - self.time_dual_moment = [ - np.empty(1, dtype=float) for i in range(self.n_sounding) - ] - # List - if not self.time_input_currents_dual_moment: - self.time_input_currents_dual_moment = [ - np.empty(1, dtype=float) for i in range(self.n_sounding) - ] - # List - if not self.input_currents_dual_moment: - self.input_currents_dual_moment = [ - np.empty(1, dtype=float) for i in range(self.n_sounding) - ] - - if self.base_frequency_dual_moment is None: - self.base_frequency_dual_moment = np.empty( - (self.n_sounding), dtype=float - ) - - @property - def nD_vec(self): - if getattr(self, '_nD_vec', None) is None: - self._nD_vec = [] - - for ii, moment_type in enumerate(self.moment_type): - if moment_type == 'single': - self._nD_vec.append(self.time[ii].size) - elif moment_type == 'dual': - self._nD_vec.append( - self.time[ii].size+self.time_dual_moment[ii].size - ) - else: - raise Exception("moment_type must be either signle or dual") - self._nD_vec = np.array(self._nD_vec) - return self._nD_vec - - @property - def data_index(self): - # Need to generalize this for the dual moment data - if getattr(self, '_data_index', None) is None: - self._data_index = [ - np.arange(self.nD_vec[i_sounding])+np.sum(self.nD_vec[:i_sounding]) for i_sounding in range(self.n_sounding) - ] - return self._data_index - - @property - def nD(self): - # Need to generalize this for the dual moment data - if getattr(self, '_nD', None) is None: - self._nD = self.nD_vec.sum() - return self._nD diff --git a/simpegEM1D/IO.py b/simpegEM1D/IO.py index f521db0..d3252b5 100644 --- a/simpegEM1D/IO.py +++ b/simpegEM1D/IO.py @@ -2,8 +2,9 @@ import numpy as np from scipy.spatial import cKDTree as kdtree import scipy.sparse as sp -from SimPEG import Utils, Mesh -from .EM1DSimulation import set_mesh_1d +from SimPEG import utils +from discretize import TensorMesh +from .utils import set_mesh_1d import matplotlib.pyplot as plt from matplotlib.colors import LogNorm import warnings @@ -141,8 +142,8 @@ def plot_plan( contourOpts['cmap'] = cmap - im = Utils.plot2Ddata( - self.topography[:, :2], Utils.mkvc(physical_property_matrix[i_layer, :]), scale=scale, + im = utils.plot2Ddata( + self.topography[:, :2], utils.mkvc(physical_property_matrix[i_layer, :]), scale=scale, ncontour=ncontour, ax=ax, contourOpts=contourOpts, dataloc=False, ) @@ -220,15 +221,15 @@ def plot_section( norm=None contourOpts['cmap'] = cmap - im = Utils.plot2Ddata( - yz, Utils.mkvc(physical_property_matrix[:, ind_line]), scale='log', ncontour=40, dataloc=False, ax=ax, + im = utils.plot2Ddata( + yz, utils.mkvc(physical_property_matrix[:, ind_line]), scale='log', ncontour=40, dataloc=False, ax=ax, contourOpts=contourOpts ) ax.fill_between(self.topography[ind_line, 1], self.topography[ind_line, 2], y2=yz[:,1].max(), color='w') out = ax.scatter( yz[:, 0], yz[:, 1], - c=Utils.mkvc(physical_property_matrix[:, ind_line]), s=0.1, vmin=vmin, vmax=vmax, + c=utils.mkvc(physical_property_matrix[:, ind_line]), s=0.1, vmin=vmin, vmax=vmax, cmap=cmap, alpha=1, norm=norm ) elif plot_type == "pcolor": @@ -314,8 +315,8 @@ def get_3d_mesh( hy = [(dy, npad_y, -1.2), (dy, ny), (dy, npad_y, -1.2)] hz = [(dz, npad_z, -1.2), (dz, nz)] - zmin = self.topography[:, 2].max() - Utils.meshTensor(hz).sum() - self._mesh_3d = Mesh.TensorMesh([hx, hy, hz], x0=[xmin, ymin, zmin]) + zmin = self.topography[:, 2].max() - utils.meshTensor(hz).sum() + self._mesh_3d = TensorMesh([hx, hy, hz], x0=[xmin, ymin, zmin]) return self.mesh_3d @@ -332,29 +333,29 @@ def get_interpolation_matrix( ): tree_2d = kdtree(self.topography[:, :2]) - xy = Utils.ndgrid(self.mesh_3d.vectorCCx, self.mesh_3d.vectorCCy) + xy = utils.ndgrid(self.mesh_3d.vectorCCx, self.mesh_3d.vectorCCy) distance, inds = tree_2d.query(xy, k=npts) if epsilon is None: epsilon = np.min([self.mesh_3d.hx.min(), self.mesh_3d.hy.min()]) w = 1. / (distance + epsilon)**2 - w = Utils.sdiag(1./np.sum(w, axis=1)) * (w) - I = Utils.mkvc( + w = utils.sdiag(1./np.sum(w, axis=1)) * (w) + I = utils.mkvc( np.arange(inds.shape[0]).reshape([-1, 1]).repeat(npts, axis=1) ) - J = Utils.mkvc(inds) + J = utils.mkvc(inds) self._P = sp.coo_matrix( - (Utils.mkvc(w), (I, J)), + (utils.mkvc(w), (I, J)), shape=(inds.shape[0], self.topography.shape[0]) ) - mesh_1d = Mesh.TensorMesh([np.r_[self.hz[:-1], 1e20]]) + mesh_1d = TensorMesh([np.r_[self.hz[:-1], 1e20]]) z = self.P*self.topography[:, 2] - self._actinds = Utils.surface2ind_topo(self.mesh_3d, np.c_[xy, z]) + self._actinds = utils.surface2ind_topo(self.mesh_3d, np.c_[xy, z]) Z = np.empty(self.mesh_3d.vnC, dtype=float, order='F') Z = self.mesh_3d.gridCC[:, 2].reshape( diff --git a/simpegEM1D/Kernels.py b/simpegEM1D/Kernels.py deleted file mode 100644 index a7ac768..0000000 --- a/simpegEM1D/Kernels.py +++ /dev/null @@ -1,81 +0,0 @@ -# import numpy as np -# from scipy.constants import mu_0 -# from .DigFilter import EvalDigitalFilt -# from RTEfun import rTEfun - -# def HzKernel_layer(lamda, f, nlay, sig, chi, depth, h, z, flag): - -# """ - -# Kernel for vertical magnetic component (Hz) due to vertical magnetic -# diopole (VMD) source in (kx,ky) domain - -# """ -# u0 = lamda -# rTE, M00, M01, M10, M11 = rTEfun(nlay, f, lamda, sig, chi, depth) - -# if flag=='secondary': -# # Note -# # Here only computes secondary field. -# # I am not sure why it does not work if we add primary term. -# # This term can be analytically evaluated, where h = 0. - -# kernel = 1/(4*np.pi)*(rTE*np.exp(-u0*(z+h)))*lamda**3/u0 - -# else: -# kernel = 1/(4*np.pi)*(np.exp(u0*(z-h))+ rTE*np.exp(-u0*(z+h)))*lamda**3/u0 - -# return kernel - -# def HzkernelCirc_layer(lamda, f, nlay, sig, chi, depth, h, z, I, a, flag): - -# """ - -# Kernel for vertical magnetic component (Hz) at the center -# due to circular loop source in (kx,ky) domain - -# .. math:: - -# H_z = \\frac{Ia}{2} \int_0^{\infty} [e^{-u_0|z+h|} + r_{TE}e^{u_0|z-h|}] \\frac{\lambda^2}{u_0} J_1(\lambda a)] d \lambda - -# """ - -# w = 2*np.pi*f -# rTE = np.zeros(lamda.size, dtype=complex) -# u0 = lamda -# rTE, M00, M01, M10, M11 = rTEfun(nlay, f, lamda, sig, chi, depth) - -# if flag == 'secondary': -# kernel = I*a*0.5*(rTE*np.exp(-u0*(z+h)))*lamda**2/u0 -# else: -# kernel = I*a*0.5*(np.exp(u0*(z-h))+rTE*np.exp(-u0*(z+h)))*lamda**2/u0 - -# return kernel - -#TODO: Get rid of below two functions and put in in main class -# def HzFreq_layer(nlay, sig, chi, depth, f, z, h, r, flag, YBASE, WT0): -# """ - -# """ -# nfreq = np.size(f) -# HzFHT = np.zeros(nfreq, dtype = complex) -# for ifreq in range(nfreq): - -# kernel = lambda x: HzKernel_layer(x, f[ifreq], nlay, sig, chi, depth, h, z, flag) -# HzFHT[ifreq] = EvalDigitalFilt(YBASE, WT0, kernel, r) - -# return HzFHT - -# def HzCircFreq_layer(nlay, sig, chi, depth, f, z, h, I, a, flag, YBASE, WT1): - -# """ - -# """ -# nfreq = np.size(f) -# HzFHT = np.zeros(nfreq, dtype = complex) -# for ifreq in range(nfreq): - -# kernel = lambda x: HzkernelCirc_layer(x, f[ifreq], nlay, sig, chi, depth, h, z, I, a, flag) -# HzFHT[ifreq] = EvalDigitalFilt(YBASE, WT1, kernel, a) - -# return HzFHT diff --git a/simpegEM1D/RTEfun.py b/simpegEM1D/RTEfun.py deleted file mode 100644 index d1b0ced..0000000 --- a/simpegEM1D/RTEfun.py +++ /dev/null @@ -1,441 +0,0 @@ -import numpy as np -from scipy.constants import mu_0 - - -# TODO: make this to take a vector rather than a single frequency -def rTEfunfwd(nlay, f, lamda, sig, chi, depth, HalfSwitch): - """ - Compute reflection coefficients for Transverse Electric (TE) mode. - Only one for loop for multiple layers. Do not use for loop for lambda, - which has 801 times of loops (actually, this makes the code really slow). - """ - Mtemp00 = np.zeros(lamda.size, dtype=complex) - Mtemp10 = np.zeros(lamda.size, dtype=complex) - Mtemp01 = np.zeros(lamda.size, dtype=complex) - Mtemp11 = np.zeros(lamda.size, dtype=complex) - - M1sum00 = np.zeros(lamda.size, dtype=complex) - M1sum10 = np.zeros(lamda.size, dtype=complex) - M1sum01 = np.zeros(lamda.size, dtype=complex) - M1sum11 = np.zeros(lamda.size, dtype=complex) - - thick = -np.diff(depth) - w = 2*np.pi*f - - rTE = np.zeros(lamda.size, dtype=complex) - utemp0 = np.zeros(lamda.size, dtype=complex) - utemp1 = np.zeros(lamda.size, dtype=complex) - const = np.zeros(lamda.size, dtype=complex) - - utemp0 = lamda - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0]) - const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) - - Mtemp00 = 0.5*(1+const) - Mtemp10 = 0.5*(1-const) - Mtemp01 = 0.5*(1-const) - Mtemp11 = 0.5*(1+const) - - M00 = [] - M10 = [] - M01 = [] - M11 = [] - - M0sum00 = Mtemp00 - M0sum10 = Mtemp10 - M0sum01 = Mtemp01 - M0sum11 = Mtemp11 - - if HalfSwitch == True: - - M1sum00 = np.zeros(lamda.size, dtype=complex) - M1sum10 = np.zeros(lamda.size, dtype=complex) - M1sum01 = np.zeros(lamda.size, dtype=complex) - M1sum11 = np.zeros(lamda.size, dtype=complex) - - M1sum00 = M0sum00 - M1sum10 = M0sum10 - M1sum01 = M0sum01 - M1sum11 = M0sum11 - - else : - - for j in range (nlay-1): - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j])*sig[j]) - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j+1])*sig[j+1]) - const = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0) - - h0 = thick[j] - - Mtemp00 = 0.5*(1.+ const)*np.exp(-2.*utemp0*h0) - Mtemp10 = 0.5*(1.- const) - Mtemp01 = 0.5*(1.- const)*np.exp(-2.*utemp0*h0) - Mtemp11 = 0.5*(1.+ const) - - M1sum00 = M0sum00*Mtemp00 + M0sum01*Mtemp10 - M1sum10 = M0sum10*Mtemp00 + M0sum11*Mtemp10 - M1sum01 = M0sum00*Mtemp01 + M0sum01*Mtemp11 - M1sum11 = M0sum10*Mtemp01 + M0sum11*Mtemp11 - - M0sum00 = M1sum00 - M0sum10 = M1sum10 - M0sum01 = M1sum01 - M0sum11 = M1sum11 - - rTE = M1sum01/M1sum11 - - return rTE - - -def matmul(a00, a10, a01, a11, b00, b10, b01, b11): - """ - Compute 2x2 matrix mutiplication in vector way - C = A*B - C = [a00 a01] * [b00 b01] = [c00 c01] - [a10 a11] [b10 b11] [c10 c11] - """ - - c00 = a00*b00 + a01*b10 - c10 = a10*b00 + a11*b10 - c01 = a00*b01 + a01*b11 - c11 = a10*b01 + a11*b11 - - return c00, c10, c01, c11 - - -# TODO: make this to take a vector rather than a single frequency -def rTEfunjac(nlay, f, lamda, sig, chi, depth, HalfSwitch): - """ - Compute reflection coefficients for Transverse Electric (TE) mode. - Only one for loop for multiple layers. Do not use for loop for lambda, - which has 801 times of loops (actually, this makes the code really slow). - """ - # Initializing arrays - Mtemp00 = np.zeros(lamda.size, dtype=complex) - Mtemp10 = np.zeros(lamda.size, dtype=complex) - Mtemp01 = np.zeros(lamda.size, dtype=complex) - Mtemp11 = np.zeros(lamda.size, dtype=complex) - - M1sum00 = np.zeros(lamda.size, dtype=complex) - M1sum10 = np.zeros(lamda.size, dtype=complex) - M1sum01 = np.zeros(lamda.size, dtype=complex) - M1sum11 = np.zeros(lamda.size, dtype=complex) - - M0sum00 = np.zeros(lamda.size, dtype=complex) - M0sum10 = np.zeros(lamda.size, dtype=complex) - M0sum01 = np.zeros(lamda.size, dtype=complex) - M0sum11 = np.zeros(lamda.size, dtype=complex) - - dMtemp00 = np.zeros(lamda.size, dtype=complex) - dMtemp10 = np.zeros(lamda.size, dtype=complex) - dMtemp01 = np.zeros(lamda.size, dtype=complex) - dMtemp11 = np.zeros(lamda.size, dtype=complex) - - dj0temp00 = np.zeros(lamda.size, dtype=complex) - dj0temp10 = np.zeros(lamda.size, dtype=complex) - dj0temp01 = np.zeros(lamda.size, dtype=complex) - dj0temp11 = np.zeros(lamda.size, dtype=complex) - - dj1temp00 = np.zeros(lamda.size, dtype=complex) - dj1temp10 = np.zeros(lamda.size, dtype=complex) - dj1temp01 = np.zeros(lamda.size, dtype=complex) - dj1temp11 = np.zeros(lamda.size, dtype=complex) - - thick = -np.diff(depth) - w = 2*np.pi*f - - rTE = np.zeros(lamda.size, dtype=complex) - drTE = np.zeros((nlay, lamda.size) , dtype=complex) - utemp0 = np.zeros(lamda.size, dtype=complex) - utemp1 = np.zeros(lamda.size, dtype=complex) - const = np.zeros(lamda.size, dtype=complex) - - utemp0 = lamda - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0]) - const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) - - # Compute M1 - Mtemp00 = 0.5*(1+const) - Mtemp10 = 0.5*(1-const) - Mtemp01 = 0.5*(1-const) - Mtemp11 = 0.5*(1+const) - - utemp0 = lamda - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0]) - const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) - - # Compute dM1du1 - dj0Mtemp00 = 0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - dj0Mtemp10 = -0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - dj0Mtemp01 = -0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - dj0Mtemp11 = 0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - - # TODO: for computing Jacobian - M00 = [] - M10 = [] - M01 = [] - M11 = [] - - dJ00 = [] - dJ10 = [] - dJ01 = [] - dJ11 = [] - - M00.append(Mtemp00) - M01.append(Mtemp01) - M10.append(Mtemp10) - M11.append(Mtemp11) - - M0sum00 = Mtemp00.copy() - M0sum10 = Mtemp10.copy() - M0sum01 = Mtemp01.copy() - M0sum11 = Mtemp11.copy() - - if HalfSwitch == True: - - M1sum00 = np.zeros(lamda.size, dtype=complex) - M1sum10 = np.zeros(lamda.size, dtype=complex) - M1sum01 = np.zeros(lamda.size, dtype=complex) - M1sum11 = np.zeros(lamda.size, dtype=complex) - - M1sum00 = M0sum00.copy() - M1sum10 = M0sum10.copy() - M1sum01 = M0sum01.copy() - M1sum11 = M0sum11.copy() - - else: - - for j in range (nlay-1): - - dJ_10Mtemp00 = np.zeros(lamda.size, dtype=complex) - dJ_10Mtemp10 = np.zeros(lamda.size, dtype=complex) - dJ_10Mtemp01 = np.zeros(lamda.size, dtype=complex) - dJ_10Mtemp11 = np.zeros(lamda.size, dtype=complex) - - dJ01Mtemp00 = np.zeros(lamda.size, dtype=complex) - dJ01Mtemp10 = np.zeros(lamda.size, dtype=complex) - dJ01Mtemp01 = np.zeros(lamda.size, dtype=complex) - dJ01Mtemp11 = np.zeros(lamda.size, dtype=complex) - - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j])*sig[j]) - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j+1])*sig[j+1]) - const = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0) - - h0 = thick[j] - - Mtemp00 = 0.5*(1.+ const)*np.exp(-2.*utemp0*h0) - Mtemp10 = 0.5*(1.- const) - Mtemp01 = 0.5*(1.- const)*np.exp(-2.*utemp0*h0) - Mtemp11 = 0.5*(1.+ const) - - M1sum00, M1sum10, M1sum01, M1sum11 = matmul( - M0sum00, M0sum10, M0sum01, M0sum11, - Mtemp00, Mtemp10, Mtemp01, Mtemp11 - ) - - M0sum00 = M1sum00 - M0sum10 = M1sum10 - M0sum01 = M1sum01 - M0sum11 = M1sum11 - - # TODO: for Computing Jacobian - - dudsig = 0.5*1j*w*mu_0*(1+chi[j])/utemp0 - - if j==0: - - const1a = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0**2) - const1b = const1a*utemp0 - - dj1Mtemp00 = -0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1+const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp10 = 0.5*const1a - dj1Mtemp01 = 0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1-const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp11 = -0.5*const1a - - #Compute dM1dm1*M2 - dJ_10Mtemp00, dJ_10Mtemp10, dJ_10Mtemp01, dJ_10Mtemp11 = matmul(dj0Mtemp00, dj0Mtemp10, dj0Mtemp01, dj0Mtemp11, Mtemp00, Mtemp10, Mtemp01, Mtemp11) - - #Compute M1*dM2dm1 - dJ01Mtemp00, dJ01Mtemp10, dJ01Mtemp01, dJ01Mtemp11 = matmul(M00[j], M10[j], M01[j], M11[j], dj1Mtemp00, dj1Mtemp10, dj1Mtemp01, dj1Mtemp11) - - dJ00.append(dudsig*(dJ_10Mtemp00+dJ01Mtemp00)) - dJ10.append(dudsig*(dJ_10Mtemp10+dJ01Mtemp10)) - dJ01.append(dudsig*(dJ_10Mtemp01+dJ01Mtemp01)) - dJ11.append(dudsig*(dJ_10Mtemp11+dJ01Mtemp11)) - - else: - - h_1 = thick[j-1] - utemp_1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j-1])*sig[j-1]) - const0 = mu_0*(1+chi[j-1])/(mu_0*(1+chi[j])*utemp_1) - - dj0Mtemp00 = 0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp10 = -0.5*(const0) - dj0Mtemp01 = -0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp11 = 0.5*(const0) - - - const1a = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0**2) - const1b = const1a*utemp0 - - dj1Mtemp00 = -0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1+const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp10 = 0.5*const1a - dj1Mtemp01 = 0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1-const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp11 = -0.5*const1a - - #Compute dMjdmj*Mj+1 - dJ_10Mtemp00, dJ_10Mtemp10, dJ_10Mtemp01, dJ_10Mtemp11 = matmul(dj0Mtemp00, dj0Mtemp10, dj0Mtemp01, dj0Mtemp11, Mtemp00, Mtemp10, Mtemp01, Mtemp11) - - #Compute Mj*dMj+1dmj - dJ01Mtemp00, dJ01Mtemp10, dJ01Mtemp01, dJ01Mtemp11 = matmul(M00[j], M10[j], M01[j], M11[j], dj1Mtemp00, dj1Mtemp10, dj1Mtemp01, dj1Mtemp11) - - dJ00.append(dudsig*(dJ_10Mtemp00+dJ01Mtemp00)) - dJ10.append(dudsig*(dJ_10Mtemp10+dJ01Mtemp10)) - dJ01.append(dudsig*(dJ_10Mtemp01+dJ01Mtemp01)) - dJ11.append(dudsig*(dJ_10Mtemp11+dJ01Mtemp11)) - - M00.append(Mtemp00) - M01.append(Mtemp01) - M10.append(Mtemp10) - M11.append(Mtemp11) - - # rTE = M1sum01/M1sum11 - - if HalfSwitch == True: - - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0]) - dudsig = 0.5*1j*w*mu_0*(1+chi[0])/utemp0 - - dJ1sum00 = np.zeros(lamda.size, dtype=complex) - dJ1sum10 = np.zeros(lamda.size, dtype=complex) - dJ1sum01 = np.zeros(lamda.size, dtype=complex) - dJ1sum11 = np.zeros(lamda.size, dtype=complex) - - dJ1sum00 = dudsig*dj0Mtemp00 - dJ1sum10 = dudsig*dj0Mtemp10 - dJ1sum01 = dudsig*dj0Mtemp01 - dJ1sum11 = dudsig*dj0Mtemp11 - - drTE = dJ1sum01/M1sum11 - M1sum01/(M1sum11**2)*dJ1sum11 - - else: - - #j = nlay - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[nlay-1])*sig[nlay-1]) - dudsig = 0.5*1j*w*mu_0*(1+chi[j])/utemp0 - - h_1 = thick[nlay-2] - utemp_1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[nlay-2])*sig[nlay-2]) - const0 = mu_0*(1+chi[nlay-2])/(mu_0*(1+chi[nlay-1])*utemp_1) - - dj0Mtemp00 = 0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp10 = -0.5*(const0) - dj0Mtemp01 = -0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp11 = 0.5*(const0) - - dJ_10Mtemp00 = dj0Mtemp00 - dJ_10Mtemp10 = dj0Mtemp10 - dJ_10Mtemp01 = dj0Mtemp01 - dJ_10Mtemp11 = dj0Mtemp11 - - dJ00.append(dudsig*dJ_10Mtemp00) - dJ10.append(dudsig*dJ_10Mtemp10) - dJ01.append(dudsig*dJ_10Mtemp01) - dJ11.append(dudsig*dJ_10Mtemp11) - - for i in range (nlay): - - dJ0sum00 = np.zeros(lamda.size, dtype=complex) - dJ0sum10 = np.zeros(lamda.size, dtype=complex) - dJ0sum01 = np.zeros(lamda.size, dtype=complex) - dJ0sum11 = np.zeros(lamda.size, dtype=complex) - - dJ1sum00 = np.zeros(lamda.size, dtype=complex) - dJ1sum10 = np.zeros(lamda.size, dtype=complex) - dJ1sum01 = np.zeros(lamda.size, dtype=complex) - dJ1sum11 = np.zeros(lamda.size, dtype=complex) - - if i==0: - - for j in range (nlay-2): - - if j==0: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ00[i], dJ10[i], dJ01[i], dJ11[i], M00[j+2], M10[j+2], M01[j+2], M11[j+2] - ) - - else: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, M00[j+2], M10[j+2], M01[j+2], M11[j+2] - ) - - dJ0sum00 = dJ1sum00 - dJ0sum10 = dJ1sum10 - dJ0sum01 = dJ1sum01 - dJ0sum11 = dJ1sum11 - - elif (i>0) & (i i-1: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, M00[j+2], M10[j+2], M01[j+2], M11[j+2] - ) - - dJ0sum00 = dJ1sum00 - dJ0sum10 = dJ1sum10 - dJ0sum01 = dJ1sum01 - dJ0sum11 = dJ1sum11 - - elif i==nlay-1: - - dJ0sum00 = M00[0] - dJ0sum10 = M10[0] - dJ0sum01 = M01[0] - dJ0sum11 = M11[0] - - for j in range (nlay-1): - - if j < nlay-2: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, M00[j+1], M10[j+1], M01[j+1], M11[j+1] - ) - - elif j == nlay-2: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, dJ00[i], dJ10[i], dJ01[i], dJ11[i] - ) - - dJ0sum00 = dJ1sum00 - dJ0sum10 = dJ1sum10 - dJ0sum01 = dJ1sum01 - dJ0sum11 = dJ1sum11 - - drTE[i, :] = dJ1sum01/M1sum11 - M1sum01/(M1sum11**2)*dJ1sum11 - - return drTE - # return rTE, drTE - diff --git a/simpegEM1D/RTEfun_vec.py b/simpegEM1D/RTEfun_vec.py deleted file mode 100644 index c6e65bb..0000000 --- a/simpegEM1D/RTEfun_vec.py +++ /dev/null @@ -1,510 +0,0 @@ -import numpy as np -from scipy.constants import mu_0 - - -# TODO: make this to take a vector rather than a single frequency -def rTEfunfwd(n_layer, f, lamda, sig, chi, depth, HalfSwitch): - """ - Compute reflection coefficients for Transverse Electric (TE) mode. - Only one for loop for multiple layers. - - Parameters - ---------- - n_layer : int - The number layers - f : complex, ndarray - Frequency (Hz); size = (n_frequency x n_filter) - lamda : complex, ndarray - Frequency (Hz); size = (n_frequency x n_filter) - sig: compelx, ndarray - Conductivity (S/m); size = (n_layer x n_frequency x n_filter) - chi: compelx, ndarray - Susceptibility (SI); size = (n_layer,) - depth: float, ndarray - Top boundary of the layers; size = (n_ayer,) - HalfSwitch: bool - Switch for halfspace - - Returns - ------- - rTE: compex, ndarray - Reflection coefficients; - size = (n_frequency x n_lamba) - """ - - n_frequency, n_filter = lamda.shape - - Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) - Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) - Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) - Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - M1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - thick = -np.diff(depth) - w = 2*np.pi*f - - rTE = np.zeros((n_frequency, n_filter), dtype=complex) - utemp0 = np.zeros((n_frequency, n_filter), dtype=complex) - utemp1 = np.zeros((n_frequency, n_filter), dtype=complex) - const = np.zeros((n_frequency, n_filter), dtype=complex) - - utemp0 = lamda - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0, :, :]) - const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) - - Mtemp00 = 0.5*(1+const) - Mtemp10 = 0.5*(1-const) - Mtemp01 = 0.5*(1-const) - Mtemp11 = 0.5*(1+const) - - # may be store these and reuse for sensitivity? - M00 = [] - M10 = [] - M01 = [] - M11 = [] - - M0sum00 = Mtemp00 - M0sum10 = Mtemp10 - M0sum01 = Mtemp01 - M0sum11 = Mtemp11 - - if HalfSwitch: - - M1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - M1sum00 = M0sum00 - M1sum10 = M0sum10 - M1sum01 = M0sum01 - M1sum11 = M0sum11 - - else: - - for j in range(n_layer-1): - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j])*sig[j, :, :]) - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j+1])*sig[j+1, :, :]) - const = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0) - - h0 = thick[j] - - Mtemp00 = 0.5*(1.+const)*np.exp(-2.*utemp0*h0) - Mtemp10 = 0.5*(1.-const) - Mtemp01 = 0.5*(1.-const)*np.exp(-2.*utemp0*h0) - Mtemp11 = 0.5*(1.+const) - - M1sum00 = M0sum00*Mtemp00 + M0sum01*Mtemp10 - M1sum10 = M0sum10*Mtemp00 + M0sum11*Mtemp10 - M1sum01 = M0sum00*Mtemp01 + M0sum01*Mtemp11 - M1sum11 = M0sum10*Mtemp01 + M0sum11*Mtemp11 - - M0sum00 = M1sum00 - M0sum10 = M1sum10 - M0sum01 = M1sum01 - M0sum11 = M1sum11 - - rTE = M1sum01/M1sum11 - - return rTE - - -def matmul(a00, a10, a01, a11, b00, b10, b01, b11): - """ - Compute 2x2 matrix mutiplication in vector way - C = A*B - C = [a00 a01] * [b00 b01] = [c00 c01] - [a10 a11] [b10 b11] [c10 c11] - """ - - c00 = a00*b00 + a01*b10 - c10 = a10*b00 + a11*b10 - c01 = a00*b01 + a01*b11 - c11 = a10*b01 + a11*b11 - - return c00, c10, c01, c11 - - -# TODO: make this to take a vector rather than a single frequency -def rTEfunjac(n_layer, f, lamda, sig, chi, depth, HalfSwitch): - """ - Compute sensitivity of reflection coefficients for - Transverse Electric (TE) mode with regard to conductivity - - Parameters - ---------- - n_layer : int - The number layers - f : complex, ndarray - Frequency (Hz); size = (n_frequency x n_finlter) - lamda : complex, ndarray - Frequency (Hz); size = (n_frequency x n_finlter) - sig: compelx, ndarray - Conductivity (S/m); size = (n_layer x 1) - chi: compelx, ndarray - Susceptibility (SI); size = (n_layer x 1) - depth: float, ndarray - Top boundary of the layers - HalfSwitch: bool - Switch for halfspace - - Returns - ------- - rTE: compex, ndarray - Derivative of reflection coefficients; - size = (n_frequency x n_layer x n_finlter) - """ - # Initializing arrays - n_frequency, n_filter = lamda.shape - - Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) - Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) - Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) - Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - M1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - M1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - M0sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - M0sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - M0sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - M0sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - dMtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) - dMtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) - dMtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) - dMtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - dj0temp00 = np.zeros((n_frequency, n_filter), dtype=complex) - dj0temp10 = np.zeros((n_frequency, n_filter), dtype=complex) - dj0temp01 = np.zeros((n_frequency, n_filter), dtype=complex) - dj0temp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - dj1temp00 = np.zeros((n_frequency, n_filter), dtype=complex) - dj1temp10 = np.zeros((n_frequency, n_filter), dtype=complex) - dj1temp01 = np.zeros((n_frequency, n_filter), dtype=complex) - dj1temp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - thick = -np.diff(depth) - w = 2*np.pi*f - - rTE = np.zeros((n_frequency, n_filter), dtype=complex) - drTE = np.zeros((n_layer, n_frequency, n_filter), dtype=complex) - utemp0 = np.zeros((n_frequency, n_filter), dtype=complex) - utemp1 = np.zeros((n_frequency, n_filter), dtype=complex) - const = np.zeros((n_frequency, n_filter), dtype=complex) - - utemp0 = lamda - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0, :, :]) - const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) - - # Compute M1 - Mtemp00 = 0.5*(1+const) - Mtemp10 = 0.5*(1-const) - Mtemp01 = 0.5*(1-const) - Mtemp11 = 0.5*(1+const) - - utemp0 = lamda - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0, :, :]) - const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) - - # Compute dM1du1 - dj0Mtemp00 = 0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - dj0Mtemp10 = -0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - dj0Mtemp01 = -0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - dj0Mtemp11 = 0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) - - # TODO: for computing Jacobian - M00 = [] - M10 = [] - M01 = [] - M11 = [] - - dJ00 = [] - dJ10 = [] - dJ01 = [] - dJ11 = [] - - M00.append(Mtemp00) - M01.append(Mtemp01) - M10.append(Mtemp10) - M11.append(Mtemp11) - - M0sum00 = Mtemp00.copy() - M0sum10 = Mtemp10.copy() - M0sum01 = Mtemp01.copy() - M0sum11 = Mtemp11.copy() - - if HalfSwitch or n_layer == 1: - - M1sum00 = M0sum00.copy() - M1sum10 = M0sum10.copy() - M1sum01 = M0sum01.copy() - M1sum11 = M0sum11.copy() - - else: - - for j in range(n_layer-1): - - dJ_10Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ_10Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ_10Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ_10Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - dJ01Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ01Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ01Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ01Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) - - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j])*sig[j, :, :]) - utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j+1])*sig[j+1, :, :]) - const = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0) - - h0 = thick[j] - - Mtemp00 = 0.5*(1.+ const)*np.exp(-2.*utemp0*h0) - Mtemp10 = 0.5*(1.- const) - Mtemp01 = 0.5*(1.- const)*np.exp(-2.*utemp0*h0) - Mtemp11 = 0.5*(1.+ const) - - M1sum00, M1sum10, M1sum01, M1sum11 = matmul( - M0sum00, M0sum10, M0sum01, M0sum11, - Mtemp00, Mtemp10, Mtemp01, Mtemp11 - ) - - M0sum00 = M1sum00 - M0sum10 = M1sum10 - M0sum01 = M1sum01 - M0sum11 = M1sum11 - - # TODO: for Computing Jacobian - - dudsig = 0.5*1j*w*mu_0*(1+chi[j])/utemp0 - - if j == 0: - - const1a = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0**2) - const1b = const1a*utemp0 - - dj1Mtemp00 = -0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1+const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp10 = 0.5*const1a - dj1Mtemp01 = 0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1-const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp11 = -0.5*const1a - - # Compute dM1dm1*M2 - dJ_10Mtemp00, dJ_10Mtemp10, dJ_10Mtemp01, dJ_10Mtemp11 = matmul( - dj0Mtemp00, dj0Mtemp10, dj0Mtemp01, dj0Mtemp11, - Mtemp00, Mtemp10, Mtemp01, Mtemp11 - ) - - # Compute M1*dM2dm1 - dJ01Mtemp00, dJ01Mtemp10, dJ01Mtemp01, dJ01Mtemp11 = matmul( - M00[j], M10[j], M01[j], M11[j], dj1Mtemp00, - dj1Mtemp10, dj1Mtemp01, dj1Mtemp11 - ) - - dJ00.append(dudsig*(dJ_10Mtemp00+dJ01Mtemp00)) - dJ10.append(dudsig*(dJ_10Mtemp10+dJ01Mtemp10)) - dJ01.append(dudsig*(dJ_10Mtemp01+dJ01Mtemp01)) - dJ11.append(dudsig*(dJ_10Mtemp11+dJ01Mtemp11)) - - else: - - h_1 = thick[j-1] - utemp_1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j-1])*sig[j-1]) - const0 = mu_0*(1+chi[j-1])/(mu_0*(1+chi[j])*utemp_1) - - dj0Mtemp00 = 0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp10 = -0.5*(const0) - dj0Mtemp01 = -0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp11 = 0.5*(const0) - - const1a = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0**2) - const1b = const1a*utemp0 - - dj1Mtemp00 = -0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1+const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp10 = 0.5*const1a - dj1Mtemp01 = 0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1-const1b)*np.exp(-2.*utemp0*h0) - dj1Mtemp11 = -0.5*const1a - - # Compute dMjdmj*Mj+1 - dJ_10Mtemp00, dJ_10Mtemp10, dJ_10Mtemp01, dJ_10Mtemp11 = matmul( - dj0Mtemp00, dj0Mtemp10, dj0Mtemp01, dj0Mtemp11, - Mtemp00, Mtemp10, Mtemp01, Mtemp11 - ) - - # Compute Mj*dMj+1dmj - dJ01Mtemp00, dJ01Mtemp10, dJ01Mtemp01, dJ01Mtemp11 = matmul( - M00[j], M10[j], M01[j], M11[j], - dj1Mtemp00, dj1Mtemp10, dj1Mtemp01, dj1Mtemp11 - ) - - dJ00.append(dudsig*(dJ_10Mtemp00+dJ01Mtemp00)) - dJ10.append(dudsig*(dJ_10Mtemp10+dJ01Mtemp10)) - dJ01.append(dudsig*(dJ_10Mtemp01+dJ01Mtemp01)) - dJ11.append(dudsig*(dJ_10Mtemp11+dJ01Mtemp11)) - - M00.append(Mtemp00) - M01.append(Mtemp01) - M10.append(Mtemp10) - M11.append(Mtemp11) - - # rTE = M1sum01/M1sum11 - - if HalfSwitch or n_layer == 1: - - utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0]) - dudsig = 0.5*1j*w*mu_0*(1+chi[0])/utemp0 - - dJ1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - dJ1sum00 = dudsig*dj0Mtemp00 - dJ1sum10 = dudsig*dj0Mtemp10 - dJ1sum01 = dudsig*dj0Mtemp01 - dJ1sum11 = dudsig*dj0Mtemp11 - - drTE = dJ1sum01/M1sum11 - M1sum01/(M1sum11**2)*dJ1sum11 - - else: - - # j = n_layer - utemp0 = ( - np.sqrt(lamda**2+1j*w*mu_0*(1+chi[n_layer-1])*sig[n_layer-1, :, :]) - ) - dudsig = 0.5*1j*w*mu_0*(1+chi[n_layer-1])/utemp0 - - h_1 = thick[n_layer-2] - - utemp_1 = ( - np.sqrt(lamda**2+1j*w*mu_0*(1+chi[n_layer-2])*sig[n_layer-2, :, :]) - ) - const0 = mu_0*(1+chi[n_layer-2])/(mu_0*(1+chi[n_layer-1])*utemp_1) - - dj0Mtemp00 = 0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp10 = -0.5*(const0) - dj0Mtemp01 = -0.5*(const0)*np.exp(-2.*utemp_1*h_1) - dj0Mtemp11 = 0.5*(const0) - - dJ_10Mtemp00 = dj0Mtemp00 - dJ_10Mtemp10 = dj0Mtemp10 - dJ_10Mtemp01 = dj0Mtemp01 - dJ_10Mtemp11 = dj0Mtemp11 - - dJ00.append(dudsig*dJ_10Mtemp00) - dJ10.append(dudsig*dJ_10Mtemp10) - dJ01.append(dudsig*dJ_10Mtemp01) - dJ11.append(dudsig*dJ_10Mtemp11) - - for i in range(n_layer): - - dJ0sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ0sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ0sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ0sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - dJ1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) - dJ1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) - - if i == 0: - - for j in range(n_layer-2): - - if j == 0: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ00[i], dJ10[i], dJ01[i], dJ11[i], - M00[j+2], M10[j+2], M01[j+2], M11[j+2] - ) - - else: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, - M00[j+2], M10[j+2], M01[j+2], M11[j+2] - ) - - dJ0sum00 = dJ1sum00 - dJ0sum10 = dJ1sum10 - dJ0sum01 = dJ1sum01 - dJ0sum11 = dJ1sum11 - - elif (i > 0) & (i < n_layer-1): - - dJ0sum00 = M00[0] - dJ0sum10 = M10[0] - dJ0sum01 = M01[0] - dJ0sum11 = M11[0] - - for j in range (n_layer-2): - - if j==i-1: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, - dJ00[i], dJ10[i], dJ01[i], dJ11[i] - ) - - elif j < i-1: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, - M00[j+1], M10[j+1], M01[j+1], M11[j+1] - ) - - elif j > i-1: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, - M00[j+2], M10[j+2], M01[j+2], M11[j+2] - ) - - dJ0sum00 = dJ1sum00 - dJ0sum10 = dJ1sum10 - dJ0sum01 = dJ1sum01 - dJ0sum11 = dJ1sum11 - - elif i == n_layer-1: - - dJ0sum00 = M00[0] - dJ0sum10 = M10[0] - dJ0sum01 = M01[0] - dJ0sum11 = M11[0] - - for j in range(n_layer-1): - - if j < n_layer-2: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, - M00[j+1], M10[j+1], M01[j+1], M11[j+1] - ) - - elif j == n_layer-2: - - dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( - dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, - dJ00[i], dJ10[i], dJ01[i], dJ11[i] - ) - - dJ0sum00 = dJ1sum00 - dJ0sum10 = dJ1sum10 - dJ0sum01 = dJ1sum01 - dJ0sum11 = dJ1sum11 - - drTE[i, :] = dJ1sum01/M1sum11 - M1sum01/(M1sum11**2)*dJ1sum11 - - return drTE - # Still worthwhile to output both? - # return rTE, drTE - diff --git a/simpegEM1D/Survey.py b/simpegEM1D/Survey.py deleted file mode 100644 index 6856c06..0000000 --- a/simpegEM1D/Survey.py +++ /dev/null @@ -1,547 +0,0 @@ -from SimPEG import Maps, Survey, Utils -import numpy as np -import scipy.sparse as sp -from scipy.constants import mu_0 -from .EM1DAnalytics import ColeCole -from .DigFilter import ( - transFilt, transFiltImpulse, transFiltInterp, transFiltImpulseInterp -) -from .Waveform import CausalConv -from scipy.interpolate import interp1d -from scipy.interpolate import InterpolatedUnivariateSpline as iuSpline -import properties -from empymod import filters -from empymod.utils import check_time -from empymod.transform import fourier_dlf -from .Waveforms import ( - piecewise_pulse_fast, - butterworth_type_filter, butter_lowpass_filter -) - - -class BaseEM1DSurvey(Survey.BaseSurvey, properties.HasProperties): - """ - Base EM1D Survey - - """ - - frequency = properties.Array("Frequency (Hz)", dtype=float) - - rx_location = properties.Array("Receiver location (x, y, z)", dtype=float) - src_location = properties.Array("Source location (x, y, z)", dtype=float) - - src_path = properties.Array( - "Source path (xi, yi, zi), i=0,...N", - dtype=float - ) - - src_type = properties.StringChoice( - "Source type", - default="VMD", - choices=[ - "VMD", "CircularLoop", "piecewise_segment" - ] - ) - offset = properties.Array("Src-Rx offsets", dtype=float) - rx_type = properties.StringChoice( - "Source location", - default="Hz", - choices=["Hz", "ppm", "Bz", "dBzdt"] - ) - field_type = properties.StringChoice( - "Field type", - default="secondary", - choices=["total", "secondary"] - ) - depth = properties.Array("Depth of the layers", dtype=float) - topo = properties.Array("Topography (x, y, z)", dtype=float) - I = properties.Float("Src loop current", default=1.) - a = properties.Float("Src loop radius", default=1.) - half_switch = properties.Bool("Switch for half-space", default=False) - - def __init__(self, **kwargs): - Survey.BaseSurvey.__init__(self, **kwargs) - - @property - def h(self): - """ - Source height - """ - return self.src_location[2]-self.topo[2] - - @property - def z(self): - """ - Receiver height - """ - return self.rx_location[2]-self.topo[2] - - @property - def dz(self): - """ - Source height - Rx height - """ - return self.z - self.h - - @property - def n_layer(self): - """ - Srource height - """ - if self.half_switch is False: - return self.depth.size - elif self.half_switch is True: - return int(1) - - @property - def n_frequency(self): - """ - # of frequency - """ - - return int(self.frequency.size) - - @property - def src_paths_on_x(self): - """ - # of frequency - """ - if getattr(self, '_src_paths_on_x', None) is None: - offset = np.unique(self.offset) - if offset.size != 1: - raise Exception( - "For the sourth paths, only single offset works!" - ) - xy_rot, xy_obs_rot, angle = rotate_to_x_axis( - np.flipud(xy), np.r_[offset, 0.] - ) - - return self._src_paths - - @Utils.requires('prob') - def dpred(self, m, f=None): - """ - Computes predicted data. - Here we do not store predicted data - because projection (`d = P(f)`) is cheap. - """ - - if f is None: - f = self.prob.fields(m) - return Utils.mkvc(self.projectFields(f)) - - -class EM1DSurveyFD(BaseEM1DSurvey): - """ - Freqency-domain EM1D survey - """ - # Nfreq = None - switch_real_imag = properties.StringChoice( - "Switch for real and imaginary part of the data", - default="all", - choices=["all", "real", "imag"] - ) - - def __init__(self, **kwargs): - BaseEM1DSurvey.__init__(self, **kwargs) - - if self.src_type == "VMD": - if self.offset is None: - raise Exception("offset is required!") - - if self.offset.size == 1: - self.offset = self.offset * np.ones(self.n_frequency) - - @property - def nD(self): - """ - # of data - """ - - if self.switch_real_imag == "all": - return int(self.frequency.size * 2) - elif ( - self.switch_real_imag == "imag" or self.switch_real_imag == "real" - ): - return int(self.n_frequency) - - @property - def hz_primary(self): - # Assumes HCP only at the moment - if self.src_type == 'VMD': - return -1./(4*np.pi*self.offset**3) - elif self.src_type == 'CircularLoop': - return self.I/(2*self.a) * np.ones_like(self.frequency) - else: - raise NotImplementedError() - - def projectFields(self, u): - """ - Decompose frequency domain EM responses as real and imaginary - components - """ - - ureal = (u.real).copy() - uimag = (u.imag).copy() - - if self.rx_type == 'Hz': - factor = 1. - elif self.rx_type == 'ppm': - factor = 1./self.hz_primary * 1e6 - - if self.switch_real_imag == 'all': - ureal = (u.real).copy() - uimag = (u.imag).copy() - if ureal.ndim == 1 or 0: - resp = np.r_[ureal*factor, uimag*factor] - elif ureal.ndim == 2: - if np.isscalar(factor): - resp = np.vstack( - (factor*ureal, factor*uimag) - ) - else: - resp = np.vstack( - (Utils.sdiag(factor)*ureal, Utils.sdiag(factor)*uimag) - ) - else: - raise NotImplementedError() - elif self.switch_real_imag == 'real': - resp = (u.real).copy() - elif self.switch_real_imag == 'imag': - resp = (u.imag).copy() - else: - raise NotImplementedError() - - return resp - - -class EM1DSurveyTD(BaseEM1DSurvey): - """docstring for EM1DSurveyTD""" - - time = properties.Array( - "Time channels (s) at current off-time", dtype=float - ) - - wave_type = properties.StringChoice( - "Source location", - default="stepoff", - choices=["stepoff", "general"] - ) - - moment_type = properties.StringChoice( - "Source moment type", - default="single", - choices=["single", "dual"] - ) - - n_pulse = properties.Integer( - "The number of pulses", - ) - - base_frequency = properties.Float( - "Base frequency (Hz)" - ) - - time_input_currents = properties.Array( - "Time for input currents", dtype=float - ) - - input_currents = properties.Array( - "Input currents", dtype=float - ) - - use_lowpass_filter = properties.Bool( - "Switch for low pass filter", default=False - ) - - high_cut_frequency = properties.Float( - "High cut frequency for low pass filter (Hz)", - default=210*1e3 - ) - - # Predicted data - _pred = None - - # ------------- For dual moment ------------- # - - time_dual_moment = properties.Array( - "Off-time channels (s) for the dual moment", dtype=float - ) - - time_input_currents_dual_moment = properties.Array( - "Time for input currents (dual moment)", dtype=float - ) - - input_currents_dual_moment = properties.Array( - "Input currents (dual moment)", dtype=float - ) - - base_frequency_dual_moment = properties.Float( - "Base frequency for the dual moment (Hz)" - ) - - def __init__(self, **kwargs): - BaseEM1DSurvey.__init__(self, **kwargs) - if self.time is None: - raise Exception("time is required!") - - # Use Sin filter for frequency to time transform - self.fftfilt = filters.key_81_CosSin_2009() - self.set_frequency() - - if self.src_type == "VMD": - if self.offset is None: - raise Exception("offset is required!") - - if self.offset.size == 1: - self.offset = self.offset * np.ones(self.n_frequency) - - @property - def time_int(self): - """ - Time channels (s) for interpolation" - """ - if getattr(self, '_time_int', None) is None: - - if self.moment_type == "single": - time = self.time - pulse_period = self.pulse_period - period = self.period - # Dual moment - else: - time = np.unique(np.r_[self.time, self.time_dual_moment]) - pulse_period = np.maximum( - self.pulse_period, self.pulse_period_dual_moment - ) - period = np.maximum(self.period, self.period_dual_moment) - tmin = time[time>0.].min() - if self.n_pulse == 1: - tmax = time.max() + pulse_period - elif self.n_pulse == 2: - tmax = time.max() + pulse_period + period/2. - else: - raise NotImplementedError("n_pulse must be either 1 or 2") - n_time = int((np.log10(tmax)-np.log10(tmin))*10+1) - self._time_int = np.logspace( - np.log10(tmin), np.log10(tmax), n_time - ) - # print (tmin, tmax) - - return self._time_int - - @property - def n_time(self): - return int(self.time.size) - - @property - def period(self): - return 1./self.base_frequency - - @property - def pulse_period(self): - Tp = ( - self.time_input_currents.max() - - self.time_input_currents.min() - ) - return Tp - - # ------------- For dual moment ------------- # - @property - def n_time_dual_moment(self): - return int(self.time_dual_moment.size) - - @property - def period_dual_moment(self): - return 1./self.base_frequency_dual_moment - - @property - def pulse_period_dual_moment(self): - Tp = ( - self.time_input_currents_dual_moment.max() - - self.time_input_currents_dual_moment.min() - ) - return Tp - - @property - def nD(self): - """ - # of data - """ - if self.moment_type == "single": - return self.n_time - else: - return self.n_time + self.n_time_dual_moment - - @property - def lowpass_filter(self): - """ - Low pass filter values - """ - if getattr(self, '_lowpass_filter', None) is None: - # self._lowpass_filter = butterworth_type_filter( - # self.frequency, self.high_cut_frequency - # ) - - self._lowpass_filter = (1+1j*(self.frequency/self.high_cut_frequency))**-1 - self._lowpass_filter *= (1+1j*(self.frequency/3e5))**-0.99 - # For actual butterworth filter - - # filter_frequency, values = butter_lowpass_filter( - # self.high_cut_frequency - # ) - # lowpass_func = interp1d( - # filter_frequency, values, fill_value='extrapolate' - # ) - # self._lowpass_filter = lowpass_func(self.frequency) - - return self._lowpass_filter - - def set_frequency(self, pts_per_dec=-1): - """ - Compute Frequency reqired for frequency to time transform - """ - if self.wave_type == "general": - _, frequency, ft, ftarg = check_time( - self.time_int, -1, 'dlf', - {'pts_per_dec': pts_per_dec, 'dlf': self.fftfilt}, 0 - ) - elif self.wave_type == "stepoff": - _, frequency, ft, ftarg = check_time( - self.time, -1, 'dlf', - {'pts_per_dec': pts_per_dec, 'dlf': self.fftfilt}, 0, - ) - else: - raise Exception("wave_type must be either general or stepoff") - - self.frequency = frequency - self.ftarg = ftarg - - def projectFields(self, u): - """ - Transform frequency domain responses to time domain responses - """ - # Compute frequency domain reponses right at filter coefficient values - # Src waveform: Step-off - - if self.use_lowpass_filter: - factor = self.lowpass_filter.copy() - else: - factor = np.ones_like(self.frequency, dtype=complex) - - if self.rx_type == 'Bz': - factor *= 1./(2j*np.pi*self.frequency) - - if self.wave_type == 'stepoff': - # Compute EM responses - if u.size == self.n_frequency: - resp, _ = fourier_dlf( - u.flatten()*factor, self.time, - self.frequency, self.ftarg - ) - # Compute EM sensitivities - else: - resp = np.zeros( - (self.n_time, self.n_layer), dtype=np.float64, order='F') - # ) - # TODO: remove for loop - for i in range(self.n_layer): - resp_i, _ = fourier_dlf( - u[:, i]*factor, self.time, - self.frequency, self.ftarg - ) - resp[:, i] = resp_i - - # Evaluate piecewise linear input current waveforms - # Using Fittermann's approach (19XX) with Gaussian Quadrature - elif self.wave_type == 'general': - # Compute EM responses - if u.size == self.n_frequency: - resp_int, _ = fourier_dlf( - u.flatten()*factor, self.time_int, - self.frequency, self.ftarg - ) - # step_func = interp1d( - # self.time_int, resp_int - # ) - step_func = iuSpline( - np.log10(self.time_int), resp_int - ) - - resp = piecewise_pulse_fast( - step_func, self.time, - self.time_input_currents, self.input_currents, - self.period, n_pulse=self.n_pulse - ) - - # Compute response for the dual moment - if self.moment_type == "dual": - resp_dual_moment = piecewise_pulse_fast( - step_func, self.time_dual_moment, - self.time_input_currents_dual_moment, - self.input_currents_dual_moment, - self.period_dual_moment, - n_pulse=self.n_pulse - ) - # concatenate dual moment response - # so, ordering is the first moment data - # then the second moment data. - resp = np.r_[resp, resp_dual_moment] - - # Compute EM sensitivities - else: - if self.moment_type == "single": - resp = np.zeros( - (self.n_time, self.n_layer), - dtype=np.float64, order='F' - ) - else: - # For dual moment - resp = np.zeros( - (self.n_time+self.n_time_dual_moment, self.n_layer), - dtype=np.float64, order='F') - - # TODO: remove for loop (?) - for i in range(self.n_layer): - resp_int_i, _ = fourier_dlf( - u[:, i]*factor, self.time_int, - self.frequency, self.ftarg - ) - # step_func = interp1d( - # self.time_int, resp_int_i - # ) - - step_func = iuSpline( - np.log10(self.time_int), resp_int_i - ) - - resp_i = piecewise_pulse_fast( - step_func, self.time, - self.time_input_currents, self.input_currents, - self.period, n_pulse=self.n_pulse - ) - - if self.moment_type == "single": - resp[:, i] = resp_i - else: - resp_dual_moment_i = piecewise_pulse_fast( - step_func, - self.time_dual_moment, - self.time_input_currents_dual_moment, - self.input_currents_dual_moment, - self.period_dual_moment, - n_pulse=self.n_pulse - ) - resp[:, i] = np.r_[resp_i, resp_dual_moment_i] - return resp * (-2.0/np.pi) * mu_0 - - @Utils.requires('prob') - def dpred(self, m, f=None): - """ - Computes predicted data. - Predicted data (`_pred`) are computed and stored - when self.prob.fields(m) is called. - """ - if f is None: - f = self.prob.fields(m) - - return self._pred diff --git a/simpegEM1D/__init__.py b/simpegEM1D/__init__.py index dbeac4f..208405f 100644 --- a/simpegEM1D/__init__.py +++ b/simpegEM1D/__init__.py @@ -1,33 +1,50 @@ -from .EM1D import EM1D -from .Survey import BaseEM1DSurvey, EM1DSurveyFD, EM1DSurveyTD -from .DigFilter import * -from .EM1DAnalytics import * -from .RTEfun import rTEfunfwd, rTEfunjac -from .Waveform import * -from .Waveforms import ( +# Surveys +from .survey import BaseEM1DSurvey, EM1DSurveyFD, EM1DSurveyTD + +# Sources and receivers +from . import sources +from . import receivers + +# Simulations +from .simulation import ( + BaseEM1DSimulation, EM1DFMSimulation, EM1DTMSimulation, + BaseStitchedEM1DSimulation, StitchedEM1DFMSimulation, StitchedEM1DTMSimulation +) + +# Other +from .analytics import * +from .waveforms import * +from . import utils +from . import supporting_functions + +# from .sources import ( +# HarmonicMagneticDipoleSource, HarmonicHorizontalLoopSource, HarmonicLineSource, +# TimeDomainMagneticDipoleSource, TimeDomainHorizontalLoopSource, TimeDomainLineSource +# ) +# from .receivers import HarmonicPointReceiver, TimeDomainPointReceiver +# from .RTEfun import rTEfunfwd, rTEfunjac + +from .known_waveforms import ( skytem_HM_2015, skytem_LM_2015, butter_lowpass_filter, butterworth_type_filter, piecewise_pulse, get_geotem_wave, get_nanotem_wave, get_flight_direction_from_fiducial, get_rx_locations_from_flight_direction ) -from .KnownSystems import( +from .known_systems import( vtem_plus, skytem_hm, skytem_lm, geotem, tempest ) -from .Utils1D import * -from .GlobalEM1D import ( - GlobalEM1DProblemFD, GlobalEM1DSurveyFD, - GlobalEM1DProblemTD, GlobalEM1DSurveyTD -) -from .EM1DSimulation import ( - get_vertical_discretization_frequency, - get_vertical_discretization_time, - set_mesh_1d, run_simulation_FD, run_simulation_TD -) -from .Regularization import ( + + +# from .EM1DSimulation import ( +# get_vertical_discretization_frequency, +# get_vertical_discretization_time, +# set_mesh_1d, run_simulation_FD, run_simulation_TD +# ) +from .regularization import ( LateralConstraint, get_2d_mesh ) from .IO import ModelIO diff --git a/simpegEM1D/EM1DAnalytics.py b/simpegEM1D/analytics.py similarity index 51% rename from simpegEM1D/EM1DAnalytics.py rename to simpegEM1D/analytics.py index 318d385..1ec6734 100644 --- a/simpegEM1D/EM1DAnalytics.py +++ b/simpegEM1D/analytics.py @@ -1,12 +1,90 @@ import numpy as np -from SimPEG import Utils +from SimPEG import utils from scipy.constants import mu_0, pi -from scipy.special import erf +import scipy.special as spec import matplotlib.pyplot as plt -from .DigFilter import transFiltImpulse, transFilt, setFrequency +from .supporting_functions.digital_filter import transFiltImpulse, transFilt, setFrequency -def Hzanal(sig, f, r, flag): +############################################################# +# PHYSICAL PROPERTIES +############################################################# + +def ColeCole(f, sig_inf=1e-2, eta=0.1, tau=0.1, c=1): + """ + Computing Cole-Cole model in frequency domain + + .. math :: + \\sigma (\\omega ) = \\sigma_{\\infty} \\Bigg [ + 1 - \\eta \\Bigg ( \\frac{1}{1 + (1-\\eta ) (1 + i\\omega \\tau)^c} \\Bigg ) + \\Bigg ] + + + """ + + if np.isscalar(sig_inf): + w = 2*np.pi*f + sigma = sig_inf - sig_inf*eta/(1+(1-eta)*(1j*w*tau)**c) + else: + sigma = np.zeros((f.size,sig_inf.size), dtype=complex) + for i in range(f.size): + w = 2*np.pi*f[i] + sigma[i,:] = utils.mkvc(sig_inf - sig_inf*eta/(1+(1-eta)*(1j*w*tau)**c)) + return sigma + + +def LogUniform(f, chi_inf=0.05, del_chi=0.05, tau1=1e-5, tau2=1e-2): + """ + Computing relaxation model in the frequency domain for a log-uniform + distribution of time-relaxation constants. + + .. math:: + \\chi (\\omega ) = \\chi_{\\infty} + \\Delta \\chi \\Bigg [ + 1 - \\Bigg ( \\frac{1}{ln (\\tau_2 / \\tau_1 )} \\Bigg ) + ln \\Bigg ( \\frac{1 + i\\omega \\tau_2}{1 + i\\omega tau_1} ) \\Bigg ) + \\Bigg ] + + + """ + + w = 2*np.pi*f + return chi_inf + del_chi*(1 - np.log((1 + 1j*w*tau2)/(1 + 1j*w*tau1))/np.log(tau2/tau1)) + + + +def diffusion_distance(t, sigma): + """ + Compute diffusion distance + + .. math:: + + d = \sqrt{\\frac{2t}{\mu_0\sigma}} + + assume \\\\(\\\\ \mu = \mu_0\\\\) is chargeability + """ + + return np.sqrt(2*t/mu_0/sigma) + + +def skin_depth(f, sigma): + """ + Compute skin depth + + .. math:: + + \delta = \sqrt{\\frac{2}{\omega\mu_0\sigma}} + + where \\\\(\\\\ \omega = 2\pi f \\\\) is chargeability + """ + + return np.sqrt(2/mu_0/sigma/f/(2*pi)) + + +############################################################# +# VMD SOURCE SOLUTIONS +############################################################# + +def Hz_vertical_magnetic_dipole(f, r, sig, flag="secondary"): """ @@ -28,17 +106,118 @@ def Hzanal(sig, f, r, flag): """ + mu0 = 4*np.pi*1e-7 w = 2*np.pi*f k = np.sqrt(-1j*w*mu0*sig) Hz = 1./(2*np.pi*k**2*r**5)*(9-(9+9*1j*k*r-4*k**2*r**2-1j*k**3*r**3)*np.exp(-1j*k*r)) + if flag == 'secondary': Hzp = -1/(4*np.pi*r**3) Hz = Hz-Hzp return Hz -def HzanalCirc(sig, f, I, a, flag): +def Hr_vertical_magnetic_dipole(f, r, sig): + + """ + + Hz component of analytic solution for half-space (VMD source) + Src and Rx are on the surface + + .. math:: + + H_z = \\frac{-mk^2}{4\pi \\rho} \ + \\Bigg [ I_1 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) K_1 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) + - I_2 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) K_2 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) \\Bigg ] + + * r: Src-Rx offset + * m: magnetic dipole moment + * k: propagation constant + * :math:`I_n`: modified Bessel function of the 1st kind of order *n* + * :math:`K_n`: modified Bessel function of the 2nd kind of order *n* + + .. math:: + + k = \omega^2\epsilon\mu - \imath\omega\mu\sigma \\ + + + """ + + mu0 = 4*np.pi*1e-7 + w = 2*np.pi*f + k = np.sqrt(-1j*w*mu0*sig) + alpha = 1j*k*r/2. + + IK1 = spec.iv(1, alpha)*spec.kv(1, alpha) + IK2 = spec.iv(2, alpha)*spec.kv(2, alpha) + + Hr = (-k**2/(4*np.pi*r))*(IK1 - IK2) + + return Hr + + + + +def Hz_horizontal_magnetic_dipole(f, r, x, sig): + + """ + + Hz component of analytic solution for half-space (HMD source) + Src and Rx are on the surface + + .. math:: + + H_z = \\frac{mxk^2}{4\pi \\rho^2} \ + \\Bigg [ I_1 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) K_1 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) + - I_2 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) K_2 \\Bigg ( \\frac{\i k \\rho }{2} \\Bigg ) \\Bigg ] + + * x: Src-Rx x offset + * r: Src-Rx offset + * m: magnetic dipole moment + * k: propagation constant + * :math:`I_n`: modified Bessel function of the 1st kind of order *n* + * :math:`K_n`: modified Bessel function of the 2nd kind of order *n* + + .. math:: + + k = \omega^2\epsilon\mu - \imath\omega\mu\sigma \\ + + + """ + + mu0 = 4*np.pi*1e-7 + w = 2*np.pi*f + k = np.sqrt(-1j*w*mu0*sig) + alpha = 1j*k*r/2. + + IK1 = spec.iv(1, alpha)*spec.kv(1, alpha) + IK2 = spec.iv(2, alpha)*spec.kv(2, alpha) + + Hr = (x*k**2/(4*np.pi*r**2))*(IK1 - IK2) + return Hr + + + + +def Bz_vertical_magnetic_dipole(r, t, sigma): + + theta = np.sqrt((sigma*mu_0)/(4*t)) + tr = theta*r + etr = spec.erf(tr) + t1 = (9/(2*tr**2) - 1)*etr + t2 = (1/np.sqrt(pi))*(9/tr + 4*tr)*np.exp(-tr**2) + hz = (t1 - t2)/(4*pi*r**3) + return mu_0*hz + + + +############################################################# +# HORIZONTAL LOOP SOURCE SOLUTIONS +############################################################# + + +def Hz_horizontal_circular_loop(f, I, a, sig, flag="secondary"): """ @@ -54,16 +233,22 @@ def HzanalCirc(sig, f, I, a, flag): * I: Current intensity """ + mu_0 = 4*np.pi*1e-7 w = 2*np.pi*f k = np.sqrt(-1j*w*mu_0*sig) Hz = -I/(k**2*a**3)*(3-(3+3*1j*k*a-k**2*a**2)*np.exp(-1j*k*a)) + if flag == 'secondary': Hzp = I/2./a Hz = Hz-Hzp + return Hz + + + def dHzdsiganalCirc(sig, f, I, a, flag): """ @@ -84,47 +269,14 @@ def dHzdsiganalCirc(sig, f, I, a, flag): return dHzdsig -def ColeCole(f, sig_inf=1e-2, eta=0.1, tau=0.1, c=1): - """ - Computing Cole-Cole model in frequency domain - - .. math:: - - \sigma (\omega) = \sigma_{\infty} - - \\frac{\sigma_{\infty}\eta}{1+(1-\eta)(\imath\omega\\tau)^c} - where \\\\(\\\\\sigma_{\\\\infty}\\\\) is conductivity at infinte frequency, - \\\\(\\\\\eta\\\\) is chargeability, - \\\\(\\\\\\tau\\\\) is chargeability, - \\\\(\\\\ c\\\\) is chargeability. - - """ - - if np.isscalar(sig_inf): - w = 2*np.pi*f - sigma = sig_inf - sig_inf*eta/(1+(1-eta)*(1j*w*tau)**c) - else: - sigma = np.zeros((f.size,sig_inf.size), dtype=complex) - for i in range(f.size): - w = 2*np.pi*f[i] - sigma[i,:] = Utils.mkvc(sig_inf - sig_inf*eta/(1+(1-eta)*(1j*w*tau)**c)) - return sigma - -def BzAnalT(r, t, sigma): - theta = np.sqrt((sigma*mu_0)/(4*t)) - tr = theta*r - etr = erf(tr) - t1 = (9/(2*tr**2) - 1)*etr - t2 = (1/np.sqrt(pi))*(9/tr + 4*tr)*np.exp(-tr**2) - hz = (t1 - t2)/(4*pi*r**3) - return mu_0*hz -def BzAnalCircT(a, t, sigma): +def Bz_horizontal_circular_loop(a, t, sigma): """ Hz component of analytic solution for half-space (Circular-loop source) Src and Rx are on the surface and receiver is located at the center of the loop. @@ -143,14 +295,14 @@ def BzAnalCircT(a, t, sigma): theta = np.sqrt((sigma*mu_0)/(4*t)) ta = theta*a - eta = erf(ta) + eta = spec.erf(ta) t1 = (3/(np.sqrt(pi)*ta))*np.exp(-ta**2) t2 = (1 - (3/(2*ta**2)))*eta hz = (t1 + t2)/(2*a) return mu_0*hz -def dBzdtAnalCircT(a, t, sigma): +def dBzdt_horizontal_circular_loop(a, t, sigma): """ Hz component of analytic solution for half-space (Circular-loop source) Src and Rx are on the surface and receiver is located at the center of the loop. @@ -168,17 +320,17 @@ def dBzdtAnalCircT(a, t, sigma): theta = np.sqrt((sigma*mu_0)/(4*t)) const = -1/(mu_0*sigma*a**3) ta = theta*a - eta = erf(ta) + eta = spec.erf(ta) t1 = 3*eta t2 = -2/(np.pi**0.5)*ta*(3+2*ta**2)*np.exp(-ta**2) dhzdt = const*(t1+t2) return mu_0*dhzdt -def BzAnalCircTCole(a, t, sigma): +def Bz_horizontal_circular_loop_ColeCole(a, t, sigma): wt, tbase, omega_int = setFrequency(t) - hz = HzanalCirc(sigma, omega_int/2/np.pi, 1., a, 'secondary') + hz = Hz_horizontal_circular_loop(omega_int/2/np.pi, 1., a, sigma, 'secondary') # Treatment for inaccuracy in analytic solutions ind = omega_int < 0.2 hz[ind] = 0. @@ -186,10 +338,10 @@ def BzAnalCircTCole(a, t, sigma): return hzTD*mu_0 -def dBzdtAnalCircTCole(a, t, sigma): +def dBzdt_horizontal_circular_loop_ColeCole(a, t, sigma): wt, tbase, omega_int = setFrequency(t) - hz = HzanalCirc(sigma, omega_int/2/np.pi, 1., a, 'secondary') + hz = Hz_horizontal_circular_loop(omega_int/2/np.pi, 1., a, sigma, 'secondary') # Treatment for inaccuracy in analytic solutions ind = omega_int < 0.2 hz[ind] = 0. @@ -198,29 +350,18 @@ def dBzdtAnalCircTCole(a, t, sigma): return dhzdtTD*mu_0 -def diffusion_distance(t, sigma): - """ - Compute diffusion distance - - .. math:: - - d = \sqrt{\\frac{2t}{\mu_0\sigma}} - - assume \\\\(\\\\ \mu = \mu_0\\\\) is chargeability - """ - - return np.sqrt(2*t/mu_0/sigma) - +def Bz_horizontal_circular_loop_VRM(a, z, h, t, dchi, tau1, tau2): -def skin_depth(f, sigma): - """ - Compute skin depth + mu0 = 4*np.pi*1e-7 + F = - (1/np.log(tau2/tau1)) * (spec.expi(t/tau2) + spec.expi(-t/tau1)) + B0 = (0.5*mu0*a**2) * (dchi/(2 + dchi)) * ((z + h)**2 + a**2)**-1.5 + return B0*F - .. math:: - \delta = \sqrt{\\frac{2}{\omega\mu_0\sigma}} +def dBzdt_horizontal_circular_loop_VRM(a, z, h, t, dchi, tau1, tau2): - where \\\\(\\\\ \omega = 2\pi f \\\\) is chargeability - """ + mu0 = 4*np.pi*1e-7 + dFdt = (1/np.log(tau2/tau1)) * (np.exp(-t/tau1) - np.exp(-t/tau2)) / t + B0 = (0.5*mu0*a**2) * (dchi/(2 + dchi)) * ((z + h)**2 + a**2)**-1.5 + return B0*dFdt - return np.sqrt(2/mu_0/sigma/f/(2*pi)) diff --git a/simpegEM1D/dummy.py b/simpegEM1D/dummy.py deleted file mode 100644 index bd9ded3..0000000 --- a/simpegEM1D/dummy.py +++ /dev/null @@ -1,182 +0,0 @@ - - # ------------ Dummy codes for older version ------------ # - # This can be used in later use for handling on-time data. - # ------------------------------------------------------- # - - # def setWaveform(self, **kwargs): - # """ - # Set parameters for Src Waveform - # """ - # # TODO: this is hp is only valid for Circular loop system - # self.hp = self.I/self.a*0.5 - - # self.toff = kwargs['toff'] - # self.waveform = kwargs['waveform'] - # self.waveformDeriv = kwargs['waveformDeriv'] - # self.tconv = kwargs['tconv'] - - # def projectFields(self, u): - # """ - # Transform frequency domain responses to time domain responses - # """ - # # Case1: Compute frequency domain reponses right at filter coefficient values - # if self.switchInterp == False: - # # Src waveform: Step-off - # if self.wave_type == 'stepoff': - # if self.rx_type == 'Bz': - # # Compute EM responses - # if u.size == self.n_frequency: - # resp, f0 = transFilt(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.time) - # # Compute EM sensitivities - # else: - # resp = np.zeros((self.n_time, self.n_layer)) - # for i in range (self.n_layer): - # resp[:,i], f0 = transFilt(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.time) - - # elif self.rx_type == 'dBzdt': - # # Compute EM responses - # if u.size == self.n_frequency: - # resp = -transFiltImpulse(u, self.wt,self.tbase, self.frequency*2*np.pi, self.time) - # # Compute EM sensitivities - # else: - # resp = np.zeros((self.n_time, self.n_layer)) - # for i in range (self.n_layer): - # resp[:,i] = -transFiltImpulse(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.time) - - # # Src waveform: General (it can be any waveform) - # # We evaluate this with time convolution - # elif self.wave_type == 'general': - # # Compute EM responses - # if u.size == self.n_frequency: - # # TODO: write small code which compute f at t = 0 - # f, f0 = transFilt(Utils.mkvc(u), self.wt, self.tbase, self.frequency*2*np.pi, self.tconv) - # fDeriv = -transFiltImpulse(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.tconv) - - # if self.rx_type == 'Bz': - - # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) - # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - - # # TODO: make it as an opition #2 - # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) - # # resp2 = (self.waveform*self.hp) - waveDerivConvf - # # respint = interp1d(self.tconv, resp2, 'linear') - - # resp = respint(self.time) - - # if self.rx_type == 'dBzdt': - # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) - # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - # resp = respint(self.time) - - # # Compute EM sensitivities - # else: - - # resp = np.zeros((self.n_time, self.n_layer)) - # for i in range (self.n_layer): - - # f, f0 = transFilt(u[:,i], self.wt, self.tbase, self.frequency*2*np.pi, self.tconv) - # fDeriv = -transFiltImpulse(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.tconv) - - # if self.rx_type == 'Bz': - - # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) - # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - - # # TODO: make it as an opition #2 - # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) - # # resp2 = (self.waveform*self.hp) - waveDerivConvf - # # respint = interp1d(self.tconv, resp2, 'linear') - - # resp[:,i] = respint(self.time) - - # if self.rx_type == 'dBzdt': - # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) - # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - # resp[:,i] = respint(self.time) - - # # Case2: Compute frequency domain reponses in logarithmic then intepolate - # if self.switchInterp == True: - # # Src waveform: Step-off - # if self.wave_type == 'stepoff': - # if self.rx_type == 'Bz': - # # Compute EM responses - # if u.size == self.n_frequency: - # resp, f0 = transFiltInterp(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) - # # Compute EM sensitivities - # else: - # resp = np.zeros((self.n_time, self.n_layer)) - # for i in range (self.n_layer): - # resp[:,i], f0 = transFiltInterp(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) - - # elif self.rx_type == 'dBzdt': - # # Compute EM responses - # if u.size == self.n_frequency: - # resp = -transFiltImpulseInterp(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) - # # Compute EM sensitivities - # else: - # resp = np.zeros((self.n_time, self.n_layer)) - # for i in range (self.n_layer): - # resp[:,i] = -transFiltImpulseInterp(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) - - # # Src waveform: General (it can be any waveform) - # # We evaluate this with time convolution - # elif self.wave_type == 'general': - # # Compute EM responses - # if u.size == self.n_frequency: - # # TODO: write small code which compute f at t = 0 - # f, f0 = transFiltInterp(Utils.mkvc(u), self.wt, self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) - # fDeriv = -transFiltImpulseInterp(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) - - # if self.rx_type == 'Bz': - - # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) - # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - - # # TODO: make it as an opition #2 - # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) - # # resp2 = (self.waveform*self.hp) - waveDerivConvf - # # respint = interp1d(self.tconv, resp2, 'linear') - - # resp = respint(self.time) - - # if self.rx_type == 'dBzdt': - # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) - # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - # resp = respint(self.time) - - # # Compute EM sensitivities - # else: - - # resp = np.zeros((self.n_time, self.n_layer)) - # for i in range (self.n_layer): - - # f, f0 = transFiltInterp(u[:,i], self.wt, self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) - # fDeriv = -transFiltImpulseInterp(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) - - # if self.rx_type == 'Bz': - - # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) - # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - - # # TODO: make it as an opition #2 - # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) - # # resp2 = (self.waveform*self.hp) - waveDerivConvf - # # respint = interp1d(self.tconv, resp2, 'linear') - - # resp[:,i] = respint(self.time) - - # if self.rx_type == 'dBzdt': - # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) - # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv - # respint = interp1d(self.tconv, resp1, 'linear') - # resp[:,i] = respint(self.time) - - # return mu_0*resp diff --git a/simpegEM1D/KnownSystems.py b/simpegEM1D/known_systems.py similarity index 100% rename from simpegEM1D/KnownSystems.py rename to simpegEM1D/known_systems.py diff --git a/simpegEM1D/Waveforms.py b/simpegEM1D/known_waveforms.py similarity index 98% rename from simpegEM1D/Waveforms.py rename to simpegEM1D/known_waveforms.py index 4ebf353..c3efab5 100644 --- a/simpegEM1D/Waveforms.py +++ b/simpegEM1D/known_waveforms.py @@ -10,7 +10,8 @@ import numpy as np from scipy.integrate import fixed_quad -from scipy.integrate.quadrature import _cached_roots_legendre +# from scipy.integrate.quadrature import _cached_roots_legendre +from scipy.special import roots_legendre # from scipy.signal import butter, freqz @@ -401,7 +402,8 @@ def piecewise_pulse_fast( assert (n_pulse == 1 or n_pulse == 2), NotImplementedError("n_pulse must be either 1 or 2") # Get gauss-legendre points and weights early since n never changes inside here - x, w = _cached_roots_legendre(n) + # x, w = _cached_roots_legendre(n) + x, w = roots_legendre(n) if n_pulse == 1: response = piecewise_ramp_fast( diff --git a/simpegEM1D/libm_rTE_Fo.GJJ4AYK2AYSJ7CBWPHQAFWIN6WGRAIYI.gfortran-win_amd64.dll b/simpegEM1D/libm_rTE_Fo.GJJ4AYK2AYSJ7CBWPHQAFWIN6WGRAIYI.gfortran-win_amd64.dll new file mode 100644 index 0000000..d9dd09b Binary files /dev/null and b/simpegEM1D/libm_rTE_Fo.GJJ4AYK2AYSJ7CBWPHQAFWIN6WGRAIYI.gfortran-win_amd64.dll differ diff --git a/simpegEM1D/libm_rTE_Fo.SCBVWIJUD5OFZKEAKP4Z75X5N7TGU6NN.gfortran-win_amd64.dll b/simpegEM1D/libm_rTE_Fo.SCBVWIJUD5OFZKEAKP4Z75X5N7TGU6NN.gfortran-win_amd64.dll new file mode 100644 index 0000000..1b5b93e Binary files /dev/null and b/simpegEM1D/libm_rTE_Fo.SCBVWIJUD5OFZKEAKP4Z75X5N7TGU6NN.gfortran-win_amd64.dll differ diff --git a/simpegEM1D/receivers.py b/simpegEM1D/receivers.py new file mode 100644 index 0000000..33009aa --- /dev/null +++ b/simpegEM1D/receivers.py @@ -0,0 +1,167 @@ +import numpy as np +import properties +from SimPEG.survey import BaseRx, BaseTimeRx + + +class HarmonicPointReceiver(BaseRx): + """ + Receiver class for simulating the harmonic magnetic field at a point. + + :param numpy.ndarray locations: receiver locations (ie. :code:`np.r_[x,y,z]`) + :param numpy.array frequencies: frequencies [Hz] + :param string orientation: receiver orientation 'x', 'y' or 'z' + :param string component: real or imaginary component 'real' or 'imag' + :param string field_type: field type 'secondary', 'total' or 'ppm' + :param bool use_source_receiver_offset: actual receiver location (False). Source-receiver offset (True) + """ + + locations = properties.Array( + "Receiver Locations", dtype=float, shape=("*",), required=True + ) + + source_receiver_offset = properties.Array( + "Source receiver offset", dtype=float, shape=("*",), required=True + ) + + frequencies = properties.Array( + "Frequency (Hz)", dtype=float, shape=("*",), required=True + ) + + orientation = properties.StringChoice( + "Field orientation", default="z", choices=["x", "y", "z"] + ) + + component = properties.StringChoice( + # "component of the field (real or imag or both)", { + # "real": ["re", "in-phase", "in phase"], + # "imag": ["imaginary", "im", "out-of-phase", "out of phase"], + # "both": ["both"] + # } + "component of the field (real or imag or both)", + choices=["real", "imag", "both"], + default="both", + + ) + + field_type = properties.StringChoice( + "Data type", + default="secondary", + choices=["total", "secondary", "ppm"] + ) + + use_source_receiver_offset = properties.Bool( + "Use source-receiver offset", + default=False + ) + + def __init__(self, locations=None, frequencies=None, orientation=None, field_type=None, component=None, use_source_receiver_offset=None, **kwargs): + + super(HarmonicPointReceiver, self).__init__(locations, **kwargs) + if frequencies is not None: + self.frequencies = frequencies + if orientation is not None: + self.orientation = orientation + if component is not None: + self.component = component + if field_type is not None: + self.field_type = field_type + if use_source_receiver_offset is not None: + self.use_source_receiver_offset = use_source_receiver_offset + + @property + def nD(self): + """ + Number of data in the receiver. + We assume that a receiver object, only have a single location + """ + if self.component is 'both': + return int(self.frequencies.size * 2) + else: + return self.frequencies.size + + +class TimeDomainPointReceiver(BaseTimeRx): + """ + Receiver class for simulating the time-domain magnetic response at a point. + + :param numpy.ndarray locations: receiver locations (ie. :code:`np.r_[x,y,z]`) + :param numpy.array times: time channels [s] + :param string orientation: receiver orientation 'x', 'y' or 'z' + :param string component: data component 'h', 'b', 'dhdt' or 'dbdt' + :param numpy.array frequencies: frequencies used to compute harmonic response + :param numpy.array time_interval: on-times [s] + :param bool use_source_receiver_offset: actual receiver location (False). Source-receiver offset (True) + """ + + ftarg = None + + locations = properties.Array( + "Receiver Location", dtype=float, shape=("*",), required=True + ) + + # times property is inherited from BaseTimeRx class + + orientation = properties.StringChoice( + "Field orientation", default="z", choices=["x", "y", "z"] + ) + + component = properties.StringChoice( + "component of the field (h, b, dhdt, dbdt)", + default="dbdt", + choices=["h", "b", "dhdt", "dbdt"] + ) + + frequencies = properties.Array( + "Frequency (Hz)", dtype=float, shape=("*",), required=True + ) + + time_interval = properties.Array( + "Full time interval", dtype=float, shape=("*",) + ) + + use_source_receiver_offset = properties.Bool( + "Use source-receiver offset", + default=False + ) + + times_dual_moment = properties.Array( + "Off-time channels (s) for the dual moment", dtype=float + ) + + def __init__(self, locations=None, times=None, orientation=None, component=None, use_source_receiver_offset=None, **kwargs): + + super(TimeDomainPointReceiver, self).__init__(locations, times, **kwargs) + + if orientation is not None: + self.orientation = orientation + if component is not None: + self.component = component + if use_source_receiver_offset is not None: + self.use_source_receiver_offset = use_source_receiver_offset + + # Required static property + self.field_type = "secondary" + + + @property + def n_time(self): + """ + Number of time channels + """ + if self.times_dual_moment is not None: + return int(self.times.size) + int(self.times_dual_moment.size) + else: + return int(self.times.size) + + @property + def n_frequency(self): + """ + Number of frequencies + """ + return int(self.frequencies.size) + + @property + def nD(self): + """Number of data in the receiver.""" + return self.n_time + diff --git a/simpegEM1D/Regularization.py b/simpegEM1D/regularization.py similarity index 91% rename from simpegEM1D/Regularization.py rename to simpegEM1D/regularization.py index 1ce966d..7ed8fbc 100644 --- a/simpegEM1D/Regularization.py +++ b/simpegEM1D/regularization.py @@ -1,7 +1,9 @@ import scipy as sp import numpy as np -from SimPEG.regularization import Sparse, SparseSmall, SparseDeriv, Simple -from SimPEG import Mesh, Utils +from SimPEG.regularization.sparse import Sparse, SparseSmall, SparseDeriv +from SimPEG.regularization.tikhonov import Simple +from SimPEG import utils +from discretize import TensorMesh def get_2d_mesh(n_sounding, hz): @@ -13,7 +15,7 @@ def get_2d_mesh(n_sounding, hz): """ hx = np.ones(n_sounding) - return Mesh.TensorMesh([hz, hx]) + return TensorMesh([hz, hx]) class LateralConstraint(Sparse): @@ -72,8 +74,8 @@ def get_grad_horizontal( A = sp.sparse.csr_matrix((avg, (row, col)), shape=(nN, nStn)) # Kron vertically for nCz - Grad = sp.sparse.kron(D, Utils.speye(hz.size)) - Avg = sp.sparse.kron(A, Utils.speye(hz.size)) + Grad = sp.sparse.kron(D, utils.speye(hz.size)) + Avg = sp.sparse.kron(A, utils.speye(hz.size)) # Override the gradient operator in y-drection # This is because of ordering ... See def get_2d_mesh diff --git a/simpegEM1D/simulation.py b/simpegEM1D/simulation.py new file mode 100644 index 0000000..b9ded81 --- /dev/null +++ b/simpegEM1D/simulation.py @@ -0,0 +1,1631 @@ +from SimPEG import maps, utils, props +from SimPEG.simulation import BaseSimulation +import numpy as np +from .sources import * +from .survey import BaseEM1DSurvey, EM1DSurveyFD, EM1DSurveyTD +from .supporting_functions.kernels import * +from scipy import sparse as sp +from scipy.constants import mu_0 +from scipy.interpolate import InterpolatedUnivariateSpline as iuSpline +from scipy.linalg import block_diag +import properties + +from empymod.utils import check_time +from empymod import filters +from empymod.transform import dlf, fourier_dlf, get_dlf_points +from empymod.utils import check_hankel + +from .known_waveforms import ( + piecewise_pulse_fast, + butterworth_type_filter, butter_lowpass_filter +) + +try: + from multiprocessing import Pool + from sys import platform +except ImportError: + print("multiprocessing is not available") + PARALLEL = False +else: + PARALLEL = True + import multiprocessing + + +####################################################################### +# SIMULATION FOR A SINGLE SOUNDING +####################################################################### + + +class BaseEM1DSimulation(BaseSimulation): + """ + Base simulation class for simulating the EM response over a 1D layered Earth + for a single sounding. The simulation computes the fields by solving the + Hankel transform solutions from Electromagnetic Theory for Geophysical + Applications: Chapter 4 (Ward and Hohmann, 1988). + """ + + hankel_filter = 'key_101_2009' # Default: Hankel filter + hankel_pts_per_dec = None # Default: Standard DLF + verbose = False + fix_Jmatrix = False + _Jmatrix_sigma = None + _Jmatrix_height = None + _pred = None + + # Properties for electrical conductivity/resistivity + sigma, sigmaMap, sigmaDeriv = props.Invertible( + "Electrical conductivity at infinite frequency (S/m)" + ) + + rho, rhoMap, rhoDeriv = props.Invertible( + "Electrical resistivity (Ohm m)" + ) + + props.Reciprocal(sigma, rho) + + eta, etaMap, etaDeriv = props.Invertible( + "Intrinsic chargeability (V/V), 0 <= eta < 1", + default=0. + ) + + tau, tauMap, tauDeriv = props.Invertible( + "Time constant for Cole-Cole model (s)", + default=1. + ) + + c, cMap, cDeriv = props.Invertible( + "Frequency Dependency for Cole-Cole model, 0 < c < 1", + default=0.5 + ) + + # Properties for magnetic susceptibility + chi, chiMap, chiDeriv = props.Invertible( + "Magnetic susceptibility at infinite frequency (SI)", + default=0. + ) + + dchi, dchiMap, dchiDeriv = props.Invertible( + "DC magnetic susceptibility for viscous remanent magnetization contribution (SI)", + default=0. + ) + + tau1, tau1Map, tau1Deriv = props.Invertible( + "Lower bound for log-uniform distribution of time-relaxation constants for viscous remanent magnetization (s)", + default=1e-10 + ) + + tau2, tau2Map, tau2Deriv = props.Invertible( + "Upper bound for log-uniform distribution of time-relaxation constants for viscous remanent magnetization (s)", + default=10. + ) + + # Additional properties + h, hMap, hDeriv = props.Invertible( + "Receiver Height (m), h > 0", + ) + + survey = properties.Instance( + "a survey object", BaseEM1DSurvey, required=True + ) + + topo = properties.Array("Topography (x, y, z)", dtype=float) + + thicknesses, thicknessesMap, thicknessesDeriv = props.Invertible( + "layer thicknesses (m)", default=np.array([]) + ) + + def __init__(self, **kwargs): + BaseSimulation.__init__(self, **kwargs) + + # Check input arguments. If self.hankel_filter is not a valid filter, + # it will set it to the default (key_201_2009). + ht, htarg = check_hankel( + 'dlf', + { + 'dlf': self.hankel_filter, + 'pts_per_dec': 0 + }, + 1 + ) + + self.fhtfilt = htarg['dlf'] # Store filter + self.hankel_pts_per_dec = htarg['pts_per_dec'] # Store pts_per_dec + if self.verbose: + print(">> Use "+self.hankel_filter+" filter for Hankel Transform") + + + @property + def halfspace_switch(self): + """True = halfspace, False = layered Earth""" + if (self.thicknesses is None) | (len(self.thicknesses)==0): + return True + else: + return False + + @property + def n_layer(self): + """number of layers""" + if self.halfspace_switch is False: + return int(self.thicknesses.size + 1) + elif self.halfspace_switch is True: + return int(1) + + @property + def n_filter(self): + """ Length of filter """ + return self.fhtfilt.base.size + + @property + def depth(self): + """layer depths""" + if self.thicknesses is not None: + return np.r_[0., -np.cumsum(self.thicknesses)] + + + def compute_sigma_matrix(self, frequencies): + """ + Computes the complex conductivity matrix using Pelton's Cole-Cole model: + + .. math :: + \\sigma (\\omega ) = \\sigma \\Bigg [ + 1 - \\eta \\Bigg ( \\frac{1}{1 + (1-\\eta ) (1 + i\\omega \\tau)^c} \\Bigg ) + \\Bigg ] + + :param numpy.array frequencies: np.array(N,) containing frequencies + :rtype: numpy.ndarray: np.array(n_layer, n_frequency) + :return: complex conductivity matrix + + """ + n_layer = self.n_layer + n_frequency = len(frequencies) + # n_filter = self.n_filter + + sigma = np.tile(self.sigma.reshape([-1, 1]), (1, n_frequency)) + + # No IP effect + if np.all(self.eta) == 0.: + return sigma + + # IP effect + else: + + if np.isscalar(self.eta): + eta = self.eta + tau = self.tau + c = self.c + else: + eta = np.tile(self.eta.reshape([-1, 1]), (1, n_frequency)) + tau = np.tile(self.tau.reshape([-1, 1]), (1, n_frequency)) + c = np.tile(self.c.reshape([-1, 1]), (1, n_frequency)) + + w = np.tile( + 2*np.pi*frequencies, + (n_layer, 1) + ) + + sigma_complex = np.empty( + [n_layer, n_frequency], dtype=np.complex128, order='F' + ) + sigma_complex[:, :] = ( + sigma - + sigma*eta/(1+(1-eta)*(1j*w*tau)**c) + ) + + return sigma_complex + + + def compute_chi_matrix(self, frequencies): + """ + Computes the complex magnetic susceptibility matrix assuming a log-uniform + distribution of time-relaxation constants: + + .. math:: + \\chi (\\omega ) = \\chi + \\Delta \\chi \\Bigg [ + 1 - \\Bigg ( \\frac{1}{ln (\\tau_2 / \\tau_1 )} \\Bigg ) + ln \\Bigg ( \\frac{1 + i\\omega \\tau_2}{1 + i\\omega tau_1} ) \\Bigg ) + \\Bigg ] + + :param numpy.array frequencies: np.array(N,) containing frequencies + :rtype: numpy.ndarray: np.array(n_layer, n_frequency) + :return: complex magnetic susceptibility matrix + + """ + + if np.isscalar(self.chi): + chi = np.ones_like(self.sigma) * self.chi + else: + chi = self.chi + + n_layer = self.n_layer + n_frequency = len(frequencies) + # n_filter = self.n_filter + + chi = np.tile(chi.reshape([-1, 1]), (1, n_frequency)) + + # No magnetic viscosity + if np.all(self.dchi) == 0.: + + + + return chi + + # Magnetic viscosity + else: + + if np.isscalar(self.dchi): + dchi = self.dchi * np.ones_like(self.chi) + tau1 = self.tau1 * np.ones_like(self.chi) + tau2 = self.tau2 * np.ones_like(self.chi) + else: + dchi = np.tile(self.dchi.reshape([-1, 1]), (1, n_frequency)) + tau1 = np.tile(self.tau1.reshape([-1, 1]), (1, n_frequency)) + tau2 = np.tile(self.tau2.reshape([-1, 1]), (1, n_frequency)) + + w = np.tile( + 2*np.pi*frequencies, + (n_layer, 1) + ) + + chi_complex = np.empty( + [n_layer, n_frequency], dtype=np.complex128, order='F' + ) + chi_complex[:, :] = chi + dchi*( + 1 - (np.log(tau2/tau1))**-1 * np.log( + (1 + 1j*w*tau2)/(1 + 1j*w*tau1) + ) + ) + + return chi_complex + + + def compute_integral(self, m, output_type='response'): + """ + This method evaluates the Hankel transform for each source and + receiver and outputs it as a list. Used for computing response + or sensitivities. + """ + + self.model = m + n_layer = self.n_layer + n_filter = self.n_filter + + # For time-domain simulations, set frequencies for the evaluation + # of the Hankel transform. + if isinstance(self.survey, EM1DSurveyTD): + if self.frequencies_are_set is False: + self.set_frequencies() + + + # Define source height above topography by mapping or from sources and receivers. + if self.hMap is not None: + h_vector = np.array(self.h) + else: + if self.topo is None: + h_vector = np.array([src.location[2] for src in self.survey.source_list]) + else: + h_vector = np.array( + [src.location[2]-self.topo[-1] for src in self.survey.source_list] + ) + + + integral_output_list = [] + + for ii, src in enumerate(self.survey.source_list): + for jj, rx in enumerate(src.receiver_list): + + n_frequency = len(rx.frequencies) + + f = np.empty([n_frequency, n_filter], order='F') + f[:, :] = np.tile( + rx.frequencies.reshape([-1, 1]), (1, n_filter) + ) + + # Create globally, not for each receiver in the future + sig = self.compute_sigma_matrix(rx.frequencies) + chi = self.compute_chi_matrix(rx.frequencies) + + # Compute receiver height + h = h_vector[ii] + if rx.use_source_receiver_offset: + z = h + rx.locations[2] + else: + z = h + rx.locations[2] - src.location[2] + + # Hankel transform for x, y or z magnetic dipole source + if isinstance(src, HarmonicMagneticDipoleSource) | isinstance(src, TimeDomainMagneticDipoleSource): + + # Radial distance + if rx.use_source_receiver_offset: + r = rx.locations[0:2] + else: + r = rx.locations[0:2] - src.location[0:2] + + r = np.sqrt(np.sum(r**2)) + r_vec = r * np.ones(n_frequency) + + # Use function from empymod to define Hankel coefficients. + # Size of lambd is (n_frequency x n_filter) + + lambd = np.empty([n_frequency, n_filter], order='F') + lambd[:, :], _ = get_dlf_points( + self.fhtfilt, r_vec, self.hankel_pts_per_dec + ) + + # Get kernel function(s) at all lambda and frequencies + PJ = magnetic_dipole_kernel( + self, lambd, f, n_layer, sig, chi, h, z, r, src, rx, output_type + ) + + PJ = tuple(PJ) + + if output_type=="sensitivity_sigma": + r_vec = np.tile(r_vec, (n_layer, 1)) + + # Evaluate Hankel transform using digital linear filter from empymod + integral_output = dlf( + PJ, lambd, r_vec, self.fhtfilt, self.hankel_pts_per_dec, ang_fact=None, ab=33 + ) + + # Hankel transform for horizontal loop source + elif isinstance(src, HarmonicHorizontalLoopSource) | isinstance(src, TimeDomainHorizontalLoopSource): + + # radial distance (r) and loop radius (a) + if rx.use_source_receiver_offset: + r = rx.locations[0:2] + else: + r = rx.locations[0:2] - src.location[0:2] + + r_vec = np.sqrt(np.sum(r**2)) * np.ones(n_frequency) + a_vec = src.a * np.ones(n_frequency) + + # Use function from empymod to define Hankel coefficients. + # Size of lambd is (n_frequency x n_filter) + lambd = np.empty([n_frequency, n_filter], order='F') + lambd[:, :], _ = get_dlf_points( + self.fhtfilt, a_vec, self.hankel_pts_per_dec + ) + + # Get kernel function(s) at all lambda and frequencies + hz = horizontal_loop_kernel( + self, lambd, f, n_layer, sig, chi, a_vec, h, z, r, + src, rx, output_type + ) + + # kernels associated with each bessel function (j0, j1, j2) + PJ = (None, hz, None) # PJ1 + + if output_type == "sensitivity_sigma": + a_vec = np.tile(a_vec, (n_layer, 1)) + + # Evaluate Hankel transform using digital linear filter from empymod + integral_output = dlf( + PJ, lambd, a_vec, self.fhtfilt, self.hankel_pts_per_dec, ang_fact=None, ab=33 + ) + + if output_type == "sensitivity_sigma": + integral_output_list.append(integral_output.T) + else: + integral_output_list.append(integral_output) + + return integral_output_list + + + def fields(self, m): + f = self.compute_integral(m, output_type='response') + f = self.project_fields(f, output_type='response') + return np.hstack(f) + + def dpred(self, m, f=None): + """ + Computes predicted data. + Here we do not store predicted data + because projection (`d = P(f)`) is cheap. + """ + + if f is None: + if m is None: + m = self.model + f = self.fields(m) + + return f + + def getJ_height(self, m, f=None): + """ + Compute the sensitivity with respect to source height(s). + """ + + # Null if source height is not parameter of the simulation. + if self.hMap is None: + return utils.Zero() + + if self._Jmatrix_height is not None: + return self._Jmatrix_height + + else: + + if self.verbose: + print(">> Compute J height ") + + dudh = self.compute_integral(m, output_type="sensitivity_height") + self._Jmatrix_height = np.hstack(self.project_fields(dudh, output_type="sensitivity_height")) + if self.survey.nSrc == 1: + self._Jmatrix_height = np.hstack(dudh).reshape([-1, 1]) + else: + # COUNT = 0 + # dudh_by_source = [] + # for ii, src in enumerate(self.survey.source_list): + # temp = np.array([]) + # for jj, rx in enumerate(src.receiver_list): + # temp = np.r_[temp, dudh[COUNT]] + # COUNT += 1 + + # dudh_by_source.append(temp.reshape([-1, 1])) + + # self._Jmatrix_height= block_diag(*dudh_by_source) + self._Jmatrix_height= block_diag(*dudh_by_source) + return self._Jmatrix_height + + + def getJ_sigma(self, m, f=None): + """ + Compute the sensitivity with respect to static conductivity. + """ + + # Null if sigma is not parameter of the simulation. + if self.sigmaMap is None: + return utils.Zero() + + if self._Jmatrix_sigma is not None: + return self._Jmatrix_sigma + else: + + if self.verbose: + print(">> Compute J sigma") + + dudsig = self.compute_integral(m, output_type="sensitivity_sigma") + self._Jmatrix_sigma = np.vstack(self.project_fields(dudsig,output_type="sensitivity_sigma")) + if self._Jmatrix_sigma.ndim == 1: + self._Jmatrix_sigma = self._Jmatrix_sigma.reshape([-1, 1]) + return self._Jmatrix_sigma + + def getJ_eta(self, m, f=None): + """ + Compute the sensitivity with respect to static conductivity. + """ + + # Null if eta is not parameter of the simulation. + if self.etaMap is None: + return utils.Zero() + + if self._Jmatrix_eta is not None: + return self._Jmatrix_eta + else: + + if self.verbose: + print(">> Compute J eta") + + dudsig = self.compute_integral(m, output_type="sensitivity_sigma") + # Need to modify + dsigdeta = np.empty((m.size, m.size)) + self._Jmatrix_eta = np.vstack(self.project_fields(dudsig.dot(dsigdeta),output_type="sensitivity_sigma")) + if self._Jmatrix_eta.ndim == 1: + self._Jmatrix_eta = self._Jmatrix_eta.reshape([-1, 1]) + return self._Jmatrix_eta + + def getJ(self, m, f=None): + """ + Fetch Jacobian. + """ + return ( + self.getJ_sigma(m, f=f) * self.sigmaDeriv + + self.getJ_height(m, f=f) * self.hDeriv + ) + + def Jvec(self, m, v, f=None): + """ + Computing Jacobian^T multiplied by vector. + """ + + J_sigma = self.getJ_sigma(m, f=f) + J_height = self.getJ_height(m, f=f) + Jv = np.dot(J_sigma, self.sigmaMap.deriv(m, v)) + if self.hMap is not None: + Jv += np.dot(J_height, self.hMap.deriv(m, v)) + return Jv + + def Jtvec(self, m, v, f=None): + """ + Computing Jacobian^T multiplied by vector. + """ + + J_sigma = self.getJ_sigma(m, f=f) + J_height = self.getJ_height(m, f=f) + Jtv = self.sigmaDeriv.T*np.dot(J_sigma.T, v) + if self.hMap is not None: + Jtv += self.hDeriv.T*np.dot(J_height.T, v) + return Jtv + + @property + def deleteTheseOnModelUpdate(self): + toDelete = [] + if self.fix_Jmatrix is False: + if self._Jmatrix_sigma is not None: + toDelete += ['_Jmatrix_sigma'] + if self._Jmatrix_height is not None: + toDelete += ['_Jmatrix_height'] + return toDelete + + def depth_of_investigation_christiansen_2012(self, std, thres_hold=0.8): + pred = self.survey._pred.copy() + delta_d = std * np.log(abs(self.survey.dobs)) + J = self.getJ(self.model) + J_sum = abs(utils.sdiag(1/delta_d/pred) * J).sum(axis=0) + S = np.cumsum(J_sum[::-1])[::-1] + active = S-thres_hold > 0. + doi = abs(self.depth[active]).max() + return doi, active + + def get_threshold(self, uncert): + _, active = self.depth_of_investigation(uncert) + JtJdiag = self.get_JtJdiag(uncert) + delta = JtJdiag[active].min() + return delta + + def get_JtJdiag(self, uncert): + J = self.getJ(self.model) + JtJdiag = (np.power((utils.sdiag(1./uncert)*J), 2)).sum(axis=0) + return JtJdiag + + + +class EM1DFMSimulation(BaseEM1DSimulation): + """ + Simulation class for simulating the FEM response over a 1D layered Earth + for a single sounding. + """ + + def __init__(self, **kwargs): + BaseEM1DSimulation.__init__(self, **kwargs) + + + def project_fields(self, u, output_type='response'): + """ + Project from the list of Hankel transform evaluations to the data or sensitivities. + Data can be real or imaginary component of: total field, secondary field or ppm. + + :param list u: list containing Hankel transform outputs for each unique + source-receiver pair. + :rtype: list: list containing predicted data for each unique + source-receiver pair. + :return: predicted data or sensitivities by source-receiver + """ + + COUNT = 0 + for ii, src in enumerate(self.survey.source_list): + for jj, rx in enumerate(src.receiver_list): + + u_temp = u[COUNT] + + if rx.component == 'real': + u_temp = np.real(u_temp) + elif rx.component == 'imag': + u_temp = np.imag(u_temp) + elif rx.component == 'both': + u_temp_r = np.real(u_temp) + u_temp_i = np.imag(u_temp) + if output_type == 'sensitivity_sigma': + u_temp = np.vstack((u_temp_r,u_temp_i)) + else: + u_temp = np.r_[u_temp_r,u_temp_i] + else: + raise Exception() + + # Either total or ppm + if rx.field_type != "secondary": + u_primary = src.PrimaryField(rx.locations, rx.use_source_receiver_offset) + if rx.field_type == "ppm": + k = [comp == rx.orientation for comp in ["x", "y", "z"]] + u_temp = 1e6 * u_temp/u_primary[0, k] + else: + if rx.component == 'both': + if output_type == 'sensitivity_sigma': + u_temp = np.vstack((u_temp_r+u_primary,u_temp_i)) + else: + u_temp = np.r_[u_temp_r+u_primary, u_temp_i] + + else: + u_temp =+ u_primary + + u[COUNT] = u_temp + COUNT = COUNT + 1 + + return u + + +class EM1DTMSimulation(BaseEM1DSimulation): + """ + Simulation class for simulating the TEM response over a 1D layered Earth + for a single sounding. + """ + + + time_intervals_are_set = False + frequencies_are_set = False + time_filter = 'key_81_CosSin_2009' + + + def __init__(self, **kwargs): + BaseEM1DSimulation.__init__(self, **kwargs) + if self.time_filter == 'key_81_CosSin_2009': + self.fftfilt = filters.key_81_CosSin_2009() + elif self.time_filter == 'key_201_CosSin_2012': + self.fftfilt = filters.key_201_CosSin_2012() + elif self.time_filter == 'key_601_CosSin_2012': + self.fftfilt = filters.key_601_CosSin_2009() + else: + raise Exception() + + + + def set_time_intervals(self): + """ + Define time interval for all source-receiver pairs. + """ + + for src in self.survey.source_list: + if src.wave_type == "general": + for rx in src.receiver_list: + + if src.moment_type == "single": + time = rx.times + pulse_period = src.pulse_period + period = src.period + # Dual moment + else: + time = np.unique(np.r_[rx.times, rx.times_dual_moment]) + pulse_period = np.maximum( + src.pulse_period, src.pulse_period_dual_moment + ) + period = np.maximum(src.period, src.period_dual_moment) + tmin = time[time>0.].min() + if src.n_pulse == 1: + tmax = time.max() + pulse_period + elif src.n_pulse == 2: + tmax = time.max() + pulse_period + period/2. + else: + raise NotImplementedError("n_pulse must be either 1 or 2") + n_time = int((np.log10(tmax)-np.log10(tmin))*10+1) + + rx.time_interval = np.logspace( + np.log10(tmin), np.log10(tmax), n_time + ) + + self.time_intervals_are_set = True + + + def set_frequencies(self, pts_per_dec=-1): + """ + Set frequencies required for Hankel transform computation and for accurate + computation of the IFFT. + """ + + # Set range of time channels + if self.time_intervals_are_set == False: + self.set_time_intervals() + + for src in self.survey.source_list: + for rx in src.receiver_list: + + if src.wave_type == "general": + _, freq, ft, ftarg = check_time( + rx.time_interval, -1, 'dlf', + {'pts_per_dec': pts_per_dec, 'dlf': self.fftfilt}, 0 + ) + elif src.wave_type == "stepoff": + _, freq, ft, ftarg = check_time( + rx.times, -1, 'dlf', + {'pts_per_dec': pts_per_dec, 'dlf': self.fftfilt}, 0, + ) + else: + raise Exception("wave_type must be either general or stepoff") + + rx.frequencies = freq + rx.ftarg = ftarg + + self.frequencies_are_set = True + + + def project_fields(self, u, output_type=None): + """ + Project from the list of Hankel transform evaluations to the data or sensitivities. + + :param list u: list containing Hankel transform outputs for each unique + source-receiver pair. + :rtype: list: list containing predicted data for each unique + source-receiver pair. + :return: predicted data or sensitivities by source-receiver + """ + + COUNT = 0 + for ii, src in enumerate(self.survey.source_list): + for jj, rx in enumerate(src.receiver_list): + + u_temp = u[COUNT] + + # use low-pass filter + if src.use_lowpass_filter: + factor = src.lowpass_filter.copy() + else: + factor = np.ones_like(rx.frequencies, dtype=complex) + + # Multiplication factors + if rx.component in ["b", "h"]: + factor *= 1./(2j*np.pi*rx.frequencies) + + if rx.component in ["b", "dbdt"]: + factor *= mu_0 + + # For stepoff waveform + if src.wave_type == 'stepoff': + + # Compute EM responses + if u_temp.ndim == 1: + resp, _ = fourier_dlf( + u_temp.flatten()*factor, rx.times, rx.frequencies, rx.ftarg + ) + + # Compute EM sensitivities + else: + + resp = np.zeros( + (rx.n_time, self.n_layer), dtype=np.float64, order='F' + ) + # TODO: remove for loop + for i in range(0, self.n_layer): + resp_i, _ = fourier_dlf( + u_temp[:, i]*factor, rx.times, rx.frequencies, rx.ftarg + ) + resp[:, i] = resp_i + + # For general waveform. + # Evaluate piecewise linear input current waveforms + # Using Fittermann's approach (19XX) with Gaussian Quadrature + elif src.wave_type == 'general': + + # Compute EM responses + if u_temp.ndim == 1: + resp_int, _ = fourier_dlf( + u_temp.flatten()*factor, rx.time_interval, rx.frequencies, rx.ftarg + ) + # step_func = interp1d( + # self.time_int, resp_int + # ) + step_func = iuSpline( + np.log10(rx.time_interval), resp_int + ) + + resp = piecewise_pulse_fast( + step_func, rx.times, + src.time_input_currents, + src.input_currents, + src.period, + n_pulse=src.n_pulse + ) + + # Compute response for the dual moment + if src.moment_type == "dual": + resp_dual_moment = piecewise_pulse_fast( + step_func, rx.times_dual_moment, + src.time_input_currents_dual_moment, + src.input_currents_dual_moment, + src.period_dual_moment, + n_pulse=src.n_pulse + ) + # concatenate dual moment response + # so, ordering is the first moment data + # then the second moment data. + resp = np.r_[resp, resp_dual_moment] + + # Compute EM sensitivities + else: + # if src.moment_type == "single": + resp = np.zeros( + (rx.n_time, self.n_layer), dtype=np.float64, order='F' + ) + # else: + # # For dual moment + # resp = np.zeros( + # (rx.n_time, self.n_layer), + # dtype=np.float64, order='F' + # ) + + # TODO: remove for loop (?) + for i in range(self.n_layer): + resp_int_i, _ = fourier_dlf( + u_temp[:, i]*factor, rx.time_interval, rx.frequencies, rx.ftarg + ) + # step_func = interp1d( + # self.time_int, resp_int_i + # ) + + step_func = iuSpline( + np.log10(rx.time_interval), resp_int_i + ) + + resp_i = piecewise_pulse_fast( + step_func, rx.times, + src.time_input_currents, src.input_currents, + src.period, n_pulse=src.n_pulse + ) + + if src.moment_type == "single": + resp[:, i] = resp_i + else: + resp_dual_moment_i = piecewise_pulse_fast( + step_func, + rx.times_dual_moment, + src.time_input_currents_dual_moment, + src.input_currents_dual_moment, + src.period_dual_moment, + n_pulse=src.n_pulse + ) + resp[:, i] = np.r_[resp_i, resp_dual_moment_i] + + u[COUNT] = resp * (-2.0/np.pi) + COUNT = COUNT + 1 + + return u + + + +####################################################################### +# STITCHED 1D SIMULATION CLASS AND GLOBAL FUNCTIONS +####################################################################### + +def dot(args): + return np.dot(args[0], args[1]) + + +def run_simulation_FD(args): + """ + This method simulates the EM response or computes the sensitivities for + a single sounding. The method allows for parallelization of + the stitched 1D problem. + + :param src: a EM1DFM source object + :param topo: Topographic location (x, y, z) + :param np.array thicknesses: np.array(N-1,) layer thicknesses for a single sounding + :param np.array sigma: np.array(N,) layer conductivities for a single sounding + :param np.array eta: np.array(N,) intrinsic chargeabilities for a single sounding + :param np.array tau: np.array(N,) Cole-Cole time constant for a single sounding + :param np.array c: np.array(N,) Cole-Cole frequency distribution constant for a single sounding + :param np.array chi: np.array(N,) magnetic susceptibility for a single sounding + :param np.array dchi: np.array(N,) DC susceptibility for magnetic viscosity for a single sounding + :param np.array tau1: np.array(N,) lower time-relaxation constant for magnetic viscosity for a single sounding + :param np.array tau2: np.array(N,) upper time-relaxation constant for magnetic viscosity for a single sounding + :param float h: source height for a single sounding + :param string output_type: "response", "sensitivity_sigma", "sensitivity_height" + :param bool invert_height: boolean switch for inverting for source height + :return: response or sensitivities + + """ + + src, topo, thicknesses, sigma, eta, tau, c, chi, dchi, tau1, tau2, h, output_type, invert_height = args + + n_layer = len(thicknesses) + 1 + local_survey = EM1DSurveyFD([src]) + exp_map = maps.ExpMap(nP=n_layer) + + if not invert_height: + # Use Exponential Map + # This is hard-wired at the moment + + sim = EM1DFMSimulation( + survey=local_survey, thicknesses=thicknesses, + sigmaMap=exp_map, eta=eta, tau=tau, c=c, chi=chi, dchi=dchi, tau1=tau1, tau2=tau2, + topo=topo, hankel_filter='key_101_2009' + ) + + if output_type == 'sensitivity_sigma': + drespdsig = sim.getJ_sigma(np.log(sigma)) + return utils.mkvc(drespdsig * sim.sigmaDeriv) + else: + resp = sim.dpred(np.log(sigma)) + return resp + else: + + wires = maps.Wires(('sigma', n_layer), ('h', 1)) + sigma_map = exp_map * wires.sigma + + sim = EM1DFMSimulation( + survey=local_survey, thicknesses=thicknesses, + sigmaMap=sigma_map, hMap=wires.h, topo=topo, + eta=eta, tau=tau, c=c, chi=chi, dchi=dchi, tau1=tau1, tau2=tau2, + hankel_filter='key_101_2009' + ) + + m = np.r_[np.log(sigma), h] + if output_type == 'sensitivity_sigma': + drespdsig = sim.getJ_sigma(m) + return utils.mkvc(drespdsig * utils.sdiag(sigma)) + # return utils.mkvc(drespdsig) + elif output_type == 'sensitivity_height': + drespdh = sim.getJ_height(m) + return utils.mkvc(drespdh) + else: + resp = sim.dpred(m) + return resp + + +def run_simulation_TD(args): + """ + This method simulates the EM response or computes the sensitivities for + a single sounding. The method allows for parallelization of + the stitched 1D problem. + + :param src: a EM1DTM source object + :param topo: Topographic location (x, y, z) + :param np.array thicknesses: np.array(N-1,) layer thicknesses for a single sounding + :param np.array sigma: np.array(N,) layer conductivities for a single sounding + :param np.array eta: np.array(N,) intrinsic chargeabilities for a single sounding + :param np.array tau: np.array(N,) Cole-Cole time constant for a single sounding + :param np.array c: np.array(N,) Cole-Cole frequency distribution constant for a single sounding + :param np.array chi: np.array(N,) magnetic susceptibility for a single sounding + :param np.array dchi: np.array(N,) DC susceptibility for magnetic viscosity for a single sounding + :param np.array tau1: np.array(N,) lower time-relaxation constant for magnetic viscosity for a single sounding + :param np.array tau2: np.array(N,) upper time-relaxation constant for magnetic viscosity for a single sounding + :param float h: source height for a single sounding + :param string output_type: "response", "sensitivity_sigma", "sensitivity_height" + :param bool invert_height: boolean switch for inverting for source height + :return: response or sensitivities + + """ + + src, topo, thicknesses, sigma, eta, tau, c, chi, dchi, tau1, tau2, h, output_type, invert_height = args + + n_layer = len(thicknesses) + 1 + local_survey = EM1DSurveyTD([src]) + exp_map = maps.ExpMap(nP=n_layer) + + if not invert_height: + # Use Exponential Map + # This is hard-wired at the moment + sim = EM1DTMSimulation( + survey=local_survey, thicknesses=thicknesses, + sigmaMap=exp_map, eta=eta, tau=tau, c=c, chi=chi, dchi=dchi, tau1=tau1, tau2=tau2, + topo=topo, hankel_filter='key_101_2009' + ) + + if output_type == 'sensitivity_sigma': + drespdsig = sim.getJ_sigma(np.log(sigma)) + return utils.mkvc(drespdsig * sim.sigmaDeriv) + else: + resp = sim.dpred(np.log(sigma)) + return resp + else: + + wires = maps.Wires(('sigma', n_layer), ('h', 1)) + sigma_map = exp_map * wires.sigma + sim = EM1DTMSimulation( + survey=local_survey, thicknesses=thicknesses, + sigmaMap=sigma_map, hMap=wires.h, topo=topo, + eta=eta, tau=tau, c=c, chi=chi, dchi=dchi, tau1=tau1, tau2=tau2, + hankel_filter='key_101_2009' + ) + + m = np.r_[np.log(sigma), h] + if output_type == 'sensitivity_sigma': + drespdsig = sim.getJ_sigma(m) + return utils.mkvc(drespdsig * utils.sdiag(sigma)) + elif output_type == 'sensitivity_height': + drespdh = sim.getJ_height(m) + return utils.mkvc(drespdh) + else: + resp = sim.dpred(m) + return resp + + +class BaseStitchedEM1DSimulation(BaseSimulation): + """ + Base class for the stitched 1D simulation. This simulation models the EM + response for a set of 1D EM soundings. + """ + + _Jmatrix_sigma = None + _Jmatrix_height = None + run_simulation = None + n_cpu = None + parallel = False + parallel_jvec_jtvec = False + verbose = False + fix_Jmatrix = False + invert_height = None + + thicknesses, thicknessesMap, thicknessesDeriv = props.Invertible( + "thicknesses of the layers", + default=np.array([]) + ) + + sigma, sigmaMap, sigmaDeriv = props.Invertible( + "Electrical conductivity (S/m)" + ) + + h, hMap, hDeriv = props.Invertible( + "Receiver Height (m), h > 0", + ) + + eta = props.PhysicalProperty( + "Electrical chargeability (V/V), 0 <= eta < 1" + ) + + tau = props.PhysicalProperty( + "Time constant (s)" + ) + + c = props.PhysicalProperty( + "Frequency Dependency, 0 < c < 1" + ) + + chi = props.PhysicalProperty( + "Magnetic susceptibility (SI)" + ) + + dchi = props.PhysicalProperty( + "DC magnetic susceptibility attributed to magnetic viscosity (SI)" + ) + + tau1 = props.PhysicalProperty( + "Lower bound for log-uniform distribution of time-relaxation constants (s)" + ) + + tau2 = props.PhysicalProperty( + "Lower bound for log-uniform distribution of time-relaxation constants (s)" + ) + + topo = properties.Array("Topography (x, y, z)", dtype=float, shape=('*', 3)) + + survey = properties.Instance( + "a survey object", BaseEM1DSurvey, required=True + ) + + def __init__(self, **kwargs): + utils.setKwargs(self, **kwargs) + + if PARALLEL: + if self.parallel: + print(">> Use multiprocessing for parallelization") + if self.n_cpu is None: + self.n_cpu = multiprocessing.cpu_count() + print((">> n_cpu: %i") % (self.n_cpu)) + else: + print(">> Serial version is used") + else: + print(">> Serial version is used") + + if self.hMap is None: + self.invert_height = False + else: + self.invert_height = True + + # ------------- For survey ------------- # + # @property + # def dz(self): + # if self.mesh.dim==2: + # return self.mesh.dy + # elif self.mesh.dim==3: + # return self.mesh.dz + + @property + def halfspace_switch(self): + """True = halfspace, False = layered Earth""" + if (self.thicknesses is None) | (len(self.thicknesses)==0): + return True + else: + return False + + @property + def n_layer(self): + if self.thicknesses is None: + return 1 + else: + return len(self.thicknesses) + 1 + + @property + def n_sounding(self): + return len(self.survey.source_list) + + + @property + def data_index(self): + return self.survey.data_index + + + # ------------- For physical properties ------------- # + @property + def Sigma(self): + if getattr(self, '_Sigma', None) is None: + # Ordering: first z then x + self._Sigma = self.sigma.reshape((self.n_sounding, self.n_layer)) + return self._Sigma + + @property + def Eta(self): + if getattr(self, '_Eta', None) is None: + # Ordering: first z then x + if self.eta is None: + self._Eta = np.zeros( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._Eta = self.eta.reshape((self.n_sounding, self.n_layer)) + return self._Eta + + @property + def Tau(self): + if getattr(self, '_Tau', None) is None: + # Ordering: first z then x + if self.tau is None: + self._Tau = 1e-3*np.ones( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._Tau = self.tau.reshape((self.n_sounding, self.n_layer)) + return self._Tau + + @property + def C(self): + if getattr(self, '_C', None) is None: + # Ordering: first z then x + if self.c is None: + self._C = np.ones( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._C = self.c.reshape((self.n_sounding, self.n_layer)) + return self._C + + @property + def Chi(self): + if getattr(self, '_Chi', None) is None: + # Ordering: first z then x + if self.chi is None: + self._Chi = np.zeros( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._Chi = self.chi.reshape((self.n_sounding, self.n_layer)) + return self._Chi + + @property + def dChi(self): + if getattr(self, '_dChi', None) is None: + # Ordering: first z then x + if self.dchi is None: + self._dChi = np.zeros( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._dChi = self.dchi.reshape((self.n_sounding, self.n_layer)) + return self._dChi + + @property + def Tau1(self): + if getattr(self, '_Tau1', None) is None: + # Ordering: first z then x + if self.tau1 is None: + self._Tau1 = 1e-10 * np.ones( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._Tau1 = self.tau1.reshape((self.n_sounding, self.n_layer)) + return self._Tau1 + + @property + def Tau2(self): + if getattr(self, '_Tau2', None) is None: + # Ordering: first z then x + if self.tau2 is None: + self._Tau2 = 100. * np.ones( + (self.n_sounding, self.n_layer), dtype=float, order='C' + ) + else: + self._Tau2 = self.tau2.reshape((self.n_sounding, self.n_layer)) + return self._Tau2 + + @property + def JtJ_sigma(self): + return self._JtJ_sigma + + def JtJ_height(self): + return self._JtJ_height + + @property + def H(self): + if self.hMap is None: + return np.ones(self.n_sounding) + else: + return self.h + + + # ------------- Etcetra .... ------------- # + @property + def IJLayers(self): + if getattr(self, '_IJLayers', None) is None: + # Ordering: first z then x + self._IJLayers = self.set_ij_n_layer() + return self._IJLayers + + @property + def IJHeight(self): + if getattr(self, '_IJHeight', None) is None: + # Ordering: first z then x + self._IJHeight = self.set_ij_n_layer(n_layer=1) + return self._IJHeight + + # ------------- For physics ------------- # + + def input_args(self, i_sounding, output_type='forward'): + output = ( + self.survey.source_list[i_sounding], + self.topo[i_sounding, :], + self.thicknesses, + self.Sigma[i_sounding, :], + self.Eta[i_sounding, :], + self.Tau[i_sounding, :], + self.C[i_sounding, :], + self.Chi[i_sounding, :], + self.dChi[i_sounding, :], + self.Tau1[i_sounding, :], + self.Tau2[i_sounding, :], + self.H[i_sounding], + output_type, + self.invert_height + ) + return output + + def fields(self, m): + if self.verbose: + print("Compute fields") + + return self.forward(m) + + def dpred(self, m, f=None): + """ + Return predicted data. + Predicted data, (`_pred`) are computed when + self.fields is called. + """ + if f is None: + f = self.fields(m) + + return f + + def forward(self, m): + self.model = m + + if self.verbose: + print(">> Compute response") + + # Set flat topo at zero + if self.topo is None: + self.set_null_topography() + + if self.survey.__class__ == EM1DSurveyFD: + print("Correct Run Simulation") + run_simulation = run_simulation_FD + else: + run_simulation = run_simulation_TD + + # if (self.parallel) & (__name__=='__main__'): + if self.parallel: + if self.verbose: + print ('parallel') + pool = Pool(self.n_cpu) + # This assumes the same # of layers for each of sounding + result = pool.map( + run_simulation, + [ + self.input_args(i, output_type='forward') for i in range(self.n_sounding) + ] + ) + pool.close() + pool.join() + else: + result = [ + run_simulation(self.input_args(i, output_type='forward')) for i in range(self.n_sounding) + ] + return np.hstack(result) + + + def set_null_topography(self): + self.topo = np.vstack( + [np.c_[src.location[0], src.location[1], 0.] for i, src in enumerate(self.survey.source_list)] + ) + + + def set_ij_n_layer(self, n_layer=None): + """ + Compute (I, J) indicies to form sparse sensitivity matrix + This will be used in GlobalEM1DSimulation when after sensitivity matrix + for each sounding is computed + """ + I = [] + J = [] + shift_for_J = 0 + shift_for_I = 0 + if n_layer is None: + m = self.n_layer + else: + m = n_layer + + for i in range(self.n_sounding): + n = self.survey.vnD_by_sounding[i] + J_temp = np.tile(np.arange(m), (n, 1)) + shift_for_J + I_temp = ( + np.tile(np.arange(n), (1, m)).reshape((n, m), order='F') + + shift_for_I + ) + J.append(utils.mkvc(J_temp)) + I.append(utils.mkvc(I_temp)) + shift_for_J += m + shift_for_I = I_temp[-1, -1] + 1 + J = np.hstack(J).astype(int) + I = np.hstack(I).astype(int) + return (I, J) + + def set_ij_height(self): + """ + Compute (I, J) indicies to form sparse sensitivity matrix + This will be used in GlobalEM1DSimulation when after sensitivity matrix + for each sounding is computed + """ + I = [] + J = [] + shift_for_J = 0 + shift_for_I = 0 + m = self.n_layer + for i in range(self.n_sounding): + n = self.survey.vnD[i] + J_temp = np.tile(np.arange(m), (n, 1)) + shift_for_J + I_temp = ( + np.tile(np.arange(n), (1, m)).reshape((n, m), order='F') + + shift_for_I + ) + J.append(utils.mkvc(J_temp)) + I.append(utils.mkvc(I_temp)) + shift_for_J += m + shift_for_I = I_temp[-1, -1] + 1 + J = np.hstack(J).astype(int) + I = np.hstack(I).astype(int) + return (I, J) + + + def getJ_sigma(self, m): + """ + Compute d F / d sigma + """ + if self._Jmatrix_sigma is not None: + return self._Jmatrix_sigma + if self.verbose: + print(">> Compute J sigma") + self.model = m + + if self.survey.__class__ == EM1DSurveyFD: + run_simulation = run_simulation_FD + else: + run_simulation = run_simulation_TD + + # if (self.parallel) & (__name__=='__main__'): + if self.parallel: + + pool = Pool(self.n_cpu) + self._Jmatrix_sigma = pool.map( + run_simulation, + [ + self.input_args(i, output_type='sensitivity_sigma') for i in range(self.n_sounding) + ] + ) + pool.close() + pool.join() + + if self.parallel_jvec_jtvec is False: + # self._Jmatrix_sigma = sp.block_diag(self._Jmatrix_sigma).tocsr() + self._Jmatrix_sigma = np.hstack(self._Jmatrix_sigma) + # self._JtJ_sigma_diag = + self._Jmatrix_sigma = sp.coo_matrix( + (self._Jmatrix_sigma, self.IJLayers), dtype=float + ).tocsr() + else: + # _Jmatrix_sigma is block diagnoal matrix (sparse) + # self._Jmatrix_sigma = sp.block_diag( + # [ + # run_simulation(self.input_args(i, output_type='sensitivity_sigma')) for i in range(self.n_sounding) + # ] + # ).tocsr() + self._Jmatrix_sigma = [ + run_simulation(self.input_args(i, output_type='sensitivity_sigma')) for i in range(self.n_sounding) + ] + self._Jmatrix_sigma = np.hstack(self._Jmatrix_sigma) + self._Jmatrix_sigma = sp.coo_matrix( + (self._Jmatrix_sigma, self.IJLayers), dtype=float + ).tocsr() + + return self._Jmatrix_sigma + + def getJ_height(self, m): + """ + Compute d F / d height + """ + if self.hMap is None: + return utils.Zero() + + if self._Jmatrix_height is not None: + return self._Jmatrix_height + if self.verbose: + print(">> Compute J height") + + self.model = m + + if self.survey.__class__ == EM1DSurveyFD: + run_simulation = run_simulation_FD + else: + run_simulation = run_simulation_TD + + if (self.parallel) & (__name__=='__main__'): + pool = Pool(self.n_cpu) + self._Jmatrix_height = pool.map( + run_simulation, + [ + self.input_args(i, output_type="sensitivity_height") for i in range(self.n_sounding) + ] + ) + pool.close() + pool.join() + if self.parallel_jvec_jtvec is False: + # self._Jmatrix_height = sp.block_diag(self._Jmatrix_height).tocsr() + self._Jmatrix_height = np.hstack(self._Jmatrix_height) + self._Jmatrix_height = sp.coo_matrix( + (self._Jmatrix_height, self.IJHeight), dtype=float + ).tocsr() + else: + # self._Jmatrix_height = sp.block_diag( + # [ + # run_simulation(self.input_args(i, output_type='sensitivity_height')) for i in range(self.n_sounding) + # ] + # ).tocsr() + self._Jmatrix_height = [ + run_simulation(self.input_args(i, output_type='sensitivity_height')) for i in range(self.n_sounding) + ] + self._Jmatrix_height = np.hstack(self._Jmatrix_height) + self._Jmatrix_height = sp.coo_matrix( + (self._Jmatrix_height, self.IJHeight), dtype=float + ).tocsr() + + return self._Jmatrix_height + + def Jvec(self, m, v, f=None): + J_sigma = self.getJ_sigma(m) + J_height = self.getJ_height(m) + + # This is deprecated at the moment + # if self.parallel and self.parallel_jvec_jtvec: + # # Extra division of sigma is because: + # # J_sigma = dF/dlog(sigma) + # # And here sigmaMap also includes ExpMap + # v_sigma = utils.sdiag(1./self.sigma) * self.sigmaMap.deriv(m, v) + # V_sigma = v_sigma.reshape((self.n_sounding, self.n_layer)) + + # pool = Pool(self.n_cpu) + # Jv = np.hstack( + # pool.map( + # dot, + # [(J_sigma[i], V_sigma[i, :]) for i in range(self.n_sounding)] + # ) + # ) + # if self.hMap is not None: + # v_height = self.hMap.deriv(m, v) + # V_height = v_height.reshape((self.n_sounding, self.n_layer)) + # Jv += np.hstack( + # pool.map( + # dot, + # [(J_height[i], V_height[i, :]) for i in range(self.n_sounding)] + # ) + # ) + # pool.close() + # pool.join() + # else: + + Jv = J_sigma*(utils.sdiag(1./self.sigma)*(self.sigmaDeriv * v)) + if self.hMap is not None: + Jv += J_height*(self.hDeriv * v) + return Jv + + def Jtvec(self, m, v, f=None): + J_sigma = self.getJ_sigma(m) + J_height = self.getJ_height(m) + + # This is deprecated at the moment + # if self.parallel and self.parallel_jvec_jtvec: + # pool = Pool(self.n_cpu) + # Jtv = np.hstack( + # pool.map( + # dot, + # [(J_sigma[i].T, v[self.data_index[i]]) for i in range(self.n_sounding)] + # ) + # ) + # if self.hMap is not None: + # Jtv_height = np.hstack( + # pool.map( + # dot, + # [(J_sigma[i].T, v[self.data_index[i]]) for i in range(self.n_sounding)] + # ) + # ) + # # This assumes certain order for model, m = (sigma, height) + # Jtv = np.hstack((Jtv, Jtv_height)) + # pool.close() + # pool.join() + # return Jtv + # else: + # Extra division of sigma is because: + # J_sigma = dF/dlog(sigma) + # And here sigmaMap also includes ExpMap + + Jtv = self.sigmaDeriv.T * (utils.sdiag(1./self.sigma) * (J_sigma.T*v)) + if self.hMap is not None: + Jtv += self.hDeriv.T*(J_height.T*v) + return Jtv + + def getJtJdiag(self, m, W=None, threshold=1e-8): + """ + Compute diagonal component of JtJ or + trace of sensitivity matrix (J) + """ + J_sigma = self.getJ_sigma(m) + J_matrix = J_sigma*(utils.sdiag(1./self.sigma)*(self.sigmaDeriv)) + + if self.hMap is not None: + J_height = self.getJ_height(m) + J_matrix += J_height*self.hDeriv + + if W is None: + W = utils.speye(J_matrix.shape[0]) + + J_matrix = W*J_matrix + JtJ_diag = (J_matrix.T*J_matrix).diagonal() + JtJ_diag /= JtJ_diag.max() + JtJ_diag += threshold + return JtJ_diag + + @property + def deleteTheseOnModelUpdate(self): + toDelete = [] + if self.sigmaMap is not None: + toDelete += ['_Sigma'] + if self.fix_Jmatrix is False: + if self._Jmatrix_sigma is not None: + toDelete += ['_Jmatrix_sigma'] + if self._Jmatrix_height is not None: + toDelete += ['_Jmatrix_height'] + return toDelete + + +class StitchedEM1DFMSimulation(BaseStitchedEM1DSimulation): + + def run_simulation(self, args): + if self.verbose: + print(">> Frequency-domain") + return run_simulation_FD(args) + +class StitchedEM1DTMSimulation(BaseStitchedEM1DSimulation): + + def run_simulation(self, args): + if self.verbose: + print(">> Time-domain") + return run_simulation_TD(args) + + + + + + + diff --git a/simpegEM1D/sources.py b/simpegEM1D/sources.py new file mode 100644 index 0000000..e60434a --- /dev/null +++ b/simpegEM1D/sources.py @@ -0,0 +1,393 @@ +import numpy as np +from SimPEG import survey +import properties +from scipy import special as spec + + + +############################################################################# +# Harmonic Sources +############################################################################# + + +class HarmonicMagneticDipoleSource(survey.BaseSrc): + """f + Harmonic magnetic dipole source. + + :param numpy.array location: source location (x,y,z) + :param string orientation: dipole orientation 'x', 'y' or 'z' + :param float moment_amplitude: magnitude of the dipole moment |m| + """ + + orientation = properties.StringChoice( + "Magnetic dipole orientation", default="z", choices=["x", "y", "z"] + ) + + moment_amplitude = properties.Float("Magnitude of the dipole moment", default=1.) + + def __init__(self, receiver_list=None, **kwargs): + super(HarmonicMagneticDipoleSource, self).__init__(receiver_list=receiver_list, **kwargs) + + + def PrimaryField(self, xyz, is_offset=False): + """ + Computes primary magnetic field (H) in units A/m + + :param numpy.ndarray xyz: np.array(N, 3) containing observation locations + :param bool is_offset: true receiver locations (False) or source-receier offset (True) + :rtype: numpy.ndarray: np.array(N, 3) array containing [Hx,Hy,Hz] values + :return: x,y,z components of the primary magnetic field + """ + + if is_offset: + r0 = np.zeros(3) + else: + r0 = self.location + + if self.orientation == "x": + m = np.r_[1., 0., 0.] + elif self.orientation == "y": + m = np.r_[0., 1., 0.] + elif self.orientation == "z": + m = np.r_[0., 0., 1.] + + r = np.sqrt((xyz[0]-r0[0])**2 + (xyz[1]-r0[1])**2 + (xyz[2]-r0[2])**2) + mdotr = m[0]*(xyz[0]-r0[0]) + m[1]*(xyz[1]-r0[1]) + m[2]*(xyz[2]-r0[2]) + + hx0 = (1/(4*np.pi))*(3*(xyz[0]-r0[0])*mdotr/r**5 - m[0]/r**3) + hy0 = (1/(4*np.pi))*(3*(xyz[1]-r0[1])*mdotr/r**5 - m[1]/r**3) + hz0 = (1/(4*np.pi))*(3*(xyz[2]-r0[2])*mdotr/r**5 - m[2]/r**3) + + return self.moment_amplitude*np.c_[hx0, hy0, hz0] + + +class HarmonicHorizontalLoopSource(survey.BaseSrc): + """ + Harmonic horizontal loop source. + + :param numpy.array locations: source location (x,y,z) + :param float I: current amplitude [A] + :param float a: loop radius [m] + """ + + I = properties.Float("Source loop current", default=1.) + + a = properties.Float("Source loop radius", default=1.) + + def __init__(self, receiver_list=None, **kwargs): + super(HarmonicHorizontalLoopSource, self).__init__(receiver_list=receiver_list, **kwargs) + + + def PrimaryField(self, xyz, is_offset=False): + """ + Computes primary magnetic field (H) in units A/m + + :param numpy.ndarray xyz: np.array(N, 3) containing observation locations + :param bool is_offset: true receiver locations (False) or source-receier offset (True) + :rtype: numpy.ndarray: np.array(N, 3) array containing [Hx,Hy,Hz] values + :return: x,y,z components of the primary magnetic field + """ + + a = self.a + I = self.I + if is_offset: + r0 = np.zeros(3) + else: + r0 = self.location + + theta = 0. # Azimuthal + alpha = 0. # Declination + + # Rotate x,y,z into coordinate axis of transmitter loop + rot_x = np.r_[ + np.c_[1, 0, 0], + np.c_[0, np.cos(np.pi*theta/180), -np.sin(np.pi*theta/180)], + np.c_[0, np.sin(np.pi*theta/180), np.cos(np.pi*theta/180)] + ] # CCW ROTATION OF THETA AROUND X-AXIS + + rot_z = np.r_[ + np.c_[np.cos(np.pi*alpha/180), -np.sin(np.pi*alpha/180), 0], + np.c_[np.sin(np.pi*alpha/180), np.cos(np.pi*alpha/180), 0], + np.c_[0, 0, 1] + ] # CCW ROTATION OF (90-ALPHA) ABOUT Z-AXIS + + rot_mat = np.dot(rot_x, rot_z) # THE ORDER MATTERS + + x1p = np.dot(np.c_[xyz[0]-r0[0], xyz[1]-r0[1], xyz[2]-r0[2]], rot_mat[0, :].T) + x2p = np.dot(np.c_[xyz[0]-r0[0], xyz[1]-r0[1], xyz[2]-r0[2]], rot_mat[1, :].T) + x3p = np.dot(np.c_[xyz[0]-r0[0], xyz[1]-r0[1], xyz[2]-r0[2]], rot_mat[2, :].T) + + s = np.sqrt(x1p**2 + x2p**2) + 1e-10 # Radial distance + k = 4*a*s/(x3p**2 + (a+s)**2) + + hxp = (x1p/s)*(x3p*I/(2*np.pi*s*np.sqrt(x3p**2 + (a + s)**2)))*(((a**2 + x3p**2 + s**2)/(x3p**2 + (s-a)**2))*spec.ellipe(k) - spec.ellipk(k)) + hyp = (x2p/s)*(x3p*I/(2*np.pi*s*np.sqrt(x3p**2 + (a + s)**2)))*(((a**2 + x3p**2 + s**2)/(x3p**2 + (s-a)**2))*spec.ellipe(k) - spec.ellipk(k)) + hzp = ( I/(2*np.pi* np.sqrt(x3p**2 + (a + s)**2)))*(((a**2 - x3p**2 - s**2)/(x3p**2 + (s-a)**2))*spec.ellipe(k) + spec.ellipk(k)) + + # Rotate the other way to get back into original coordinates + rot_mat_t = rot_mat.T + hx0 = np.dot(np.c_[hxp, hyp, hzp], rot_mat_t[0, :].T) + hy0 = np.dot(np.c_[hxp, hyp, hzp], rot_mat_t[1, :].T) + hz0 = np.dot(np.c_[hxp, hyp, hzp], rot_mat_t[2, :].T) + + return np.c_[hx0, hy0, hz0] + + +class HarmonicCurrentLineSource(survey.BaseSrc): + """ + Harmonic current line source. + + :param numpy.ndarray node_locations: np.array(N+1, 3) of node locations defining N line segments + :param float I: current amplitude [A] + """ + + node_locations = properties.Array( + "Source path (xi, yi, zi), i=0,...,N", + dtype=float + ) + + I = properties.Float("Source current", default=1.) + + + def __init__(self, receiver_list=None, **kwargs): + super(HarmonicLineSource, self).__init__(receiver_list=receiver_list, **kwargs) + + + def PrimaryField(self, xyz): + """ + Computes primary magnetic field (H) in units A/m + + :param numpy.ndarray xyz: np.array(N, 3) containing observation locations + :param bool is_offset: true receiver locations (False) or source-receier offset (True) + :rtype: numpy.ndarray: np.array(N, 3) array containing [Hx,Hy,Hz] values + :return: x,y,z components of the primary magnetic field + """ + + I = self.I + tx_nodes = self.node_locations + x1tr = tx_nodes[:, 0] + x2tr = tx_nodes[:, 1] + x3tr = tx_nodes[:, 2] + + nLoc = np.shape(xyz)[0] + nSeg = np.size(x1tr)-1 + + hx0 = np.zeros(nLoc) + hy0 = np.zeros(nLoc) + hz0 = np.zeros(nLoc) + + for pp in range(0, nSeg): + + # Wire ends for transmitter wire pp + x1a = x1tr[pp] + x2a = x2tr[pp] + x3a = x3tr[pp] + x1b = x1tr[pp+1] + x2b = x2tr[pp+1] + x3b = x3tr[pp+1] + + # Vector Lengths between points + vab = np.sqrt((x1b - x1a)**2 + (x2b - x2a)**2 + (x3b - x3a)**2) + vap = np.sqrt((xyz[:, 0] - x1a)**2 + (xyz[:, 1] - x2a)**2 + (xyz[:, 2] - x3a)**2) + vbp = np.sqrt((xyz[:, 0] - x1b)**2 + (xyz[:, 1] - x2b)**2 + (xyz[:, 2] - x3b)**2) + + # Cosines from cos()=/(|v1||v2|) + cos_alpha = ((xyz[:, 0]-x1a)*(x1b - x1a) + (xyz[:, 1]-x2a)*(x2b - x2a) + (xyz[:, 2]-x3a)*(x3b - x3a))/(vap*vab) + cos_beta = ((xyz[:, 0]-x1b)*(x1a - x1b) + (xyz[:, 1]-x2b)*(x2a - x2b) + (xyz[:, 2]-x3b)*(x3a - x3b))/(vbp*vab) + + # Determining Radial Vector From Wire + dot_temp = ( + (x1a - xyz[:, 0])*(x1b - x1a) + + (x2a - xyz[:, 1])*(x2b - x2a) + + (x3a - xyz[:, 2])*(x3b - x3a) + ) + + rx1 = (x1a - xyz[:, 0]) - dot_temp*(x1b - x1a)/vab**2 + rx2 = (x2a - xyz[:, 1]) - dot_temp*(x2b - x2a)/vab**2 + rx3 = (x3a - xyz[:, 2]) - dot_temp*(x3b - x3a)/vab**2 + + r = np.sqrt(rx1**2 + rx2**2 + rx3**2) + + phi = (cos_alpha + cos_beta)/r + + # I/4*pi in each direction + ix1 = I*(x1b - x1a)/(4*np.pi*vab) + ix2 = I*(x2b - x2a)/(4*np.pi*vab) + ix3 = I*(x3b - x3a)/(4*np.pi*vab) + + # Add contribution from wire pp into array + hx0 = hx0 + phi*(-ix2*rx3 + ix3*rx2)/r + hy0 = hy0 + phi*( ix1*rx3 - ix3*rx1)/r + hz0 = hz0 + phi*(-ix1*rx2 + ix2*rx1)/r + + return np.c_[hx0, hy0, hz0] + + +############################################################################# +# Time Sources +############################################################################# + + +class BaseTimeSrc(survey.BaseSrc): + """ + Base class for EM1D time-domain sources. + + :param numpy.array location: source location (x,y,z) + :param string orientation: dipole orientation 'x', 'y' or 'z' + :param float moment_amplitude: magnitude of the dipole moment |m| + """ + + wave_type = properties.StringChoice( + "Waveform", + default="stepoff", + choices=["stepoff", "general"] + ) + + moment_type = properties.StringChoice( + "Source moment type", + default="single", + choices=["single", "dual"] + ) + + n_pulse = properties.Integer( + "The number of pulses", + ) + + base_frequency = properties.Float( + "Base frequency (Hz)" + ) + + time_input_currents = properties.Array( + "Time for input currents", dtype=float + ) + + input_currents = properties.Array( + "Input currents", dtype=float + ) + + use_lowpass_filter = properties.Bool( + "Switch for low pass filter", default=False + ) + + high_cut_frequency = properties.Float( + "High cut frequency for low pass filter (Hz)", + default=210*1e3 + ) + + + # ------------- For dual moment ------------- # + + time_input_currents_dual_moment = properties.Array( + "Time for input currents (dual moment)", dtype=float + ) + + input_currents_dual_moment = properties.Array( + "Input currents (dual moment)", dtype=float + ) + + base_frequency_dual_moment = properties.Float( + "Base frequency for the dual moment (Hz)" + ) + + + def __init__(self, receiver_list=None, **kwargs): + super(BaseTimeSrc, self).__init__(receiver_list=receiver_list, **kwargs) + + + @property + def period(self): + return 1./self.base_frequency + + @property + def pulse_period(self): + Tp = ( + self.time_input_currents.max() - + self.time_input_currents.min() + ) + return Tp + + # ------------- For dual moment ------------- # + @property + def period_dual_moment(self): + return 1./self.base_frequency_dual_moment + + @property + def pulse_period_dual_moment(self): + Tp = ( + self.time_input_currents_dual_moment.max() - + self.time_input_currents_dual_moment.min() + ) + return Tp + + # Note: not relevant here + # @property + # def n_time_dual_moment(self): + # return int(self.time_dual_moment.size) + + # @property + # def nD(self): + # """ + # # of data + # """ + + # if self.moment_type == "single": + # return self.n_time + # else: + # return self.n_time + self.n_time_dual_moment + + +class TimeDomainMagneticDipoleSource(BaseTimeSrc): + """ + Time-domain magnetic dipole source. + + :param numpy.array location: source location (x,y,z) + :param string orientation: dipole orientation 'z' + :param float moment_amplitude: magnitude of the dipole moment |m| + """ + + moment_amplitude = properties.Float("Magnitude of the dipole moment", default=1.) + + orientation = properties.StringChoice( + "Dipole Orientation", default="z", choices=["z"] + ) + + def __init__(self, receiver_list=None, **kwargs): + super(TimeDomainMagneticDipoleSource, self).__init__(receiver_list=receiver_list, **kwargs) + + +class TimeDomainHorizontalLoopSource(BaseTimeSrc): + """ + Time-domain horizontal loop source. + + :param numpy.array location: source location (x,y,z) + :param float I: source current amplitude [A] + :param float a: loop radius [m] + """ + + I = properties.Float("Source loop current", default=1.) + + a = properties.Float("Source loop radius", default=1.) + + def __init__(self, receiver_list=None, **kwargs): + super(TimeDomainHorizontalLoopSource, self).__init__(receiver_list=receiver_list, **kwargs) + + +class TimeDomainLineSource(BaseTimeSrc): + """ + Time-domain current line source. + + :param numpy.ndarray node_locations: np.array(N+1, 3) of node locations defining N line segments + :param float I: current amplitude [A] + """ + + I = properties.Float("Source loop current", default=1.) + + node_locations = properties.Array( + "Source path (xi, yi, zi), i=0,...N", + dtype=float + ) + + def __init__(self, receiver_list=None, **kwargs): + super(TimeDomainLineSource, self).__init__(receiver_list=receiver_list, **kwargs) + + diff --git a/simpegEM1D/supporting_functions/__init__.py b/simpegEM1D/supporting_functions/__init__.py new file mode 100644 index 0000000..a4fa666 --- /dev/null +++ b/simpegEM1D/supporting_functions/__init__.py @@ -0,0 +1,2 @@ +from .digital_filter import * +from .kernels import * \ No newline at end of file diff --git a/simpegEM1D/DigFilter.py b/simpegEM1D/supporting_functions/digital_filter.py similarity index 99% rename from simpegEM1D/DigFilter.py rename to simpegEM1D/supporting_functions/digital_filter.py index 0376693..4b53093 100644 --- a/simpegEM1D/DigFilter.py +++ b/simpegEM1D/supporting_functions/digital_filter.py @@ -2,7 +2,7 @@ from scipy.constants import mu_0 from scipy.interpolate import interp1d from scipy.constants import pi -from SimPEG import Utils +from SimPEG.utils import mkvc def EvalDigitalFilt(base, weight, fun, r): @@ -37,7 +37,7 @@ def transFilt(hz, wt, tbase, omega_int, t, tol=1e-12): # Determine required frequencies # Calculate the frequency domain data - hziw = Utils.mkvc(hz.imag)/omega_int + hziw = mkvc(hz.imag)/omega_int # Clean the low frequency results idKeep = [idx for idx in range(len(hz)) if abs(hz.imag)[idx] > tol] @@ -77,7 +77,7 @@ def transFiltInterp(hz, wt, tbase, omega, omega_int, t, tol=1e-12): # Determine required frequencies # Calculate the frequency domain data - hziw = Utils.mkvc(hz.imag)/omega + hziw = mkvc(hz.imag)/omega # Clean the low frequency results idKeep = [idx for idx in range(len(hz)) if abs(hz.imag)[idx] > tol] @@ -121,7 +121,7 @@ def transFiltImpulse(hz, wt, tbase, omega_int, t, tol=1e-12): # Determine required frequencies # Calculate the frequency domain data - hzr = -Utils.mkvc(hz.real) + hzr = -mkvc(hz.real) # Clean the low frequency results idKeep = [idx for idx in range(len(hz)) if abs(hz.imag)[idx] > tol] @@ -161,7 +161,7 @@ def transFiltImpulseInterp(hz, wt, tbase, omega, omega_int, t, tol=1e-12): # Determine required frequencies # Calculate the frequency domain data - hzr = -Utils.mkvc(hz.real) + hzr = -mkvc(hz.real) # Clean the low frequency results # idKeep = [idx for idx in range(len(hz)) if abs(hz.imag)[idx] > tol] diff --git a/simpegEM1D/supporting_functions/dummy.py b/simpegEM1D/supporting_functions/dummy.py new file mode 100644 index 0000000..6af050b --- /dev/null +++ b/simpegEM1D/supporting_functions/dummy.py @@ -0,0 +1,695 @@ +# ------------ Dummy codes for older version ------------ # +# Deprecated with the latest versions in geoana +# ------------------------------------------------------- # + +# try: +# from simpegEM1D.m_rTE_Fortran import rte_fortran +# except ImportError as e: +# rte_fortran = None + +# def rTEfunfwd(n_layer, f, lamda, sig, chi, thick, halfspace_switch): +# """ +# Compute reflection coefficients for Transverse Electric (TE) mode. +# Only one for loop for multiple layers. + +# Parameters +# ---------- +# n_layer : int +# The number layers +# f : complex, ndarray +# Frequency (Hz); size = (n_frequency x n_filter) +# lamda : complex, ndarray +# Frequency (Hz); size = (n_frequency x n_filter) +# sig: compelx, ndarray +# Conductivity (S/m); size = (n_layer x n_frequency x n_filter) +# chi: compelx, ndarray +# Susceptibility (SI); size = (n_layer,) +# depth: float, ndarray +# Top boundary of the layers; size = (n_ayer,) +# halfspace_switch: bool +# Switch for halfspace + +# Returns +# ------- +# rTE: compex, ndarray +# Reflection coefficients; +# size = (n_frequency x n_lamba) +# """ + +# n_frequency, n_filter = lamda.shape + +# Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# M1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# w = 2*np.pi*f + +# rTE = np.zeros((n_frequency, n_filter), dtype=complex) +# utemp0 = np.zeros((n_frequency, n_filter), dtype=complex) +# utemp1 = np.zeros((n_frequency, n_filter), dtype=complex) +# const = np.zeros((n_frequency, n_filter), dtype=complex) + +# utemp0 = lamda +# utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0, :, :])*sig[0, :, :]) +# const = mu_0*utemp1/(mu_0*(1+chi[0, :, :])*utemp0) + +# Mtemp00 = 0.5*(1+const) +# Mtemp10 = 0.5*(1-const) +# Mtemp01 = 0.5*(1-const) +# Mtemp11 = 0.5*(1+const) + +# # may be store these and reuse for sensitivity? +# M00 = [] +# M10 = [] +# M01 = [] +# M11 = [] + +# M0sum00 = Mtemp00 +# M0sum10 = Mtemp10 +# M0sum01 = Mtemp01 +# M0sum11 = Mtemp11 + +# if halfspace_switch: + +# M1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# M1sum00 = M0sum00 +# M1sum10 = M0sum10 +# M1sum01 = M0sum01 +# M1sum11 = M0sum11 + +# else: + +# for j in range(n_layer-1): +# utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j, :, :])*sig[j, :, :]) +# utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j+1, :, :])*sig[j+1, :, :]) +# const = mu_0*(1+chi[j, :, :])*utemp1/(mu_0*(1+chi[j+1, :, :])*utemp0) + +# h0 = thick[j] + +# Mtemp00 = 0.5*(1.+const)*np.exp(-2.*utemp0*h0) +# Mtemp10 = 0.5*(1.-const) +# Mtemp01 = 0.5*(1.-const)*np.exp(-2.*utemp0*h0) +# Mtemp11 = 0.5*(1.+const) + +# M1sum00 = M0sum00*Mtemp00 + M0sum01*Mtemp10 +# M1sum10 = M0sum10*Mtemp00 + M0sum11*Mtemp10 +# M1sum01 = M0sum00*Mtemp01 + M0sum01*Mtemp11 +# M1sum11 = M0sum10*Mtemp01 + M0sum11*Mtemp11 + +# M0sum00 = M1sum00 +# M0sum10 = M1sum10 +# M0sum01 = M1sum01 +# M0sum11 = M1sum11 + +# rTE = M1sum01/M1sum11 + +# return rTE + + +# def matmul(a00, a10, a01, a11, b00, b10, b01, b11): +# """ +# Compute 2x2 matrix mutiplication in vector way +# C = A*B +# C = [a00 a01] * [b00 b01] = [c00 c01] +# [a10 a11] [b10 b11] [c10 c11] +# """ + +# c00 = a00*b00 + a01*b10 +# c10 = a10*b00 + a11*b10 +# c01 = a00*b01 + a01*b11 +# c11 = a10*b01 + a11*b11 + +# return c00, c10, c01, c11 + + + +# # TODO: make this to take a vector rather than a single frequency +# def rTEfunjac(n_layer, f, lamda, sig, chi, thick, halfspace_switch): +# """ +# Compute sensitivity of reflection coefficients for +# Transverse Electric (TE) mode with regard to conductivity + +# Parameters +# ---------- +# n_layer : int +# The number layers +# f : complex, ndarray +# Frequency (Hz); size = (n_frequency x n_finlter) +# lamda : complex, ndarray +# Frequency (Hz); size = (n_frequency x n_finlter) +# sig: complex, ndarray +# Conductivity (S/m); size = (n_layer x 1) +# chi: compelx, ndarray +# Susceptibility (SI); size = (n_layer x 1) +# depth: float, ndarray +# Top boundary of the layers +# halfspace_switch: bool +# Switch for halfspace + +# Returns +# ------- +# rTE: compex, ndarray +# Derivative of reflection coefficients; +# size = (n_frequency x n_layer x n_finlter) +# """ +# # Initializing arrays +# n_frequency, n_filter = lamda.shape + +# Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# M1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# M1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# M0sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# M0sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# M0sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# M0sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# dMtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dMtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dMtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dMtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# dj0temp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dj0temp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dj0temp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dj0temp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# dj1temp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dj1temp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dj1temp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dj1temp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# w = 2*np.pi*f + +# rTE = np.zeros((n_frequency, n_filter), dtype=complex) +# drTE = np.zeros((n_layer, n_frequency, n_filter), dtype=complex) +# utemp0 = np.zeros((n_frequency, n_filter), dtype=complex) +# utemp1 = np.zeros((n_frequency, n_filter), dtype=complex) +# const = np.zeros((n_frequency, n_filter), dtype=complex) + +# utemp0 = lamda +# utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0, :, :]) +# const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) + +# # Compute M1 +# Mtemp00 = 0.5*(1+const) +# Mtemp10 = 0.5*(1-const) +# Mtemp01 = 0.5*(1-const) +# Mtemp11 = 0.5*(1+const) + +# utemp0 = lamda +# utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0, :, :]) +# const = mu_0*utemp1/(mu_0*(1+chi[0])*utemp0) + +# # Compute dM1du1 +# dj0Mtemp00 = 0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) +# dj0Mtemp10 = -0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) +# dj0Mtemp01 = -0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) +# dj0Mtemp11 = 0.5*(mu_0/(mu_0*(1+chi[0])*utemp0)) + +# # TODO: for computing Jacobian +# M00 = [] +# M10 = [] +# M01 = [] +# M11 = [] + +# dJ00 = [] +# dJ10 = [] +# dJ01 = [] +# dJ11 = [] + +# M00.append(Mtemp00) +# M01.append(Mtemp01) +# M10.append(Mtemp10) +# M11.append(Mtemp11) + +# M0sum00 = Mtemp00.copy() +# M0sum10 = Mtemp10.copy() +# M0sum01 = Mtemp01.copy() +# M0sum11 = Mtemp11.copy() + +# if halfspace_switch or n_layer == 1: + +# M1sum00 = M0sum00.copy() +# M1sum10 = M0sum10.copy() +# M1sum01 = M0sum01.copy() +# M1sum11 = M0sum11.copy() + +# else: + +# for j in range(n_layer-1): + +# dJ_10Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ_10Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ_10Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ_10Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# dJ01Mtemp00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ01Mtemp10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ01Mtemp01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ01Mtemp11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j])*sig[j, :, :]) +# utemp1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j+1])*sig[j+1, :, :]) +# const = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0) + +# h0 = thick[j] + +# Mtemp00 = 0.5*(1.+ const)*np.exp(-2.*utemp0*h0) +# Mtemp10 = 0.5*(1.- const) +# Mtemp01 = 0.5*(1.- const)*np.exp(-2.*utemp0*h0) +# Mtemp11 = 0.5*(1.+ const) + +# M1sum00, M1sum10, M1sum01, M1sum11 = matmul( +# M0sum00, M0sum10, M0sum01, M0sum11, +# Mtemp00, Mtemp10, Mtemp01, Mtemp11 +# ) + +# M0sum00 = M1sum00 +# M0sum10 = M1sum10 +# M0sum01 = M1sum01 +# M0sum11 = M1sum11 + +# # TODO: for Computing Jacobian + +# dudsig = 0.5*1j*w*mu_0*(1+chi[j])/utemp0 + +# if j == 0: + +# const1a = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0**2) +# const1b = const1a*utemp0 + +# dj1Mtemp00 = -0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1+const1b)*np.exp(-2.*utemp0*h0) +# dj1Mtemp10 = 0.5*const1a +# dj1Mtemp01 = 0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1-const1b)*np.exp(-2.*utemp0*h0) +# dj1Mtemp11 = -0.5*const1a + +# # Compute dM1dm1*M2 +# dJ_10Mtemp00, dJ_10Mtemp10, dJ_10Mtemp01, dJ_10Mtemp11 = matmul( +# dj0Mtemp00, dj0Mtemp10, dj0Mtemp01, dj0Mtemp11, +# Mtemp00, Mtemp10, Mtemp01, Mtemp11 +# ) + +# # Compute M1*dM2dm1 +# dJ01Mtemp00, dJ01Mtemp10, dJ01Mtemp01, dJ01Mtemp11 = matmul( +# M00[j], M10[j], M01[j], M11[j], dj1Mtemp00, +# dj1Mtemp10, dj1Mtemp01, dj1Mtemp11 +# ) + +# dJ00.append(dudsig*(dJ_10Mtemp00+dJ01Mtemp00)) +# dJ10.append(dudsig*(dJ_10Mtemp10+dJ01Mtemp10)) +# dJ01.append(dudsig*(dJ_10Mtemp01+dJ01Mtemp01)) +# dJ11.append(dudsig*(dJ_10Mtemp11+dJ01Mtemp11)) + +# else: + +# h_1 = thick[j-1] +# utemp_1 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[j-1])*sig[j-1]) +# const0 = mu_0*(1+chi[j-1])/(mu_0*(1+chi[j])*utemp_1) + +# dj0Mtemp00 = 0.5*(const0)*np.exp(-2.*utemp_1*h_1) +# dj0Mtemp10 = -0.5*(const0) +# dj0Mtemp01 = -0.5*(const0)*np.exp(-2.*utemp_1*h_1) +# dj0Mtemp11 = 0.5*(const0) + +# const1a = mu_0*(1+chi[j])*utemp1/(mu_0*(1+chi[j+1])*utemp0**2) +# const1b = const1a*utemp0 + +# dj1Mtemp00 = -0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1+const1b)*np.exp(-2.*utemp0*h0) +# dj1Mtemp10 = 0.5*const1a +# dj1Mtemp01 = 0.5*const1a*np.exp(-2.*utemp0*h0)-h0*(1-const1b)*np.exp(-2.*utemp0*h0) +# dj1Mtemp11 = -0.5*const1a + +# # Compute dMjdmj*Mj+1 +# dJ_10Mtemp00, dJ_10Mtemp10, dJ_10Mtemp01, dJ_10Mtemp11 = matmul( +# dj0Mtemp00, dj0Mtemp10, dj0Mtemp01, dj0Mtemp11, +# Mtemp00, Mtemp10, Mtemp01, Mtemp11 +# ) + +# # Compute Mj*dMj+1dmj +# dJ01Mtemp00, dJ01Mtemp10, dJ01Mtemp01, dJ01Mtemp11 = matmul( +# M00[j], M10[j], M01[j], M11[j], +# dj1Mtemp00, dj1Mtemp10, dj1Mtemp01, dj1Mtemp11 +# ) + +# dJ00.append(dudsig*(dJ_10Mtemp00+dJ01Mtemp00)) +# dJ10.append(dudsig*(dJ_10Mtemp10+dJ01Mtemp10)) +# dJ01.append(dudsig*(dJ_10Mtemp01+dJ01Mtemp01)) +# dJ11.append(dudsig*(dJ_10Mtemp11+dJ01Mtemp11)) + +# M00.append(Mtemp00) +# M01.append(Mtemp01) +# M10.append(Mtemp10) +# M11.append(Mtemp11) + +# # rTE = M1sum01/M1sum11 + +# if halfspace_switch or n_layer == 1: + +# utemp0 = np.sqrt(lamda**2+1j*w*mu_0*(1+chi[0])*sig[0]) +# dudsig = 0.5*1j*w*mu_0*(1+chi[0])/utemp0 + +# dJ1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# dJ1sum00 = dudsig*dj0Mtemp00 +# dJ1sum10 = dudsig*dj0Mtemp10 +# dJ1sum01 = dudsig*dj0Mtemp01 +# dJ1sum11 = dudsig*dj0Mtemp11 + +# drTE = dJ1sum01/M1sum11 - M1sum01/(M1sum11**2)*dJ1sum11 + +# else: + +# # j = n_layer +# utemp0 = ( +# np.sqrt(lamda**2+1j*w*mu_0*(1+chi[n_layer-1])*sig[n_layer-1, :, :]) +# ) +# dudsig = 0.5*1j*w*mu_0*(1+chi[n_layer-1])/utemp0 + +# h_1 = thick[n_layer-2] + +# utemp_1 = ( +# np.sqrt(lamda**2+1j*w*mu_0*(1+chi[n_layer-2])*sig[n_layer-2, :, :]) +# ) +# const0 = mu_0*(1+chi[n_layer-2])/(mu_0*(1+chi[n_layer-1])*utemp_1) + +# dj0Mtemp00 = 0.5*(const0)*np.exp(-2.*utemp_1*h_1) +# dj0Mtemp10 = -0.5*(const0) +# dj0Mtemp01 = -0.5*(const0)*np.exp(-2.*utemp_1*h_1) +# dj0Mtemp11 = 0.5*(const0) + +# dJ_10Mtemp00 = dj0Mtemp00 +# dJ_10Mtemp10 = dj0Mtemp10 +# dJ_10Mtemp01 = dj0Mtemp01 +# dJ_10Mtemp11 = dj0Mtemp11 + +# dJ00.append(dudsig*dJ_10Mtemp00) +# dJ10.append(dudsig*dJ_10Mtemp10) +# dJ01.append(dudsig*dJ_10Mtemp01) +# dJ11.append(dudsig*dJ_10Mtemp11) + +# for i in range(n_layer): + +# dJ0sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ0sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ0sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ0sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# dJ1sum00 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ1sum10 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ1sum01 = np.zeros((n_frequency, n_filter), dtype=complex) +# dJ1sum11 = np.zeros((n_frequency, n_filter), dtype=complex) + +# if i == 0: + +# for j in range(n_layer-2): + +# if j == 0: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ00[i], dJ10[i], dJ01[i], dJ11[i], +# M00[j+2], M10[j+2], M01[j+2], M11[j+2] +# ) + +# else: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, +# M00[j+2], M10[j+2], M01[j+2], M11[j+2] +# ) + +# dJ0sum00 = dJ1sum00 +# dJ0sum10 = dJ1sum10 +# dJ0sum01 = dJ1sum01 +# dJ0sum11 = dJ1sum11 + +# elif (i > 0) & (i < n_layer-1): + +# dJ0sum00 = M00[0] +# dJ0sum10 = M10[0] +# dJ0sum01 = M01[0] +# dJ0sum11 = M11[0] + +# for j in range (n_layer-2): + +# if j==i-1: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, +# dJ00[i], dJ10[i], dJ01[i], dJ11[i] +# ) + +# elif j < i-1: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, +# M00[j+1], M10[j+1], M01[j+1], M11[j+1] +# ) + +# elif j > i-1: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, +# M00[j+2], M10[j+2], M01[j+2], M11[j+2] +# ) + +# dJ0sum00 = dJ1sum00 +# dJ0sum10 = dJ1sum10 +# dJ0sum01 = dJ1sum01 +# dJ0sum11 = dJ1sum11 + +# elif i == n_layer-1: + +# dJ0sum00 = M00[0] +# dJ0sum10 = M10[0] +# dJ0sum01 = M01[0] +# dJ0sum11 = M11[0] + +# for j in range(n_layer-1): + +# if j < n_layer-2: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, +# M00[j+1], M10[j+1], M01[j+1], M11[j+1] +# ) + +# elif j == n_layer-2: + +# dJ1sum00, dJ1sum10, dJ1sum01, dJ1sum11 = matmul( +# dJ0sum00, dJ0sum10, dJ0sum01, dJ0sum11, +# dJ00[i], dJ10[i], dJ01[i], dJ11[i] +# ) + +# dJ0sum00 = dJ1sum00 +# dJ0sum10 = dJ1sum10 +# dJ0sum01 = dJ1sum01 +# dJ0sum11 = dJ1sum11 + +# drTE[i, :] = dJ1sum01/M1sum11 - M1sum01/(M1sum11**2)*dJ1sum11 + +# return drTE + # Still worthwhile to output both? + # return rTE, drTE + + + # ------------ Dummy codes for older version ------------ # + # This can be used in later use for handling on-time data. + # ------------------------------------------------------- # + + # def setWaveform(self, **kwargs): + # """ + # Set parameters for Src Waveform + # """ + # # TODO: this is hp is only valid for Circular loop system + # self.hp = self.I/self.a*0.5 + + # self.toff = kwargs['toff'] + # self.waveform = kwargs['waveform'] + # self.waveformDeriv = kwargs['waveformDeriv'] + # self.tconv = kwargs['tconv'] + + # def projectFields(self, u): + # """ + # Transform frequency domain responses to time domain responses + # """ + # # Case1: Compute frequency domain reponses right at filter coefficient values + # if self.switchInterp == False: + # # Src waveform: Step-off + # if self.wave_type == 'stepoff': + # if self.rx_type == 'Bz': + # # Compute EM responses + # if u.size == self.n_frequency: + # resp, f0 = transFilt(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.time) + # # Compute EM sensitivities + # else: + # resp = np.zeros((self.n_time, self.n_layer)) + # for i in range (self.n_layer): + # resp[:,i], f0 = transFilt(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.time) + + # elif self.rx_type == 'dBzdt': + # # Compute EM responses + # if u.size == self.n_frequency: + # resp = -transFiltImpulse(u, self.wt,self.tbase, self.frequency*2*np.pi, self.time) + # # Compute EM sensitivities + # else: + # resp = np.zeros((self.n_time, self.n_layer)) + # for i in range (self.n_layer): + # resp[:,i] = -transFiltImpulse(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.time) + + # # Src waveform: General (it can be any waveform) + # # We evaluate this with time convolution + # elif self.wave_type == 'general': + # # Compute EM responses + # if u.size == self.n_frequency: + # # TODO: write small code which compute f at t = 0 + # f, f0 = transFilt(Utils.mkvc(u), self.wt, self.tbase, self.frequency*2*np.pi, self.tconv) + # fDeriv = -transFiltImpulse(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.tconv) + + # if self.rx_type == 'Bz': + + # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) + # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + + # # TODO: make it as an opition #2 + # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) + # # resp2 = (self.waveform*self.hp) - waveDerivConvf + # # respint = interp1d(self.tconv, resp2, 'linear') + + # resp = respint(self.time) + + # if self.rx_type == 'dBzdt': + # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) + # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + # resp = respint(self.time) + + # # Compute EM sensitivities + # else: + + # resp = np.zeros((self.n_time, self.n_layer)) + # for i in range (self.n_layer): + + # f, f0 = transFilt(u[:,i], self.wt, self.tbase, self.frequency*2*np.pi, self.tconv) + # fDeriv = -transFiltImpulse(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.tconv) + + # if self.rx_type == 'Bz': + + # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) + # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + + # # TODO: make it as an opition #2 + # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) + # # resp2 = (self.waveform*self.hp) - waveDerivConvf + # # respint = interp1d(self.tconv, resp2, 'linear') + + # resp[:,i] = respint(self.time) + + # if self.rx_type == 'dBzdt': + # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) + # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + # resp[:,i] = respint(self.time) + + # # Case2: Compute frequency domain reponses in logarithmic then intepolate + # if self.switchInterp == True: + # # Src waveform: Step-off + # if self.wave_type == 'stepoff': + # if self.rx_type == 'Bz': + # # Compute EM responses + # if u.size == self.n_frequency: + # resp, f0 = transFiltInterp(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) + # # Compute EM sensitivities + # else: + # resp = np.zeros((self.n_time, self.n_layer)) + # for i in range (self.n_layer): + # resp[:,i], f0 = transFiltInterp(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) + + # elif self.rx_type == 'dBzdt': + # # Compute EM responses + # if u.size == self.n_frequency: + # resp = -transFiltImpulseInterp(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) + # # Compute EM sensitivities + # else: + # resp = np.zeros((self.n_time, self.n_layer)) + # for i in range (self.n_layer): + # resp[:,i] = -transFiltImpulseInterp(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.time) + + # # Src waveform: General (it can be any waveform) + # # We evaluate this with time convolution + # elif self.wave_type == 'general': + # # Compute EM responses + # if u.size == self.n_frequency: + # # TODO: write small code which compute f at t = 0 + # f, f0 = transFiltInterp(Utils.mkvc(u), self.wt, self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) + # fDeriv = -transFiltImpulseInterp(Utils.mkvc(u), self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) + + # if self.rx_type == 'Bz': + + # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) + # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + + # # TODO: make it as an opition #2 + # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) + # # resp2 = (self.waveform*self.hp) - waveDerivConvf + # # respint = interp1d(self.tconv, resp2, 'linear') + + # resp = respint(self.time) + + # if self.rx_type == 'dBzdt': + # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) + # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + # resp = respint(self.time) + + # # Compute EM sensitivities + # else: + + # resp = np.zeros((self.n_time, self.n_layer)) + # for i in range (self.n_layer): + + # f, f0 = transFiltInterp(u[:,i], self.wt, self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) + # fDeriv = -transFiltImpulseInterp(u[:,i], self.wt,self.tbase, self.frequency*2*np.pi, self.omega_int, self.tconv) + + # if self.rx_type == 'Bz': + + # waveConvfDeriv = CausalConv(self.waveform, fDeriv, self.tconv) + # resp1 = (self.waveform*self.hp*(1-f0[1]/self.hp)) - waveConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + + # # TODO: make it as an opition #2 + # # waveDerivConvf = CausalConv(self.waveformDeriv, f, self.tconv) + # # resp2 = (self.waveform*self.hp) - waveDerivConvf + # # respint = interp1d(self.tconv, resp2, 'linear') + + # resp[:,i] = respint(self.time) + + # if self.rx_type == 'dBzdt': + # waveDerivConvfDeriv = CausalConv(self.waveformDeriv, fDeriv, self.tconv) + # resp1 = self.hp*self.waveformDeriv*(1-f0[1]/self.hp) - waveDerivConvfDeriv + # respint = interp1d(self.tconv, resp1, 'linear') + # resp[:,i] = respint(self.time) + + # return mu_0*resp diff --git a/simpegEM1D/supporting_functions/kernels.py b/simpegEM1D/supporting_functions/kernels.py new file mode 100644 index 0000000..94492c6 --- /dev/null +++ b/simpegEM1D/supporting_functions/kernels.py @@ -0,0 +1,343 @@ +import numpy as np +from scipy.constants import mu_0 +from geoana.kernels import rTE_forward, rTE_gradient + +# TODO: reduce f and lamda as 1D arrays, and use numpy broadcast +def magnetic_dipole_kernel( + simulation, lamda, f, n_layer, sig, chi, h, z, r, + src, rx, output_type='response' +): + + """ + Kernel for vertical (Hz) and radial (Hrho) magnetic component due to + vertical magnetic diopole (VMD) source in (kx,ky) domain. + + For vertical magnetic dipole: + + .. math:: + + H_z = \\frac{m}{4\\pi} + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda^2 J_0(\\lambda r) d \\lambda + + .. math:: + + H_{\\rho} = - \\frac{m}{4\\pi} + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda^2 J_1(\\lambda r) d \\lambda + + For horizontal magnetic dipole: + + .. math:: + + H_x = \\frac{m}{4\\pi} \\Bigg \\frac{1}{\\rho} -\\frac{2x^2}{\\rho^3} \\Bigg ) + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda J_1(\\lambda r) d \\lambda + + \\frac{m}{4\\pi} \\frac{x^2}{\\rho^2} + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda^2 J_0(\\lambda r) d \\lambda + + .. math:: + + H_y = - \\frac{m}{4\\pi} \\frac{2xy}{\\rho^3} + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda J_1(\\lambda r) d \\lambda + + \\frac{m}{4\\pi} \\frac{xy}{\\rho^2} + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda^2 J_0(\\lambda r) d \\lambda + + .. math:: + + H_z = \\frac{m}{4\\pi} \\frac{x}{\\rho} + \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} + \\lambda^2 J_1(\\lambda r) d \\lambda + + """ + + # coefficient_wavenumber = 1/(4*np.pi)*lamda**2 + C = src.moment_amplitude/(4*np.pi) + + n_frequency = len(f) + n_filter = simulation.n_filter + thicknesses = simulation.thicknesses + mu = (chi+1)*mu_0 + # COMPUTE TE-MODE REFLECTION COEFFICIENT + if output_type == 'sensitivity_sigma': + drTE = np.zeros( + [n_layer, n_frequency, n_filter], + dtype=np.complex128, order='F' + ) + + drTE, _, _ = rTE_gradient( + f[:,0], lamda[0,:], sig, mu, thicknesses + ) + + temp = drTE * np.exp(-lamda*(z+h)) + else: + rTE = np.empty( + [n_frequency, n_filter], dtype=np.complex128, order='F' + ) + depth = simulation.depth + rTE = rTE_forward( + f[:,0], lamda[0,:], sig, mu, thicknesses + ) + + temp = rTE * np.exp(-lamda*(z+h)) + if output_type == 'sensitivity_height': + temp *= -2*lamda + + # COMPUTE KERNEL FUNCTIONS FOR HANKEL TRANSFORM + if rx.use_source_receiver_offset: + v_dist = rx.locations + else: + v_dist = rx.locations - src.location + + if src.orientation == "z": + if rx.orientation == "z": + kernels = [C * lamda**2 * temp, None, None] + elif rx.orientation == "x": + C *= -v_dist[0]/np.sqrt(np.sum(v_dist[0:-1]**2)) + kernels = [None, C * lamda**2 * temp, None] + elif rx.orientation == "y": + C *= -v_dist[1]/np.sqrt(np.sum(v_dist[0:-1]**2)) + kernels = [None, C * lamda**2 * temp, None] + elif src.orientation == "x": + rho = np.sqrt(np.sum(v_dist[0:-1]**2)) + if rx.orientation == "z": + C *= v_dist[0]/rho + kernels = [None, C * lamda**2 * temp, None] + elif rx.orientation == "x": + C0 = C * v_dist[0]**2/rho**2 + C1 = C * (1/rho - 2*v_dist[0]**2/rho**3) + kernels = [C0 * lamda**2 * temp, C1 * lamda *temp, None] + elif rx.orientation == "y": + C0 = C * v_dist[0]*v_dist[1]/rho**2 + C1 = C * -2*v_dist[0]*v_dist[1]/rho**3 + kernels = [C0 * lamda**2 * temp, C1 * lamda *temp, None] + elif src.orientation == "y": + rho = np.sqrt(np.sum(v_dist[0:-1]**2)) + if rx.orientation == "z": + C *= v_dist[1]/rho + kernels = [None, C * lamda**2 * temp, None] + elif rx.orientation == "x": + C0 = C * -v_dist[0]*v_dist[1]/rho**2 + C1 = C * 2*v_dist[0]*v_dist[1]/rho**3 + kernels = [C0 * lamda**2 * temp, C1 * lamda *temp, None] + elif rx.orientation == "y": + C0 = C * v_dist[1]**2/rho**2 + C1 = C * (1/rho - 2*v_dist[1]**2/rho**3) + kernels = [C0 * lamda**2 * temp, C1 * lamda *temp, None] + + + return kernels + + +# def magnetic_dipole_fourier( +# simulation, lamda, f, n_layer, sig, chi, I, h, z, r, +# src, rx, output_type='response' +# ): + +# """ +# Kernel for vertical (Hz) and radial (Hrho) magnetic component due to +# vertical magnetic diopole (VMD) source in (kx,ky) domain. + +# For vertical magnetic dipole: + +# .. math:: + +# H_z = \\frac{m}{4\\pi} +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda^2 J_0(\\lambda r) d \\lambda + +# .. math:: + +# H_{\\rho} = - \\frac{m}{4\\pi} +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda^2 J_1(\\lambda r) d \\lambda + +# For horizontal magnetic dipole: + +# .. math:: + +# H_x = \\frac{m}{4\\pi} \\Bigg \\frac{1}{\\rho} -\\frac{2x^2}{\\rho^3} \\Bigg ) +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda J_1(\\lambda r) d \\lambda +# + \\frac{m}{4\\pi} \\frac{x^2}{\\rho^2} +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda^2 J_0(\\lambda r) d \\lambda + +# .. math:: + +# H_y = - \\frac{m}{4\\pi} \\frac{2xy}{\\rho^3} +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda J_1(\\lambda r) d \\lambda +# + \\frac{m}{4\\pi} \\frac{xy}{\\rho^2} +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda^2 J_0(\\lambda r) d \\lambda + +# .. math:: + +# H_z = \\frac{m}{4\\pi} \\frac{x}{\\rho} +# \\int_0^{\\infty} \\r_{TE} e^{u_0|z-h|} +# \\lambda^2 J_1(\\lambda r) d \\lambda + +# """ + +# # coefficient_wavenumber = 1/(4*np.pi)*lamda**2 +# C = I/(4*np.pi) + +# n_frequency = len(f) +# n_filter = simulation.n_filter + +# # COMPUTE TE-MODE REFLECTION COEFFICIENT +# if output_type == 'sensitivity_sigma': +# drTE = np.zeros( +# [n_layer, n_frequency, n_filter], +# dtype=np.complex128, order='F' +# ) +# if rte_fortran is None: +# thick = simulation.thicknesses +# drTE = rTEfunjac( +# n_layer, f, lamda[0,:], sig, chi, thick, simulation.halfspace_switch +# ) +# else: +# depth = simulation.depth +# rte_fortran.rte_sensitivity( +# f, lamda[0,:], sig, chi, depth, simulation.halfspace_switch, drTE, +# n_layer, n_frequency, n_filter +# ) + +# temp = drTE * np.exp(-lamda*(z+h)) +# else: +# rTE = np.empty( +# [n_frequency, n_filter], dtype=np.complex128, order='F' +# ) +# if rte_fortran is None: +# thick = simulation.thicknesses +# rTE = rTEfunfwd( +# n_layer, f, lamda[0,:], sig, chi, thick, simulation.halfspace_switch +# ) +# else: +# depth = simulation.depth +# rte_fortran.rte_forward( +# f, lamda[0,:], sig, chi, depth, simulation.halfspace_switch, +# rTE, n_layer, n_frequency, n_filter +# ) + +# if output_type == 'sensitivity_height': +# rTE *= -2*lamda + +# # COMPUTE KERNEL FUNCTIONS FOR FOURIER TRANSFORM +# return C * lamda**2 * rTE + + + +# TODO: make this to take a vector rather than a single frequency +def horizontal_loop_kernel( + simulation, lamda, f, n_layer, sig, chi, a, h, z, r, + src, rx, output_type='response' +): + + """ + + Kernel for vertical (Hz) and radial (Hrho) magnetic component due to + horizontal cirular loop source in (kx,ky) domain. + + For the vertical component: + + .. math:: + H_z = \\frac{Ia}{2} \\int_0^{\\infty} + \\r_{TE}e^{u_0|z-h|}] \\frac{\\lambda^2}{u_0} + J_1(\\lambda a) J_0(\\lambda r) d \\lambda + + For the radial component: + + .. math:: + H_{\\rho} = - \\frac{Ia}{2} \\int_0^{\\infty} + \\r_{TE}e^{u_0|z-h|}] \\lambda + J_1(\\lambda a) J_1(\\lambda r) d \\lambda + + + """ + + n_frequency = len(f) + n_filter = simulation.n_filter + + w = 2*np.pi*f + u0 = lamda + radius = np.empty([n_frequency, n_filter], order='F') + radius[:, :] = np.tile(a.reshape([-1, 1]), (1, n_filter)) + + coefficient_wavenumber = src.I*radius*0.5*lamda**2/u0 + thicknesses = simulation.thicknesses + mu = (chi+1)*mu_0 + + if output_type == 'sensitivity_sigma': + drTE = np.empty( + [n_layer, n_frequency, n_filter], + dtype=np.complex128, order='F' + ) + + drTE, _, _ = rTE_gradient( + f[:,0], lamda[0,:], sig, mu, thicknesses + ) + kernel = drTE * np.exp(-u0*(z+h)) * coefficient_wavenumber + else: + rTE = np.empty( + [n_frequency, n_filter], dtype=np.complex128, order='F' + ) + + rTE = rTE_forward( + f[:,0], lamda[0,:], sig, mu, thicknesses + ) + + kernel = rTE * np.exp(-u0*(z+h)) * coefficient_wavenumber + + if output_type == 'sensitivity_height': + kernel *= -2*u0 + + return kernel + +def hz_kernel_horizontal_electric_dipole( + simulation, lamda, f, n_layer, sig, chi, h, z, + flag, output_type='response' +): + + """ + Kernel for vertical magnetic field (Hz) due to + horizontal electric diopole (HED) source in (kx,ky) domain + + """ + n_frequency = len(f) + n_filter = simulation.n_filter + + u0 = lamda + coefficient_wavenumber = 1/(4*np.pi)*lamda**2/u0 + thicknesses = simulation.thicknesses + mu = (chi+1)*mu_0 + + if output_type == 'sensitivity_sigma': + drTE = np.zeros( + [n_layer, n_frequency, n_filter], dtype=np.complex128, + order='F' + ) + + drTE, _, _ = rTE_gradient( + f[:,0], lamda[0,:], sig, mu, thicknesses + ) + + kernel = drTE * np.exp(-u0*(z+h)) * coefficient_wavenumber + else: + rTE = np.empty( + [n_frequency, n_filter], dtype=np.complex128, order='F' + ) + rTE = rTE_forward( + f[:,0], lamda[0,:], sig, mu, thicknesses + ) + + kernel = rTE * np.exp(-u0*(z+h)) * coefficient_wavenumber + if output_type == 'sensitivity_height': + kernel *= -2*u0 + + return kernel + diff --git a/simpegEM1D/survey.py b/simpegEM1D/survey.py new file mode 100644 index 0000000..65c1fc7 --- /dev/null +++ b/simpegEM1D/survey.py @@ -0,0 +1,131 @@ +from SimPEG import maps, utils +from SimPEG.survey import BaseSurvey +import numpy as np +import scipy.sparse as sp +from scipy.constants import mu_0 +from .analytics import ColeCole +from .supporting_functions.digital_filter import ( + transFilt, transFiltImpulse, transFiltInterp, transFiltImpulseInterp +) +from .waveforms import CausalConv +from scipy.interpolate import interp1d +from scipy.interpolate import InterpolatedUnivariateSpline as iuSpline +import properties +from empymod import filters +from empymod.utils import check_time +from empymod.transform import fourier_dlf +from .known_waveforms import ( + piecewise_pulse_fast, + butterworth_type_filter, butter_lowpass_filter +) + + +class BaseEM1DSurvey(BaseSurvey, properties.HasProperties): + """ + Base EM1D survey class + """ + + def __init__(self, source_list=None, **kwargs): + BaseSurvey.__init__(self, source_list, **kwargs) + + +class EM1DSurveyFD(BaseEM1DSurvey): + """ + Survey class for frequency domain surveys. Used for 1D simulation + as well as stitched 1D simulation. + """ + + def __init__(self, source_list=None, **kwargs): + BaseEM1DSurvey.__init__(self, source_list, **kwargs) + + @property + def nD(self): + """ + Returns number of data. + """ + + nD = 0 + + for src in self.source_list: + for rx in src.receiver_list: + nD += rx.nD + + return int(nD) + + @property + def vnD_by_sounding(self): + if getattr(self, '_vnD_by_sounding', None) is None: + temp = [] + for src in self.source_list: + temp.append( + np.sum([rx.nD for rx in src.receiver_list]) + ) + self._vnD_by_sounding = np.array(temp) + return self._vnD_by_sounding + + +class EM1DSurveyTD(BaseEM1DSurvey): + """ + Survey class for time-domain surveys. Used for 1D simulation + as well as stitched 1D simulation. + """ + + + def __init__(self, source_list=None, **kwargs): + BaseEM1DSurvey.__init__(self, source_list, **kwargs) + + # Use Sin filter for frequency to time transform + self.fftfilt = filters.key_81_CosSin_2009() + + + @property + def nD(self): + """ + Returns the number of data. + """ + + nD = 0 + + for src in self.source_list: + for rx in src.receiver_list: + nD += rx.nD + + + return int(nD) + + + @property + def vnD_by_sounding(self): + if getattr(self, '_vnD_by_sounding', None) is None: + temp = [] + for src in self.source_list: + temp.append( + np.sum([rx.nD for rx in src.receiver_list]) + ) + self._vnD_by_sounding = np.array(temp) + return self._vnD_by_sounding + + + @property + def lowpass_filter(self): + """ + Low pass filter values + """ + if getattr(self, '_lowpass_filter', None) is None: + # self._lowpass_filter = butterworth_type_filter( + # self.frequency, self.high_cut_frequency + # ) + + self._lowpass_filter = (1+1j*(self.frequency/self.high_cut_frequency))**-1 + self._lowpass_filter *= (1+1j*(self.frequency/3e5))**-0.99 + # For actual butterworth filter + + # filter_frequency, values = butter_lowpass_filter( + # self.high_cut_frequency + # ) + # lowpass_func = interp1d( + # filter_frequency, values, fill_value='extrapolate' + # ) + # self._lowpass_filter = lowpass_func(self.frequency) + + return self._lowpass_filter diff --git a/simpegEM1D/utils/__init__.py b/simpegEM1D/utils/__init__.py new file mode 100644 index 0000000..5a1c581 --- /dev/null +++ b/simpegEM1D/utils/__init__.py @@ -0,0 +1 @@ +from .utils1D import * diff --git a/simpegEM1D/Utils1D.py b/simpegEM1D/utils/utils1D.py similarity index 71% rename from simpegEM1D/Utils1D.py rename to simpegEM1D/utils/utils1D.py index f0eb510..2fb196c 100644 --- a/simpegEM1D/Utils1D.py +++ b/simpegEM1D/utils/utils1D.py @@ -1,6 +1,11 @@ import numpy as np import matplotlib.pyplot as plt import scipy +from discretize import TensorMesh +from SimPEG import maps, utils +from ..analytics import skin_depth, diffusion_distance +from ..simulation import EM1DFMSimulation, EM1DTMSimulation +from ..survey import EM1DSurveyFD, EM1DSurveyTD def plotLayer(sig, mesh, xscale='log', ax=None, showlayers=False, xlim=None,**kwargs): """ @@ -99,3 +104,45 @@ def write25Dinputformat(Rvals,Ivals, frequency, x, z, offset, fname='profile2D.i fid.write("%5i\n" % (ist+1)) fid.write("%10.4f %10.4f %10.5e %10.5e \n" % (x[ist]+offset, z[ist], Rvals[ifreq, ist], Ivals[ifreq, ist])) + +def get_vertical_discretization_frequency( + frequency, sigma_background=0.01, + factor_fmax=4, factor_fmin=1., n_layer=19, + hz_min=None, z_max=None +): + if hz_min is None: + hz_min = skin_depth(frequency.max(), sigma_background) / factor_fmax + if z_max is None: + z_max = skin_depth(frequency.min(), sigma_background) * factor_fmin + i = 4 + hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) + z_sum = hz.sum() + + while z_sum < z_max: + i += 1 + hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) + z_sum = hz.sum() + return hz + + +def get_vertical_discretization_time( + time, sigma_background=0.01, + factor_tmin=4, facter_tmax=1., n_layer=19, + hz_min=None, z_max=None +): + if hz_min is None: + hz_min = diffusion_distance(time.min(), sigma_background) / factor_tmin + if z_max is None: + z_max = diffusion_distance(time.max(), sigma_background) * facter_tmax + i = 4 + hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) + z_sum = hz.sum() + while z_sum < z_max: + i += 1 + hz = np.logspace(np.log10(hz_min), np.log10(hz_min*i), n_layer) + z_sum = hz.sum() + return hz + + +def set_mesh_1d(hz): + return TensorMesh([hz], x0=[0]) \ No newline at end of file diff --git a/simpegEM1D/Waveform.py b/simpegEM1D/waveforms.py similarity index 96% rename from simpegEM1D/Waveform.py rename to simpegEM1D/waveforms.py index 740793e..3f04775 100644 --- a/simpegEM1D/Waveform.py +++ b/simpegEM1D/waveforms.py @@ -89,11 +89,11 @@ def RectFun(time, ta, tb): .. math:: - I(t) = 1, 0 < t \le t_a + I(t) = 1, 0 < t \\le t_a I(t) = -1, t_a < t < t_b - I(t) = 0, t \le t_a \ \\text{or} \ t \ge t_b + I(t) = 0, t \\le t_a \\ \\text{or} \\ t \\ge t_b """ out = np.zeros(time.size) diff --git a/tests/testEM1D_FD_fwd.py b/tests/testEM1D_FD_fwd.py index b7fe7b0..ec3aa05 100644 --- a/tests/testEM1D_FD_fwd.py +++ b/tests/testEM1D_FD_fwd.py @@ -1,7 +1,10 @@ import unittest from SimPEG import * +from discretize import TensorMesh import matplotlib.pyplot as plt -from simpegEM1D import EM1D, EM1DAnalytics, EM1DSurveyFD +import simpegEM1D as em1d +from simpegEM1D.analytics import * +#from simpegEM1D import EM1D, EM1DAnalytics, EM1DSurveyFD import numpy as np from scipy.constants import mu_0 @@ -12,252 +15,369 @@ def setUp(self): nearthick = np.logspace(-1, 1, 5) deepthick = np.logspace(1, 2, 10) - hx = np.r_[nearthick, deepthick] - mesh1D = Mesh.TensorMesh([hx], [0.]) - depth = -mesh1D.gridN[:-1] - nlay = depth.size + thicknesses = np.r_[nearthick, deepthick] topo = np.r_[0., 0., 100.] - - FDsurvey = EM1DSurveyFD( - rx_location=np.array([0., 0., 100.+1e-5]), - src_location=np.array([0., 0., 100.+1e-5]), - field_type='secondary', - depth=depth, - topo=topo, - frequency=np.logspace(1, 8, 61), - offset=10. * np.ones(61) + + offset = 10. + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([offset, 0., 100.+1e-5]) + field_type = "secondary" # "secondary", "total" or "ppm" + frequencies = np.logspace(-1, 5, 61) + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="real" + ) ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="imag" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="real" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="imag" + ) + ) + + source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=src_location, orientation="z" + ) + ] - sig_half = 1e-2 - chi_half = 0. - - expmap = Maps.ExpMap(mesh1D) + # Survey + survey = em1d.survey.EM1DSurveyFD(source_list) + + sigma = 1e-2 + chi = 0. tau = 1e-3 eta = 2e-1 c = 1. - m_1D = np.log(np.ones(nlay)*sig_half) - FDsurvey.rx_type = 'Hz' - - prob = EM1D( - mesh1D, sigmaMap=expmap - ) - prob.pair(FDsurvey) - prob.chi = np.zeros(FDsurvey.n_layer) - - self.survey = FDsurvey - self.prob = prob - self.mesh1D = mesh1D + self.topo = topo + self.survey = survey self.showIt = False + self.sigma = sigma self.tau = tau self.eta = eta self.c = c + self.chi = chi + self.offset = offset + self.frequencies = frequencies + self.thicknesses = thicknesses + self.nlayers = len(thicknesses)+1 + + + def test_EM1DFDfwd_VMD_Halfspace(self): + + sigma_map = maps.ExpMap(nP=1) + sim = em1d.simulation.EM1DFMSimulation( + survey=self.survey, sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.array([np.log(self.sigma)]) + H = sim.dpred(m_1D) + + soln_anal_z = Hz_vertical_magnetic_dipole( + self.frequencies, self.offset, self.sigma, 'secondary' + ) + soln_anal_r = Hr_vertical_magnetic_dipole( + self.frequencies, self.offset, self.sigma + ) + + if self.showIt is True: + N=int(len(H)/4) + plt.loglog(self.frequencies, abs(Hz[0:N]), 'b') + plt.loglog(self.frequencies, abs(soln_anal_z.real), 'b*') + plt.loglog(self.frequencies, abs(Hz[N:2*N]), 'r') + plt.loglog(self.frequencies, abs(soln_anal_z.imag), 'r*') + plt.show() + + soln_anal = np.r_[ + np.real(soln_anal_z), np.imag(soln_anal_z), + np.real(soln_anal_r), np.imag(soln_anal_r) + ] + + err = np.linalg.norm(H-soln_anal)/np.linalg.norm(soln_anal) + self.assertTrue(err < 1e-5) + print ("EM1DFD-VMD for halfspace works") def test_EM1DFDfwd_VMD_RealCond(self): - self.prob.survey.src_type = 'VMD' - self.prob.survey.offset = np.ones(self.prob.survey.n_frequency) * 10. - sig_half = 0.01 - m_1D = np.log(np.ones(self.prob.survey.n_layer)*sig_half) - Hz = self.prob.forward(m_1D) - Hzanal = EM1DAnalytics.Hzanal( - sig_half, self.prob.survey.frequency, - self.prob.survey.offset, 'secondary' + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DFMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo ) - + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) + H = sim.dpred(m_1D) + + soln_anal_z = Hz_vertical_magnetic_dipole( + self.frequencies, self.offset, self.sigma, 'secondary' + ) + soln_anal_r = Hr_vertical_magnetic_dipole( + self.frequencies, self.offset, self.sigma + ) + if self.showIt is True: - - plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*') - plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*') + N=int(len(Hz)/2) + plt.loglog(self.frequencies, abs(Hz[0:N]), 'b') + plt.loglog(self.frequencies, abs(soln_anal.real), 'b*') + plt.loglog(self.frequencies, abs(Hz[N:]), 'r') + plt.loglog(self.frequencies, abs(soln_anal.imag), 'r*') plt.show() - - err = np.linalg.norm(Hz-Hzanal)/np.linalg.norm(Hzanal) + + soln_anal = np.r_[ + np.real(soln_anal_z), np.imag(soln_anal_z), + np.real(soln_anal_r), np.imag(soln_anal_r) + ] + + err = np.linalg.norm(H-soln_anal)/np.linalg.norm(soln_anal) self.assertTrue(err < 1e-5) print ("EM1DFD-VMD for real conductivity works") def test_EM1DFDfwd_VMD_ComplexCond(self): - if self.prob.ispaired: - self.prob.unpair() - if self.survey.ispaired: - self.survey.unpair() + sigma_map = maps.IdentityMap(nP=self.nlayers) + chi = np.zeros(self.nlayers) + tau = self.tau*np.ones(self.nlayers) + c = self.c*np.ones(self.nlayers) + eta = self.eta*np.ones(self.nlayers) + + sim = em1d.simulation.EM1DFMSimulation( + survey=self.survey, thicknesses=self.thicknesses, topo=self.topo, + sigmaMap=sigma_map, eta=eta, tau=tau, c=c, chi=chi + ) + + m_1D = self.sigma*np.ones(self.nlayers) + H = sim.dpred(m_1D) + + sigma_colecole = ColeCole( + self.frequencies, self.sigma, self.eta, self.tau, self.c + ) + + soln_anal_z = Hz_vertical_magnetic_dipole( + self.frequencies, self.offset, sigma_colecole, 'secondary' + ) + soln_anal_r = Hr_vertical_magnetic_dipole( + self.frequencies, self.offset, sigma_colecole + ) + + if self.showIt is True: + N=int(len(Hz)/2) + plt.loglog(self.frequencies, abs(Hz[0:N]), 'b') + plt.loglog(self.frequencies, abs(soln_anal.real), 'b*') + plt.loglog(self.frequencies, abs(Hz[N:]), 'r') + plt.loglog(self.frequencies, abs(soln_anal.imag), 'r*') + plt.show() + + soln_anal = np.r_[ + np.real(soln_anal_z), np.imag(soln_anal_z), + np.real(soln_anal_r), np.imag(soln_anal_r) + ] + + err = np.linalg.norm(H-soln_anal)/np.linalg.norm(soln_anal) + self.assertTrue(err < 1e-5) + print ("EM1DFD-VMD for complex conductivity works") - self.prob = EM1D( - self.mesh1D, - sigmaMap=Maps.IdentityMap(self.mesh1D), - chi=np.zeros(self.survey.n_layer), - eta=self.eta, - tau=self.tau, - c=self.c + def test_EM1DFDfwd_HMD_RealCond(self): + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([self.offset, 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + field_type = "secondary" # "secondary", "total" or "ppm" + frequencies = np.logspace(-1, 5, 61) + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="real" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="imag" + ) ) - self.prob.pair(self.survey) - self.prob.survey.src_type = 'VMD' - sig_half = 0.01 - m_1D = np.ones(self.prob.survey.n_layer)*sig_half - Hz = self.prob.forward(m_1D) - sigCole = EM1DAnalytics.ColeCole( - self.survey.frequency, sig_half, - self.eta, self.tau, self.c + + source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=src_location, orientation="x" ) - Hzanal = EM1DAnalytics.Hzanal( - sigCole, self.prob.survey.frequency, - self.prob.survey.offset, 'secondary' + ] + + survey = em1d.survey.EM1DSurveyFD(source_list) + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) + Hz = sim.dpred(m_1D) + + soln_anal = Hz_horizontal_magnetic_dipole( + self.frequencies, self.offset, self.offset, self.sigma ) if self.showIt is True: - - plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*') - plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*') + N=int(len(Hz)/2) + plt.loglog(self.frequencies, abs(Hz[0:N]), 'b') + plt.loglog(self.frequencies, abs(soln_anal.real), 'b*') + plt.loglog(self.frequencies, abs(Hz[N:]), 'r') + plt.loglog(self.frequencies, abs(soln_anal.imag), 'r*') plt.show() - err = np.linalg.norm(Hz-Hzanal)/np.linalg.norm(Hzanal) + soln_anal = np.r_[np.real(soln_anal), np.imag(soln_anal)] + + err = np.linalg.norm(Hz-soln_anal)/np.linalg.norm(soln_anal) self.assertTrue(err < 1e-5) - print ("EM1DFD-VMD for complex conductivity works") + print ("EM1DFD-HMD for real conductivity works") + def test_EM1DFDfwd_CircularLoop_RealCond(self): - self.prob.survey.src_type = 'CircularLoop' - I = 1e0 - a = 1e1 - self.prob.survey.I = I - self.prob.survey.a = a - sig_half = 0.01 - m_1D = np.log(np.ones(self.prob.survey.n_layer)*sig_half) - Hz = self.prob.forward(m_1D) - Hzanal = EM1DAnalytics.HzanalCirc( - sig_half, self.prob.survey.frequency, - I, a, 'secondary' + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([0., 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + field_type = "secondary" # "secondary", "total" or "ppm" + frequencies = np.logspace(-1, 5, 61) + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag" + ) + ) + + source_list = [ + em1d.sources.HarmonicHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, a=5. + ) + ] + + survey = em1d.survey.EM1DSurveyFD(source_list) + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) + Hz = sim.dpred(m_1D) + + soln_anal = Hz_horizontal_circular_loop( + self.frequencies, 1., 5., self.sigma, 'secondary' ) if self.showIt is True: - - plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*') - plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*') + N=int(len(Hz)/2) + plt.loglog(self.frequencies, abs(Hz[0:N]), 'b') + plt.loglog(self.frequencies, abs(soln_anal.real), 'b*') + plt.loglog(self.frequencies, abs(Hz[N:]), 'r') + plt.loglog(self.frequencies, abs(soln_anal.imag), 'r*') plt.show() - err = np.linalg.norm(Hz-Hzanal)/np.linalg.norm(Hzanal) + soln_anal = np.r_[np.real(soln_anal), np.imag(soln_anal)] + + err = np.linalg.norm(Hz-soln_anal)/np.linalg.norm(soln_anal) self.assertTrue(err < 1e-5) print ("EM1DFD-CircularLoop for real conductivity works") def test_EM1DFDfwd_CircularLoop_ComplexCond(self): - if self.prob.ispaired: - self.prob.unpair() - if self.survey.ispaired: - self.survey.unpair() - - self.prob = EM1D( - self.mesh1D, - sigmaMap=Maps.IdentityMap(self.mesh1D), - chi=np.zeros(self.survey.n_layer), - eta=self.eta, - tau=self.tau, - c=self.c + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([0., 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + field_type = "secondary" # "secondary", "total" or "ppm" + frequencies = np.logspace(-1, 5, 61) + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real" + ) ) - - self.prob.pair(self.survey) - self.prob.survey.src_type = 'CircularLoop' - I = 1e0 - a = 1e1 - self.prob.survey.I = I - self.prob.survey.a = a - - sig_half = 0.01 - m_1D = np.ones(self.prob.survey.n_layer)*sig_half - Hz = self.prob.forward(m_1D) - sigCole = EM1DAnalytics.ColeCole( - self.survey.frequency, sig_half, self.eta, self.tau, self.c + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag" + ) + ) + + source_list = [ + em1d.sources.HarmonicHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, a=5. + ) + ] + + # Survey + survey = em1d.survey.EM1DSurveyFD(source_list) + + sigma_map = maps.IdentityMap(nP=self.nlayers) + chi = np.zeros(self.nlayers) + tau = self.tau*np.ones(self.nlayers) + c = self.c*np.ones(self.nlayers) + eta = self.eta*np.ones(self.nlayers) + + sim = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=self.thicknesses, topo=self.topo, + sigmaMap=sigma_map, eta=eta, tau=tau, c=c, chi=chi + ) + + m_1D = self.sigma*np.ones(self.nlayers) + Hz = sim.dpred(m_1D) + + sigma_colecole = ColeCole( + self.frequencies, self.sigma, self.eta, self.tau, self.c ) - Hzanal = EM1DAnalytics.HzanalCirc( - sigCole, self.prob.survey.frequency, I, a, 'secondary' + + soln_anal = Hz_horizontal_circular_loop( + self.frequencies, 1., 5., sigma_colecole, 'secondary' ) if self.showIt is True: - - plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*') - plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r') - plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*') + N=int(len(Hz)/2) + plt.loglog(self.frequencies, abs(Hz[0:N]), 'b') + plt.loglog(self.frequencies, abs(soln_anal.real), 'b*') + plt.loglog(self.frequencies, abs(Hz[N:]), 'r') + plt.loglog(self.frequencies, abs(soln_anal.imag), 'r*') plt.show() - err = np.linalg.norm(Hz-Hzanal)/np.linalg.norm(Hzanal) + soln_anal = np.r_[np.real(soln_anal), np.imag(soln_anal)] + + err = np.linalg.norm(Hz-soln_anal)/np.linalg.norm(soln_anal) self.assertTrue(err < 1e-5) print ("EM1DFD-CircularLoop for complex conductivity works") - # def test_EM1DFDfwd_VMD_EM1D_sigchi(self): - - # self.survey.rx_location = np.array([0., 0., 110.+1e-5]) - # self.survey.src_location = np.array([0., 0., 110.+1e-5]) - # self.survey.field_type = 'secondary' - - # hx = np.r_[np.ones(3)*10] - # mesh1D = Mesh.TensorMesh([hx], [0.]) - # depth = -mesh1D.gridN[:-1] - # nlay = depth.size - # topo = np.r_[0., 0., 100.] - - # self.survey.depth = depth - # self.survey.topo = topo - - # self.survey.frequency = np.logspace(-3, 5, 61) - # self.prob.unpair() - # mapping = Maps.ExpMap(mesh1D) - # # 1. Verification for variable conductivity - # chi = np.array([0., 0., 0.]) - # sig = np.array([0.01, 0.1, 0.01]) - - # self.prob = EM1D(mesh1D, sigmaMap=mapping, chi=chi, jacSwitch=False) - # self.prob.pair(self.survey) - # self.prob.survey.src_type = 'VMD' - # self.prob.survey.offset = 10. * np.ones(self.survey.n_frequency) - - # m_1D = np.log(sig) - # Hz = self.prob.forward(m_1D) - # from scipy import io - # mat = io.loadmat('em1dfm/VMD_3lay.mat') - # freq = mat['data'][:, 0] - # Hzanal = mat['data'][:, 1] + 1j*mat['data'][:, 2] - - # if self.showIt is True: - - # plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b') - # plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*') - # plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r') - # plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*') - # plt.show() - - # err = np.linalg.norm(Hz-Hzanal)/np.linalg.norm(Hzanal) - # self.assertTrue(err < 0.08) - - # chi = np.array([0., 1., 0.], dtype=float) - # sig = np.array([0.01, 0.01, 0.01], dtype=float) - # self.prob.chi = chi - - # m_1D = np.log(sig) - # Hz = self.prob.forward(m_1D) - - # # 2. Verification for variable susceptibility - # mat = io.loadmat('em1dfm/VMD_3lay_chi.mat') - # freq = mat['data'][:, 0] - # Hzanal = mat['data'][:, 1] + 1j*mat['data'][:, 2] - - # if self.showIt is True: - - # plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b') - # plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*') - # plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r') - # plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*') - # plt.show() - - # err = np.linalg.norm(Hz-Hzanal)/np.linalg.norm(Hzanal) - # self.assertTrue(err < 0.08) - - # print ("EM1DFD comprison of UBC code works") - if __name__ == '__main__': unittest.main() diff --git a/tests/testEM1D_FD_jac_layers.py b/tests/testEM1D_FD_jac_layers.py index 0692913..9c472d2 100644 --- a/tests/testEM1D_FD_jac_layers.py +++ b/tests/testEM1D_FD_jac_layers.py @@ -1,7 +1,8 @@ import unittest from SimPEG import * +from SimPEG.utils import mkvc import matplotlib.pyplot as plt -from simpegEM1D import EM1D, EM1DAnalytics, DigFilter, EM1DSurveyFD +import simpegEM1D as em1d import numpy as np @@ -9,82 +10,115 @@ class EM1D_FD_Jac_layers_ProblemTests(unittest.TestCase): def setUp(self): - nearthick = np.logspace(-1, 1, 2) - deepthick = np.logspace(1, 2, 5) - hx = np.r_[nearthick, deepthick] - mesh1D = Mesh.TensorMesh([hx], [0.]) - depth = -mesh1D.gridN[:-1] - n_layer = depth.size - - FDsurvey = EM1DSurveyFD( - rx_location=np.array([0., 0., 100.+50.]), - src_location=np.array([0., 0., 100.+50.]), - field_type='secondary', - topo=np.r_[0., 0., 100.], - depth=depth, - frequency=np.logspace(2, 4, 10), - src_type='CircularLoop' - ) - - sig_half = 1e-1 - chi_half = 0. - - expmap = Maps.ExpMap(mesh1D) - tau = 1e-3 - eta = 2e-1 - c = 1. - - m_1D = np.log(np.ones(n_layer)*sig_half) - FDsurvey.rxType = 'Hz' - - prob = EM1D(mesh1D, sigmaMap=expmap) - prob.pair(FDsurvey) - prob.chi = np.zeros(FDsurvey.n_layer) - - self.survey = FDsurvey - self.prob = prob - self.mesh1D = mesh1D + nearthick = np.logspace(-1, 1, 5) + deepthick = np.logspace(1, 2, 10) + thicknesses = np.r_[nearthick, deepthick] + topo = np.r_[0., 0., 100.] + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([10., 0., 100.+1e-5]) + field_type = "secondary" # "secondary", "total" or "ppm" + frequencies = np.logspace(1, 8, 21) + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="both" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="imag" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="y", + field_type=field_type, component="both" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="y", + field_type=field_type, component="real" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="both" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="imag" + ) + ) + + I = 1. + a = 10. + source_list = [ + em1d.sources.HarmonicHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, I=I, a=a + ) + ] + + # Survey + survey = em1d.survey.EM1DSurveyFD(source_list) + + self.topo = topo + self.survey = survey self.showIt = False + self.frequencies = frequencies + self.thicknesses = thicknesses + self.nlayers = len(thicknesses)+1 + self.sigma_map = maps.ExpMap(nP=self.nlayers) - def test_EM1DFDJvec_Layers(self): + sim = em1d.simulation.EM1DFMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=self.sigma_map, topo=self.topo + ) - I = 1e0 - a = 1e1 - self.prob.survey.I = I - self.prob.survey.a = a + self.sim = sim + + def test_EM1DFDJvec_Layers(self): - sig_half = 0.01 - sig_blk = 0.1 - sig = np.ones(self.prob.survey.n_layer)*sig_half - sig[3] = sig_blk + sigma_half = 0.01 + sigma_blk = 0.1 + sig = np.ones(self.nlayers)*sigma_half + sig[3] = sigma_blk m_1D = np.log(sig) - Hz = self.prob.forward(m_1D, output_type='response') - dHzdsig = self.prob.forward( + Hz = self.sim.dpred(m_1D) + dHzdsig = self.sim.compute_integral( m_1D, output_type='sensitivity_sigma' ) def fwdfun(m): - resp = self.prob.survey.dpred(m) + resp = self.sim.dpred(m) return resp # return Hz def jacfun(m, dm): - Jvec = self.prob.Jvec(m, dm) + Jvec = self.sim.Jvec(m, dm) return Jvec dm = m_1D*0.5 derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)] - passed = Tests.checkDerivative( + passed = tests.checkDerivative( derChk, m_1D, num=4, dx=dm, plotIt=False, eps=1e-15 ) if self.showIt is True: ilay = 3 - temp_r = Utils.mkvc((dHzdsig[:, ilay].copy()).real) - temp_i = Utils.mkvc((dHzdsig[:, ilay].copy()).imag) - frequency = Utils.mkvc(self.prob.survey.frequency) + temp_r = mkvc((dHzdsig[:, ilay].copy()).real) + temp_i = mkvc((dHzdsig[:, ilay].copy()).imag) + frequency = mkvc(self.prob.survey.frequency) plt.loglog(frequency[temp_r > 0], temp_r[temp_r > 0], 'b.-') plt.loglog(frequency[temp_r < 0], -temp_r[temp_r < 0], 'b.--') @@ -97,33 +131,28 @@ def jacfun(m, dm): def test_EM1DFDJtvec_Layers(self): - I = 1e0 - a = 1e1 - self.prob.survey.I = I - self.prob.survey.a = a - - sig_half = 0.01 - sig_blk = 0.1 - sig = np.ones(self.prob.survey.n_layer)*sig_half - sig[3] = sig_blk + sigma_half = 0.01 + sigma_blk = 0.1 + sig = np.ones(self.nlayers)*sigma_half + sig[3] = sigma_blk m_true = np.log(sig) - dobs = self.prob.survey.dpred(m_true) + dobs = self.sim.dpred(m_true) m_ini = np.log( - np.ones(self.prob.survey.n_layer)*sig_half + np.ones(self.nlayers)*sigma_half ) - resp_ini = self.prob.survey.dpred(m_ini) + resp_ini = self.sim.dpred(m_ini) dr = resp_ini-dobs def misfit(m, dobs): - dpred = self.survey.dpred(m) + dpred = self.sim.dpred(m) misfit = 0.5*np.linalg.norm(dpred-dobs)**2 - dmisfit = self.prob.Jtvec(m, dr) + dmisfit = self.sim.Jtvec(m, dr) return misfit, dmisfit derChk = lambda m: misfit(m, dobs) - passed = Tests.checkDerivative( + passed = tests.checkDerivative( derChk, m_ini, num=4, plotIt=False, eps=1e-27 ) self.assertTrue(passed) @@ -131,5 +160,139 @@ def misfit(m, dobs): print ("EM1DFD-layers Jtvec works") +class EM1D_FD_Jac_layers_ProblemTests_Height(unittest.TestCase): + + def setUp(self): + + topo = np.r_[0., 0., 100.] + + src_location = np.array([0., 0., 100.+20.]) + rx_location = np.array([10., 0., 100.+20.]) + field_type = "secondary" # "secondary", "total" or "ppm" + frequencies = np.logspace(1, 8, 21) + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="both" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="both" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="x", + field_type=field_type, component="imag" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="y", + field_type=field_type, component="imag" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="both" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + rx_location, frequencies, orientation="z", + field_type=field_type, component="imag" + ) + ) + + I = 1. + a = 10. + source_list = [ + em1d.sources.HarmonicHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, I=I, a=a + ) + ] + + # Survey + survey = em1d.survey.EM1DSurveyFD(source_list) + + wires = maps.Wires(('sigma', 1),('height', 1)) + expmap = maps.ExpMap(nP=1) + sigma_map = expmap * wires.sigma + + self.topo = topo + self.survey = survey + self.showIt = False + self.frequencies = frequencies + self.nlayers = 1 + self.sigma_map = sigma_map + self.h_map = wires.height + + sim = em1d.simulation.EM1DFMSimulation( + survey=self.survey, + sigmaMap=self.sigma_map, hMap=wires.height, topo=self.topo + ) + + self.sim = sim + + def test_EM1DFDJvec_Layers(self): + + sigma_half = 0.01 + height = 20. + + m_1D = np.r_[np.log(sigma_half), height] + + def fwdfun(m): + resp = self.sim.dpred(m) + return resp + # return Hz + + def jacfun(m, dm): + Jvec = self.sim.Jvec(m, dm) + return Jvec + + dm = m_1D*0.5 + derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)] + passed = tests.checkDerivative( + derChk, m_1D, num=4, dx=dm, plotIt=False, eps=1e-15 + ) + + if passed: + print ("EM1DFD - Jvec with height works") + + def test_EM1DFDJtvec_Layers(self): + + sigma_half = 0.01 + height = 20. + + m_true = np.r_[np.log(sigma_half), height] + + dobs = self.sim.dpred(m_true) + + m_ini = m_true * 1.2 + resp_ini = self.sim.dpred(m_ini) + dr = resp_ini-dobs + + def misfit(m, dobs): + dpred = self.sim.dpred(m) + misfit = 0.5*np.linalg.norm(dpred-dobs)**2 + dmisfit = self.sim.Jtvec(m, dr) + return misfit, dmisfit + + derChk = lambda m: misfit(m, dobs) + passed = tests.checkDerivative( + derChk, m_ini, num=4, plotIt=False, eps=1e-27 + ) + self.assertTrue(passed) + if passed: + print ("EM1DFD - Jtvec with height works") + + + if __name__ == '__main__': unittest.main() diff --git a/tests/testEM1D_TD_dual_moment_fwd.py b/tests/testEM1D_TD_dual_moment_fwd.py index 75d65e3..98a9356 100644 --- a/tests/testEM1D_TD_dual_moment_fwd.py +++ b/tests/testEM1D_TD_dual_moment_fwd.py @@ -1,10 +1,10 @@ import unittest -from SimPEG import Mesh, Maps, Utils +from SimPEG import maps import matplotlib.pyplot as plt -from simpegEM1D import ( - EM1D, EM1DSurveyTD, EM1DAnalytics, piecewise_pulse, set_mesh_1d, - skytem_HM_2015, skytem_LM_2015, get_vertical_discretization_time -) +import simpegEM1D as em1d +from simpegEM1D.known_waveforms import piecewise_ramp, piecewise_pulse +from simpegEM1D.analytics import * +from simpegEM1D import skytem_HM_2015, skytem_LM_2015 import numpy as np from scipy import io from scipy.interpolate import interp1d @@ -19,92 +19,104 @@ def setUp(self): time_HM = wave_HM.time_gate_center[0::2] time_LM = wave_LM.time_gate_center[0::2] - hz = get_vertical_discretization_time( - np.unique(np.r_[time_HM, time_LM]), facter_tmax=0.5, factor_tmin=10. + + source_location = np.array([0., 0., 0.]) + source_orientation = "z" # "x", "y" or "z" + source_current = 1. + source_radius = 10. + moment_amplitude=1. + + receiver_location = np.array([10., 0., 0.]) + receiver_orientation = "z" # "x", "y" or "z" + field_type = "secondary" # "secondary", "total" or "ppm" + + times = np.logspace(-5, -2, 41) + + # Receiver list + rx = em1d.receivers.TimeDomainPointReceiver( + receiver_location, + times=time_HM, + times_dual_moment=time_LM, + orientation=receiver_orientation, + component="dbdt" ) - mesh1D = set_mesh_1d(hz) - depth = -mesh1D.gridN[:-1] - LocSigZ = -mesh1D.gridCC + receiver_list = [rx] + + # Sources time_input_currents_HM = wave_HM.current_times[-7:] input_currents_HM = wave_HM.currents[-7:] time_input_currents_LM = wave_LM.current_times[-13:] input_currents_LM = wave_LM.currents[-13:] - TDsurvey = EM1DSurveyTD( - rx_location=np.array([0., 0., 100.]), - src_location=np.array([0., 0., 100.]), - topo=np.r_[0., 0., 100.], - depth=depth, - rx_type='dBzdt', - wave_type='general', - src_type='CircularLoop', - a=13., - I=1., - time=time_HM, + + src = em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, + location=source_location, + I=source_current, + a=source_radius, + wave_type="general", + moment_type='dual', time_input_currents=time_input_currents_HM, input_currents=input_currents_HM, - n_pulse=2, - base_frequency=25., - use_lowpass_filter=False, - high_cut_frequency=7e4, - moment_type='dual', - time_dual_moment=time_HM, - time_input_currents_dual_moment=time_input_currents_LM, - input_currents_dual_moment=input_currents_LM, - base_frequency_dual_moment=210, + n_pulse = 1, + base_frequency = 25., + time_input_currents_dual_moment = time_input_currents_LM, + input_currents_dual_moment = input_currents_LM, + base_frequency_dual_moment = 210 ) + source_list = [src] - sig_half=1e-2 - chi_half=0. - - expmap = Maps.ExpMap(mesh1D) - m_1D = np.log(np.ones(TDsurvey.n_layer)*sig_half) - chi = np.zeros(TDsurvey.n_layer) + thicknesses = np.ones(3) + sigma = 1e-2 + n_layer = thicknesses.size + 1 - prob = EM1D( - mesh1D, sigmaMap=expmap, chi=chi + sigma_model = sigma * np.ones(n_layer) + survey = em1d.survey.EM1DSurveyTD(source_list) + model_mapping = maps.IdentityMap(nP=n_layer) + simulation = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, ) - prob.pair(TDsurvey) - self.survey = TDsurvey - self.prob = prob - self.mesh1D = mesh1D + + self.survey = survey + self.simulation = simulation self.showIt = False - self.chi = chi - self.m_1D = m_1D - self.sig_half = sig_half - self.expmap = expmap + self.sigma_model = sigma_model + self.sigma_halfspace = sigma def test_em1dtd_circular_loop_single_pulse(self): - dBzdtTD = self.survey.dpred(self.m_1D) - dBzdtTD_HM = dBzdtTD[:self.survey.n_time] - dBzdtTD_LM = dBzdtTD[self.survey.n_time:] + src = self.survey.srcList[0] + rx = src.rxList[0] + dBzdtTD = self.simulation.dpred(self.sigma_model) + dBzdtTD_HM = dBzdtTD[:rx.times.size] + dBzdtTD_LM = dBzdtTD[rx.times.size:] def step_func_dBzdt(time): - return EM1DAnalytics.dBzdtAnalCircT( - self.survey.a, time, self.sig_half + return dBzdt_horizontal_circular_loop( + src.a, time, self.sigma_halfspace ) dBzdtTD_analytic_HM = piecewise_pulse( - step_func_dBzdt, self.survey.time, - self.survey.time_input_currents, - self.survey.input_currents, - self.survey.period + step_func_dBzdt, rx.times, + src.time_input_currents, + src.input_currents, + src.period ) dBzdtTD_analytic_LM = piecewise_pulse( - step_func_dBzdt, self.survey.time, - self.survey.time_input_currents_dual_moment, - self.survey.input_currents_dual_moment, - self.survey.period_dual_moment + step_func_dBzdt, rx.times_dual_moment, + src.time_input_currents_dual_moment, + src.input_currents_dual_moment, + src.period_dual_moment ) + if self.showIt: - plt.loglog(self.survey.time, -dBzdtTD_HM) - plt.loglog(self.survey.time, -dBzdtTD_LM) - plt.loglog(self.survey.time, -dBzdtTD_analytic_HM, 'x') - plt.loglog(self.survey.time, -dBzdtTD_analytic_LM, 'x') + plt.loglog(rx.times, -dBzdtTD_HM) + plt.loglog(rx.times_dual_moment, -dBzdtTD_LM) + plt.loglog(rx.times, -dBzdtTD_analytic_HM, 'x') + plt.loglog(rx.times_dual_moment, -dBzdtTD_analytic_LM, 'x') plt.show() err = ( diff --git a/tests/testEM1D_TD_general_fwd.py b/tests/testEM1D_TD_general_fwd.py index 1047873..6e3443a 100644 --- a/tests/testEM1D_TD_general_fwd.py +++ b/tests/testEM1D_TD_general_fwd.py @@ -1,8 +1,11 @@ import unittest -from SimPEG import Mesh, Maps, Utils +from SimPEG import maps +from SimPEG.utils import mkvc import matplotlib.pyplot as plt -from simpegEM1D import EM1D, EM1DSurveyTD, EM1DAnalytics -from simpegEM1D.Waveforms import piecewise_ramp +import simpegEM1D as em1d +from simpegEM1D.known_waveforms import piecewise_ramp +from simpegEM1D.analytics import * +from simpegEM1D.waveforms import TriangleFun import numpy as np from scipy import io from scipy.interpolate import interp1d @@ -11,114 +14,134 @@ class EM1D_TD_FwdProblemTests(unittest.TestCase): def setUp(self): - + nearthick = np.logspace(-1, 1, 5) deepthick = np.logspace(1, 2, 10) - hx = np.r_[nearthick, deepthick] - mesh1D = Mesh.TensorMesh([hx], [0.]) - depth = -mesh1D.gridN[:-1] - LocSigZ = -mesh1D.gridCC - - # Triangular waveform - time_input_currents = np.r_[0., 5.5*1e-4, 1.1*1e-3] - input_currents = np.r_[0., 1., 0.] - - TDsurvey = EM1DSurveyTD( - rx_location=np.array([0., 0., 100.+1e-5]), - src_location=np.array([0., 0., 100.+1e-5]), - topo=np.r_[0., 0., 100.], - depth=depth, - field_type='secondary', - rx_type='Bz', - wave_type='general', - time_input_currents=time_input_currents, - input_currents=input_currents, - n_pulse=2, - base_frequency=25., - time=np.logspace(-5, -2, 31), - src_type='CircularLoop', - I=1e0, - a=2e1 + thicknesses = np.r_[nearthick, deepthick] + topo = np.r_[0., 0., 100.] + a = 20. + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([0., 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + times = np.logspace(-5, -2, 31) + + # Receiver list + receiver_list = [] + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="b" + ) ) - - sig_half = 1e-4 - chi_half = 0. - - expmap = Maps.ExpMap(mesh1D) - m_1D = np.log(np.ones(TDsurvey.n_layer)*sig_half) - chi = np.zeros(TDsurvey.n_layer) - - prob = EM1D( - mesh1D, sigmaMap=expmap, chi=chi + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="dbdt" + ) ) - prob.pair(TDsurvey) - - self.survey = TDsurvey - self.prob = prob - self.mesh1D = mesh1D - self.showIt = True - self.chi = chi - self.m_1D = m_1D - self.sig_half = sig_half - self.expmap = expmap + + time_input_currents = np.r_[-np.logspace(-2, -5, 31), 0.] + input_currents = TriangleFun(time_input_currents+0.01, 5e-3, 0.01) + source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, + location=src_location, + a=a, I=1., + wave_type="general", + time_input_currents=time_input_currents, + input_currents=input_currents, + n_pulse = 1, + base_frequency = 25., + use_lowpass_filter=False, + high_cut_frequency=210*1e3 + ) + ] + + # Survey + survey = em1d.survey.EM1DSurveyTD(source_list) + + sigma = 1e-2 + + self.topo = topo + self.survey = survey + self.showIt = False + self.sigma = sigma + self.times = times + self.thicknesses = thicknesses + self.nlayers = len(thicknesses)+1 + self.a = a + def test_em1dtd_circular_loop_single_pulse(self): - f = self.prob.forward(self.m_1D) - BzTD = self.prob.survey.projectFields(f) - - def step_func_Bzdt(time): - return EM1DAnalytics.BzAnalCircT( - self.survey.a, time, self.sig_half + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) +# f = sim.compute_integral(m_1D) + d = sim.dpred(m_1D) + bz = d[0:len(self.times)] + dbdt = d[len(self.times):] + + def step_func_Bzt(times): + return Bz_horizontal_circular_loop( + self.a, times, self.sigma ) - BzTD_analytic = piecewise_ramp( - step_func_Bzdt, self.survey.time, - self.survey.time_input_currents, self.survey.input_currents + bz_analytic = piecewise_ramp( + step_func_Bzt, self.times, + sim.survey.source_list[0].time_input_currents, + sim.survey.source_list[0].input_currents ) if self.showIt: plt.subplot(121) - plt.loglog(self.survey.time, BzTD, 'b*') - plt.loglog(self.survey.time, BzTD_analytic, 'b') + plt.loglog(self.times, bz, 'b*') + plt.loglog(self.times, bz_analytic, 'b') plt.subplot(122) plt.loglog( - self.survey.time, abs((BzTD-BzTD_analytic)/BzTD_analytic), 'r:' + self.times, abs((bz-bz_analytic)/bz_analytic), 'r:' ) plt.show() - - err = np.linalg.norm(BzTD-BzTD_analytic)/np.linalg.norm(BzTD_analytic) + + err = np.linalg.norm(bz-bz_analytic)/np.linalg.norm(bz_analytic) print ('Bz error = ', err) self.assertTrue(err < 6e-2) - self.survey.rx_type = 'dBzdt' - dBzdtTD = self.prob.survey.projectFields(f) - - def step_func_dBzdt(time): - return EM1DAnalytics.dBzdtAnalCircT( - self.survey.a, time, self.sig_half + def step_func_dBzdt(times): + return dBzdt_horizontal_circular_loop( + self.a, times, self.sigma ) - dBzdtTD_analytic = piecewise_ramp( - step_func_dBzdt, self.survey.time, - self.survey.time_input_currents, self.survey.input_currents + dbdt_analytic = piecewise_ramp( + step_func_dBzdt, self.times, + sim.survey.source_list[0].time_input_currents, + sim.survey.source_list[0].input_currents ) + if self.showIt: plt.subplot(121) - plt.loglog(self.survey.time, abs(dBzdtTD), 'b*') + plt.loglog(self.times, abs(dbdt), 'b*') plt.loglog( - self.survey.time, - abs(dBzdtTD_analytic), 'b' + self.times, + abs(dbdt_analytic), 'b' ) plt.subplot(122) plt.loglog( - self.survey.time, - abs((dBzdtTD-dBzdtTD_analytic)/dBzdtTD_analytic), 'r:' + self.times, + abs((dbdt-dbdt_analytic)/dbdt_analytic), 'r:' ) plt.show() err = ( - np.linalg.norm(dBzdtTD-dBzdtTD_analytic)/ - np.linalg.norm(dBzdtTD_analytic) + np.linalg.norm(dbdt-dbdt_analytic)/ + np.linalg.norm(dbdt_analytic) ) print ('dBzdt error = ', err) diff --git a/tests/testEM1D_TD_general_jac_layers.py b/tests/testEM1D_TD_general_jac_layers.py index 4e2cc60..d699816 100644 --- a/tests/testEM1D_TD_general_jac_layers.py +++ b/tests/testEM1D_TD_general_jac_layers.py @@ -2,79 +2,95 @@ from SimPEG import * import numpy as np import matplotlib.pyplot as plt -from simpegEM1D import EM1D, EM1DSurveyTD -from simpegEM1D.Waveform import TriangleFun, TriangleFunDeriv +import simpegEM1D as em1d +from simpegEM1D.waveforms import TriangleFun, TriangleFunDeriv class EM1D_TD_general_Jac_layers_ProblemTests(unittest.TestCase): - def setUp(self): + def setUp(self): nearthick = np.logspace(-1, 1, 5) deepthick = np.logspace(1, 2, 10) - hx = np.r_[nearthick, deepthick] - mesh1D = Mesh.TensorMesh([hx], [0.]) - depth = -mesh1D.gridN[:-1] - LocSigZ = -mesh1D.gridCC - - # Triangular waveform - time_input_currents = np.r_[0., 5.5*1e-4, 1.1*1e-3] - input_currents = np.r_[0., 1., 0.] - - TDsurvey = EM1DSurveyTD( - rx_location=np.array([0., 0., 100.+1e-5]), - src_location=np.array([0., 0., 100.+1e-5]), - topo=np.r_[0., 0., 100.], - depth=depth, - field_type='secondary', - rx_type='Bz', - wave_type='general', - time_input_currents=time_input_currents, - input_currents=input_currents, - n_pulse=2, - base_frequency=25., - time=np.logspace(-5, -2, 31), - src_type='CircularLoop', - I=1e0, - a=2e1 + thicknesses = np.r_[nearthick, deepthick] + topo = np.r_[0., 0., 100.] + a = 20. + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([0., 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + times = np.logspace(-5, -2, 31) + + # Receiver list + receiver_list = [] + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="b" + ) ) - - sig_half = 1e-4 - chi_half = 0. - - expmap = Maps.ExpMap(mesh1D) - m_1D = np.log(np.ones(TDsurvey.n_layer)*sig_half) - chi = np.zeros(TDsurvey.n_layer) - - prob = EM1D( - mesh1D, sigmaMap=expmap, chi=chi + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="dbdt" + ) ) - prob.pair(TDsurvey) - - self.survey = TDsurvey - self.prob = prob - self.mesh1D = mesh1D + + time_input_currents = np.r_[-np.logspace(-2, -5, 31), 0.] + input_currents = TriangleFun(time_input_currents+0.01, 5e-3, 0.01) + source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, + location=src_location, + a=a, I=1., + wave_type="general", + time_input_currents=time_input_currents, + input_currents=input_currents, + n_pulse = 1, + base_frequency = 25., + use_lowpass_filter=False, + high_cut_frequency=210*1e3 + ) + ] + + # Survey + survey = em1d.survey.EM1DSurveyTD(source_list) + + sigma = 1e-2 + + self.topo = topo + self.survey = survey self.showIt = False - self.chi = chi - self.m_1D = m_1D - self.sig_half = sig_half - self.expmap = expmap + self.sigma = sigma + self.times = times + self.thicknesses = thicknesses + self.nlayers = len(thicknesses)+1 + self.a = a - def test_EM1DTDJvec_Layers(self): - sig = np.ones(self.prob.survey.n_layer)*self.sig_half - m_1D = np.log(sig) + def test_EM1DTDJvec_Layers(self): + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) + def fwdfun(m): - resp = self.prob.survey.dpred(m) + resp = sim.dpred(m) return resp def jacfun(m, dm): - Jvec = self.prob.Jvec(m, dm) + Jvec = sim.Jvec(m, dm) return Jvec dm = m_1D*0.5 derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)] - passed = Tests.checkDerivative( + passed = tests.checkDerivative( derChk, m_1D, num=4, dx=dm, plotIt=False, eps=1e-15 ) @@ -83,24 +99,31 @@ def jacfun(m, dm): def test_EM1DTDJtvec_Layers(self): - sig_blk = 0.1 - sig = np.ones(self.prob.survey.n_layer)*self.sig_half - sig[3] = sig_blk - - m_true = np.log(sig) - dobs = self.prob.survey.dpred(m_true) - m_ini = np.log(np.ones(self.prob.survey.n_layer)*self.sig_half) - resp_ini = self.prob.survey.dpred(m_ini) + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + sigma_layer = 0.1 + sigma = np.ones(self.nlayers)*self.sigma + sigma[3] = sigma_layer + m_true = np.log(sigma) + + dobs = sim.dpred(m_true) + + m_ini = np.log(np.ones(self.nlayers)*self.sigma) + resp_ini = sim.dpred(m_ini) dr = resp_ini-dobs def misfit(m, dobs): - dpred = self.survey.dpred(m) + dpred = sim.dpred(m) misfit = 0.5*np.linalg.norm(dpred-dobs)**2 - dmisfit = self.prob.Jtvec(m, dr) + dmisfit = sim.Jtvec(m, dr) return misfit, dmisfit derChk = lambda m: misfit(m, dobs) - passed = Tests.checkDerivative( + passed = tests.checkDerivative( derChk, m_ini, num=4, plotIt=False, eps=1e-26 ) self.assertTrue(passed) diff --git a/tests/testEM1D_TD_off_fwd.py b/tests/testEM1D_TD_off_fwd.py index 3d8ad10..90556bb 100644 --- a/tests/testEM1D_TD_off_fwd.py +++ b/tests/testEM1D_TD_off_fwd.py @@ -1,10 +1,11 @@ import unittest import numpy as np -from SimPEG import Maps, Utils, Mesh +from SimPEG import maps, utils import matplotlib.pyplot as plt -from simpegEM1D import EM1D, EM1DAnalytics, EM1DSurveyTD +import simpegEM1D as em1d from scipy import io -from simpegEM1D.DigFilter import setFrequency +from simpegEM1D.supporting_functions.digital_filter import setFrequency +from simpegEM1D.analytics import * class EM1D_TD_FwdProblemTests(unittest.TestCase): @@ -13,81 +14,102 @@ def setUp(self): nearthick = np.logspace(-1, 1, 5) deepthick = np.logspace(1, 2, 10) - hx = np.r_[nearthick, deepthick] - mesh1D = Mesh.TensorMesh([hx], [0.]) - depth = -mesh1D.gridN[:-1] - LocSigZ = -mesh1D.gridCC - - TDsurvey = EM1DSurveyTD( - rx_location=np.array([0., 0., 100.+1e-5]), - src_location=np.array([0., 0., 100.+1e-5]), - topo=np.r_[0., 0., 100.], - depth=depth, - field_type='secondary', - rx_type='Bz', - wave_type='stepoff', - time=np.logspace(-5, -2, 64), - src_type='CircularLoop', - I=1e0, - a=1e1 + thicknesses = np.r_[nearthick, deepthick] + topo = np.r_[0., 0., 100.] + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([0., 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + times = np.logspace(-5, -2, 31) + a = 20. + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="b" + ) ) - - sig_half = 1e-2 - chi_half = 0. - - expmap = Maps.ExpMap(mesh1D) - tau = 1e-3 * np.ones(TDsurvey.n_layer) - eta = 2e-1 * np.ones(TDsurvey.n_layer) - c = 1. * np.ones(TDsurvey.n_layer) - m_1D = np.log(np.ones(TDsurvey.n_layer)*sig_half) - chi = np.zeros(TDsurvey.n_layer) - - prob = EM1D( - mesh1D, sigmaMap=expmap, chi=chi + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="dbdt" + ) ) - prob.pair(TDsurvey) - self.survey = TDsurvey - self.prob = prob - self.mesh1D = mesh1D + source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, + a=a, I=1., wave_type="stepoff" + ) + ] + # Survey + survey = em1d.survey.EM1DSurveyTD(source_list) + + sigma = 1e-2 + chi = 0. + tau = 1e-3 + eta = 2e-1 + c = 1. + dchi = 0.05 + tau1 = 1e-10 + tau2 = 1e2 + + self.topo = topo + self.survey = survey self.showIt = False + self.sigma = sigma self.tau = tau self.eta = eta self.c = c self.chi = chi - self.m_1D = m_1D - self.sig_half = sig_half - self.expmap = expmap + self.dchi = dchi + self.tau1 = tau1 + self.tau2 = tau2 + self.times = times + self.thicknesses = thicknesses + self.nlayers = len(thicknesses)+1 + self.a = a def test_EM1DTDfwd_CirLoop_RealCond(self): - BzTD = self.prob.survey.dpred(self.m_1D) - Bzanal = EM1DAnalytics.BzAnalCircT( - self.survey.a, self.survey.time, self.sig_half + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) + d = sim.dpred(m_1D) + bz = d[0:len(self.times)] + dbdt = d[len(self.times):] + + bzanal = Bz_horizontal_circular_loop( + self.a, self.times, self.sigma + ) + + dbdtanal = dBzdt_horizontal_circular_loop( + self.a, self.times, self.sigma ) if self.showIt is True: - plt.loglog(self.survey.time, (BzTD), 'b') - plt.loglog(self.survey.time, (Bzanal), 'b.') + plt.loglog(self.times, (bz), 'b') + plt.loglog(self.times, (bzanal), 'b.') plt.show() - err = np.linalg.norm(BzTD-Bzanal)/np.linalg.norm(Bzanal) + err = np.linalg.norm(bz-bzanal)/np.linalg.norm(bzanal) print ('Bz error = ', err) self.assertTrue(err < 1e-2) - self.survey.rx_type = 'dBzdt' - dBzdtTD = self.prob.survey.dpred(self.m_1D) - dBzdtanal = EM1DAnalytics.dBzdtAnalCircT( - self.survey.a, self.survey.time, self.sig_half - ) - if self.showIt is True: - plt.loglog(self.survey.time, -(dBzdtTD), 'b-') - plt.loglog(self.survey.time, -(dBzdtanal), 'b.') + plt.loglog(self.times, -(dbdt), 'b-') + plt.loglog(self.times, -(dbdtanal), 'b.') plt.show() - err = np.linalg.norm(dBzdtTD-dBzdtanal)/np.linalg.norm(dBzdtanal) + err = np.linalg.norm(dbdt-dbdtanal)/np.linalg.norm(dbdtanal) print ('dBzdt error = ', err) self.assertTrue(err < 5e-2) @@ -95,55 +117,107 @@ def test_EM1DTDfwd_CirLoop_RealCond(self): def test_EM1DTDfwd_CirLoop_ComplexCond(self): - if self.prob.ispaired: - self.prob.unpair() - if self.survey.ispaired: - self.survey.unpair() + sigma_map = maps.IdentityMap(nP=self.nlayers) + chi = np.zeros(self.nlayers) + tau = self.tau*np.ones(self.nlayers) + c = self.c*np.ones(self.nlayers) + eta = self.eta*np.ones(self.nlayers) - self.prob = EM1D( - self.mesh1D, sigmaMap=self.expmap, chi=self.chi, - eta=self.eta, tau=self.tau, c=self.c + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo, + eta=eta, tau=tau, c=c, chi=chi ) - self.prob.pair(self.survey) - BzTD = self.prob.survey.dpred(self.m_1D) + m_1D = np.ones(self.nlayers)*self.sigma + d = sim.dpred(m_1D) + bz = d[0:len(self.times)] + dbdt = d[len(self.times):] - w_, _, omega_int = setFrequency(self.survey.time) - sigCole = EM1DAnalytics.ColeCole( - omega_int/(2*np.pi), self.sig_half, - self.eta[0], self.tau[0], self.c[0] + w_, _, omega_int = setFrequency(self.times) + sigCole = ColeCole( + omega_int/(2*np.pi), self.sigma, + self.eta, self.tau, self.c ) - Bzanal = EM1DAnalytics.BzAnalCircTCole( - self.survey.a, self.survey.time, sigCole + bzanal = Bz_horizontal_circular_loop_ColeCole( + self.a, self.times, sigCole ) if self.showIt is True: - plt.loglog(self.survey.time, (BzTD), 'b') - plt.loglog(self.survey.time, (Bzanal), 'b*') + plt.loglog(self.times, (bz), 'b') + plt.loglog(self.times, (bzanal), 'b*') plt.show() - err = np.linalg.norm(BzTD-Bzanal)/np.linalg.norm(Bzanal) + err = np.linalg.norm(bz-bzanal)/np.linalg.norm(bzanal) print ('Bz error = ', err) self.assertTrue(err < 1e-2) - self.survey.rx_type = 'dBzdt' - dBzdtTD = self.survey.dpred(self.m_1D) - dBzdtanal = EM1DAnalytics.dBzdtAnalCircTCole( - self.survey.a, self.survey.time, sigCole + dbdtanal = dBzdt_horizontal_circular_loop_ColeCole( + self.a, self.times, sigCole ) if self.showIt is True: - plt.loglog(self.survey.time, - dBzdtTD, 'b') - plt.loglog(self.survey.time, - dBzdtanal, 'b*') + plt.loglog(self.times, - dbdt, 'b') + plt.loglog(self.times, - dbdtanal, 'b*') plt.show() - err = np.linalg.norm(dBzdtTD-dBzdtanal)/np.linalg.norm(dBzdtanal) + err = np.linalg.norm(dbdt-dbdtanal)/np.linalg.norm(dbdtanal) print ('dBzdt error = ', err) self.assertTrue(err < 5e-2) print ("EM1DTD-CirculurLoop for Complex conductivity works") + + def test_EM1DTDfwd_CirLoop_VRM(self): + + sigma_map = maps.IdentityMap(nP=self.nlayers) + chi = np.zeros(self.nlayers) + dchi = self.dchi*np.ones(self.nlayers) + tau1 = self.tau1*np.ones(self.nlayers) + tau2 = self.tau2*np.ones(self.nlayers) + + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo, + chi=chi, dchi=dchi, tau1=tau1, tau2=tau2, + time_filter='key_201_CosSin_2012' + ) + + m_1D = 1e-8 * np.ones(self.nlayers) + d = sim.dpred(m_1D) + bz = d[0:len(self.times)] + dbdt = d[len(self.times):] + + bzanal = Bz_horizontal_circular_loop_VRM( + self.a, 1e-5, 1e-5, self.times, self.dchi, self.tau1, self.tau2 + ) + + if self.showIt is True: + + plt.loglog(self.times, (bz), 'b') + plt.loglog(self.times, (bzanal), 'b*') + plt.show() + + err = np.linalg.norm(bz-bzanal)/np.linalg.norm(bzanal) + print ('Bz error = ', err) + self.assertTrue(err < 5e-2) + + dbdtanal = dBzdt_horizontal_circular_loop_VRM( + self.a, 1e-5, 1e-5, self.times, self.dchi, self.tau1, self.tau2 + ) + + if self.showIt is True: + + plt.loglog(self.times, - dbdt, 'b') + plt.loglog(self.times, - dbdtanal, 'b*') + plt.show() + + err = np.linalg.norm(dbdt-dbdtanal)/np.linalg.norm(dbdtanal) + print ('dBzdt error = ', err) + self.assertTrue(err < 1e-2) + print ("EM1DTD-CirculurLoop for viscous remanent magnetization works") + if __name__ == '__main__': unittest.main() diff --git a/tests/testEM1D_TD_off_jac_layers.py b/tests/testEM1D_TD_off_jac_layers.py index dd7d4f8..c29ae3b 100644 --- a/tests/testEM1D_TD_off_jac_layers.py +++ b/tests/testEM1D_TD_off_jac_layers.py @@ -1,7 +1,7 @@ import unittest -from SimPEG import Mesh, Utils, Maps, Tests +from SimPEG import * import matplotlib.pyplot as plt -from simpegEM1D import EM1D, EM1DSurveyTD +import simpegEM1D as em1d import numpy as np @@ -11,88 +11,228 @@ def setUp(self): nearthick = np.logspace(-1, 1, 5) deepthick = np.logspace(1, 2, 10) - hx = np.r_[nearthick, deepthick] - mesh1D = Mesh.TensorMesh([hx], [0.]) - depth = -mesh1D.gridN[:-1] - LocSigZ = -mesh1D.gridCC - - TDsurvey = EM1DSurveyTD( - rx_location=np.array([0., 0., 100.+50.]), - src_location=np.array([0., 0., 100.+50.]), - topo=np.r_[0., 0., 100.], - depth=depth, - field_type='secondary', - rx_type='dBzdt', - wave_type='stepoff', - time=np.logspace(-5, -2, 64), - src_type='CircularLoop', - I=1e0, - a=1e1 + thicknesses = np.r_[nearthick, deepthick] + topo = np.r_[0., 0., 100.] + + src_location = np.array([0., 0., 100.+1e-5]) + rx_location = np.array([0., 0., 100.+1e-5]) + receiver_orientation = "z" # "x", "y" or "z" + times = np.logspace(-5, -2, 31) + a = 20. + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="b" + ) ) + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="dbdt" + ) + ) + + source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, + a=a, I=1., wave_type="stepoff" + ) + ] + # Survey + survey = em1d.survey.EM1DSurveyTD(source_list) + + sigma = 1e-2 + chi = 0. + tau = 1e-3 + eta = 2e-1 + c = 1. + + self.topo = topo + self.survey = survey + self.showIt = False + self.sigma = sigma + self.tau = tau + self.eta = eta + self.c = c + self.chi = chi + self.times = times + self.thicknesses = thicknesses + self.nlayers = len(thicknesses)+1 + self.a = a - sig_half = 1e-2 - chi_half = 0. - expmap = Maps.ExpMap(mesh1D) - tau = 1e-3 * np.ones(TDsurvey.n_layer) - eta = 2e-1 * np.ones(TDsurvey.n_layer) - c = 1. * np.ones(TDsurvey.n_layer) - m_1D = np.log(np.ones(TDsurvey.n_layer)*sig_half) - chi = np.zeros(TDsurvey.n_layer) + def test_EM1DTDJvec_Layers(self): + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + m_1D = np.log(np.ones(self.nlayers)*self.sigma) + + def fwdfun(m): + resp = sim.dpred(m) + return resp - prob = EM1D( - mesh1D, sigmaMap=expmap, chi=chi + def jacfun(m, dm): + Jvec = sim.Jvec(m, dm) + return Jvec + + dm = m_1D*0.5 + derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)] + passed = tests.checkDerivative( + derChk, m_1D, num=4, dx=dm, plotIt=False, eps=1e-15 ) - prob.pair(TDsurvey) - self.survey = TDsurvey - self.prob = prob - self.mesh1D = mesh1D - self.showIt = True - self.m_1D = m_1D - self.sig_half = sig_half + if passed: + print ("EM1DTD-layers Jvec works") - def test_EM1DTDJvec_Layers(self): - sig = np.ones(self.prob.survey.n_layer)*self.sig_half - m_1D = np.log(sig) + def test_EM1DTDJtvec_Layers(self): + + sigma_map = maps.ExpMap(nP=self.nlayers) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, thicknesses=self.thicknesses, + sigmaMap=sigma_map, topo=self.topo + ) + + sigma_layer = 0.1 + sigma = np.ones(self.nlayers)*self.sigma + sigma[3] = sigma_layer + m_true = np.log(sigma) + + dobs = sim.dpred(m_true) + + m_ini = np.log(np.ones(self.nlayers)*self.sigma) + resp_ini = sim.dpred(m_ini) + dr = resp_ini-dobs + + def misfit(m, dobs): + dpred = sim.dpred(m) + misfit = 0.5*np.linalg.norm(dpred-dobs)**2 + dmisfit = sim.Jtvec(m, dr) + return misfit, dmisfit + + derChk = lambda m: misfit(m, dobs) + passed = tests.checkDerivative( + derChk, m_ini, num=4, plotIt=False, eps=1e-26 + ) + self.assertTrue(passed) + if passed: + print ("EM1DTD-layers Jtvec works") + + + +class EM1D_TD_Jac_layers_ProblemTests_Height(unittest.TestCase): + + def setUp(self): + + topo = np.r_[0., 0., 100.] + + src_location = np.array([0., 0., 100.+20.]) + rx_location = np.array([0., 0., 100.+20.]) + receiver_orientation = "z" # "x", "y" or "z" + times = np.logspace(-5, -2, 31) + a = 20. + + # Receiver list + receiver_list = [] + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="b" + ) + ) + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + rx_location, times, orientation=receiver_orientation, + component="dbdt" + ) + ) + + source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=src_location, + a=a, I=1., wave_type="stepoff" + ) + ] + # Survey + survey = em1d.survey.EM1DSurveyTD(source_list) + + wires = maps.Wires(('sigma', 1),('height', 1)) + expmap = maps.ExpMap(nP=1) + sigma_map = expmap * wires.sigma + + self.topo = topo + self.survey = survey + self.showIt = False + self.times = times + self.nlayers = 1 + self.a = a + self.sigma_map = sigma_map + self.h_map = wires.height + + + def test_EM1DTDJvec_Layers(self): + + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, + sigmaMap=self.sigma_map, hMap=self.h_map, topo=self.topo + ) + + sigma_half = 0.01 + height = 20. + + m_1D = np.r_[np.log(sigma_half), height] + def fwdfun(m): - resp = self.prob.survey.dpred(m) + resp = sim.dpred(m) return resp def jacfun(m, dm): - Jvec = self.prob.Jvec(m, dm) + Jvec = sim.Jvec(m, dm) return Jvec dm = m_1D*0.5 derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)] - passed = Tests.checkDerivative( + passed = tests.checkDerivative( derChk, m_1D, num=4, dx=dm, plotIt=False, eps=1e-15 ) if passed: print ("EM1DTD-layers Jvec works") - def test_EM1DTDJtvec_Layers(self): - sig_blk = 0.1 - sig = np.ones(self.prob.survey.n_layer)*self.sig_half - sig[3] = sig_blk + def test_EM1DTDJtvec_Layers(self): - m_true = np.log(sig) - dobs = self.prob.survey.dpred(m_true) - m_ini = np.log(np.ones(self.prob.survey.n_layer)*self.sig_half) - resp_ini = self.prob.survey.dpred(m_ini) + sim = em1d.simulation.EM1DTMSimulation( + survey=self.survey, + sigmaMap=self.sigma_map, hMap=self.h_map, topo=self.topo + ) + + sigma_half = 0.01 + height = 20. + + m_true = np.r_[np.log(sigma_half), height] + + dobs = sim.dpred(m_true) + + m_ini = 1.2 * np.r_[np.log(sigma_half), height] + resp_ini = sim.dpred(m_ini) dr = resp_ini-dobs def misfit(m, dobs): - dpred = self.survey.dpred(m) + dpred = sim.dpred(m) misfit = 0.5*np.linalg.norm(dpred-dobs)**2 - dmisfit = self.prob.Jtvec(m, dr) + dmisfit = sim.Jtvec(m, dr) return misfit, dmisfit derChk = lambda m: misfit(m, dobs) - passed = Tests.checkDerivative( + passed = tests.checkDerivative( derChk, m_ini, num=4, plotIt=False, eps=1e-26 ) self.assertTrue(passed) diff --git a/tests/testGlobalEM1D_FD_jac_layers.py b/tests/testGlobalEM1D_FD_jac_layers.py index 30c3572..2cf7ee8 100644 --- a/tests/testGlobalEM1D_FD_jac_layers.py +++ b/tests/testGlobalEM1D_FD_jac_layers.py @@ -1,15 +1,11 @@ from __future__ import print_function import unittest import numpy as np -from simpegEM1D import ( - GlobalEM1DProblemFD, GlobalEM1DSurveyFD, - get_vertical_discretization_frequency -) -from SimPEG import ( - regularization, Inversion, InvProblem, - DataMisfit, Utils, Mesh, Maps, Optimization, - Tests -) +import simpegEM1D as em1d +from simpegEM1D.utils import get_vertical_discretization_frequency +from SimPEG import * +from discretize import TensorMesh +from pymatsolver import PardisoSolver np.random.seed(41) @@ -17,14 +13,19 @@ class GlobalEM1DFD(unittest.TestCase): def setUp(self, parallel=True): - frequency = np.array([900, 7200, 56000], dtype=float) - hz = get_vertical_discretization_frequency( - frequency, sigma_background=1./10. + + n_layer = 20 + frequencies = np.array([900, 7200, 56000], dtype=float) + thicknesses = get_vertical_discretization_frequency( + frequencies, sigma_background=0.1, n_layer=n_layer-1 ) + n_sounding = 10 dx = 20. hx = np.ones(n_sounding) * dx - mesh = Mesh.TensorMesh([hx, hz], x0='00') + hz = np.r_[thicknesses, thicknesses[-1]] + + mesh = TensorMesh([hx, hz], x0='00') inds = mesh.gridCC[:, 1] < 25 inds_1 = mesh.gridCC[:, 1] < 50 sigma = np.ones(mesh.nC) * 1./100. @@ -36,51 +37,83 @@ def setUp(self, parallel=True): x = mesh.vectorCCx y = np.zeros_like(x) z = np.ones_like(x) * 30. - rx_locations = np.c_[x, y, z] - src_locations = np.c_[x, y, z] + receiver_locations = np.c_[x+8., y, z] + source_locations = np.c_[x, y, z] topo = np.c_[x, y, z-30.].astype(float) - mapping = Maps.ExpMap(mesh) - survey = GlobalEM1DSurveyFD( - rx_locations=rx_locations, - src_locations=src_locations, - frequency=frequency, - offset=np.ones_like(frequency) * 8., - src_type="VMD", - rx_type="Hz", - field_type='secondary', - topo=topo - ) - problem = GlobalEM1DProblemFD( - [], sigmaMap=mapping, hz=hz, - parallel=parallel, n_cpu=2 + sigma_map = maps.ExpMap(mesh) + + source_list = [] + + for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [] + + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation="z", + field_type="secondary", component="both" + ) + ) + # receiver_list.append( + # em1d.receivers.HarmonicPointReceiver( + # receiver_location, frequencies, orientation="z", + # field_type="secondary", component="imag" + # ) + # ) + + source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, + orientation="z", moment_amplitude=1. + ) + ) + + survey = em1d.survey.EM1DSurveyFD(source_list) + + simulation = em1d.simulation.StitchedEM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=sigma_map, + topo=topo, parallel=False, n_cpu=2, verbose=False, Solver=PardisoSolver ) - problem.pair(survey) - survey.makeSyntheticData(mSynth) - # Now set up the problem to do some minimization - dmis = DataMisfit.l2_DataMisfit(survey) + + dpred = simulation.dpred(mSynth) + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + uncertainties = 0.1*np.abs(dpred)*np.ones(np.shape(dpred)) + dobs = dpred + noise + data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) + dmis.W = 1./uncertainties + reg = regularization.Tikhonov(mesh) - opt = Optimization.InexactGaussNewton( + + opt = optimization.InexactGaussNewton( maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6 ) - invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.) - inv = Inversion.BaseInversion(invProb) + invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=0.) + inv = inversion.BaseInversion(invProb) + + self.data = data_object + self.dmis = dmis self.inv = inv self.reg = reg - self.p = problem + self.sim = simulation self.mesh = mesh self.m0 = mSynth self.survey = survey - self.dmis = dmis + def test_misfit(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: ( - self.survey.dpred(m), - lambda mx: self.p.Jvec(self.m0, mx) + self.sim.dpred(m), + lambda mx: self.sim.Jvec(self.m0, mx) ), self.m0, plotIt=False, @@ -92,15 +125,15 @@ def test_adjoint(self): # Adjoint Test # u = np.random.rand(self.mesh.nC * self.survey.nSrc) v = np.random.rand(self.mesh.nC) - w = np.random.rand(self.survey.dobs.shape[0]) - wtJv = w.dot(self.p.Jvec(self.m0, v)) - vtJtw = v.dot(self.p.Jtvec(self.m0, w)) + w = np.random.rand(self.data.dobs.shape[0]) + wtJv = w.dot(self.sim.Jvec(self.m0, v)) + vtJtw = v.dot(self.sim.Jtvec(self.m0, w)) passed = np.abs(wtJv - vtJtw) < 1e-10 print('Adjoint Test', np.abs(wtJv - vtJtw), passed) self.assertTrue(passed) def test_dataObj(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: [self.dmis(m), self.dmis.deriv(m)], self.m0, plotIt=False, @@ -111,68 +144,110 @@ def test_dataObj(self): class GlobalEM1DFD_Height(unittest.TestCase): def setUp(self, parallel=True): - frequency = np.array([900, 7200, 56000], dtype=float) - hz = np.r_[1.] + + frequencies = np.array([900, 7200, 56000], dtype=float) + n_layer = 0 n_sounding = 10 dx = 20. hx = np.ones(n_sounding) * dx + hz = 1. # not used in simulation e = np.ones(n_sounding) - mSynth = np.r_[e*np.log(1./100.), e*20] + mSynth = np.r_[e*np.log(1./100.), e*20.] + mesh = TensorMesh([hx, hz], x0='00') - x = np.arange(n_sounding) + x = mesh.vectorCCx y = np.zeros_like(x) z = np.ones_like(x) * 30. - rx_locations = np.c_[x, y, z] - src_locations = np.c_[x, y, z] - topo = np.c_[x, y, z-30.].astype(float) + source_locations = np.c_[x, y, z] + receiver_offsets = np.c_[ + np.zeros(n_sounding)+8., + np.zeros(n_sounding), + np.zeros(n_sounding) + ] - wires = Maps.Wires(('sigma', n_sounding),('h', n_sounding)) - expmap = Maps.ExpMap(nP=n_sounding) - sigmaMap = expmap * wires.sigma - - survey = GlobalEM1DSurveyFD( - rx_locations=rx_locations, - src_locations=src_locations, - frequency=frequency, - offset=np.ones_like(frequency) * 8., - src_type="VMD", - rx_type="ppm", - field_type='secondary', - topo=topo, - half_switch=True - ) + # topo = np.c_[x, y, z-30.].astype(float) + + wires = maps.Wires(('sigma', n_sounding),('height', n_sounding)) + expmap = maps.ExpMap(nP=n_sounding) + sigma_map = expmap * wires.sigma + + source_list = [] + + for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_offset = receiver_offsets[ii, :] - problem = GlobalEM1DProblemFD( - [], sigmaMap=sigmaMap, hMap=wires.h, hz=hz, - parallel=parallel, n_cpu=2 + receiver_list = [] + + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_offset, frequencies, orientation="z", + field_type="secondary", component="both", + use_source_receiver_offset=True + ) + ) + # receiver_list.append( + # em1d.receivers.HarmonicPointReceiver( + # receiver_offset, frequencies, orientation="z", + # field_type="secondary", component="imag", + # use_source_receiver_offset=True + # ) + # ) + + source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, + orientation="z", moment_amplitude=1. + ) + ) + + survey = em1d.survey.EM1DSurveyFD(source_list) + + simulation = em1d.simulation.StitchedEM1DFMSimulation( + survey=survey, sigmaMap=sigma_map, hMap=wires.height, + parallel=False, n_cpu=2, verbose=True, Solver=PardisoSolver ) - problem.pair(survey) - survey.makeSyntheticData(mSynth) - # Now set up the problem to do some minimization - mesh = Mesh.TensorMesh([int(n_sounding * 2)]) - dmis = DataMisfit.l2_DataMisfit(survey) - reg = regularization.Tikhonov(mesh) - opt = Optimization.InexactGaussNewton( + dpred = simulation.dpred(mSynth) + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + uncertainties = 0.1*np.abs(dpred)*np.ones(np.shape(dpred)) + dobs = dpred + noise + data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + + dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) + dmis.W = 1./uncertainties + + reg_mesh = TensorMesh([int(n_sounding)]) + reg_sigma = regularization.Tikhonov(reg_mesh, mapping=wires.sigma) + reg_height = regularization.Tikhonov(reg_mesh, mapping=wires.height) + + reg = reg_sigma + reg_height + + opt = optimization.InexactGaussNewton( maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6 ) - invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.) - inv = Inversion.BaseInversion(invProb) + invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=0.) + inv = inversion.BaseInversion(invProb) + + self.data = data_object + self.dmis = dmis self.inv = inv self.reg = reg - self.p = problem - self.mesh = mesh + self.sim = simulation + self.mesh = reg_mesh self.m0 = mSynth * 1.2 self.survey = survey - self.dmis = dmis + def test_misfit(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: ( - self.survey.dpred(m), - lambda mx: self.p.Jvec(self.m0, mx) + self.sim.dpred(m), + lambda mx: self.sim.Jvec(self.m0, mx) ), self.m0, plotIt=False, @@ -183,16 +258,16 @@ def test_misfit(self): def test_adjoint(self): # Adjoint Test # u = np.random.rand(self.mesh.nC * self.survey.nSrc) - v = np.random.rand(self.mesh.nC) - w = np.random.rand(self.survey.dobs.shape[0]) - wtJv = w.dot(self.p.Jvec(self.m0, v)) - vtJtw = v.dot(self.p.Jtvec(self.m0, w)) + v = np.random.rand(2*self.mesh.nC) + w = np.random.rand(self.data.dobs.shape[0]) + wtJv = w.dot(self.sim.Jvec(self.m0, v)) + vtJtw = v.dot(self.sim.Jtvec(self.m0, w)) passed = np.abs(wtJv - vtJtw) < 1e-10 print('Adjoint Test', np.abs(wtJv - vtJtw), passed) self.assertTrue(passed) def test_dataObj(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: [self.dmis(m), self.dmis.deriv(m)], self.m0, plotIt=False, diff --git a/tests/testGlobalEM1D_TD_jac_layers.py b/tests/testGlobalEM1D_TD_jac_layers.py index 45df8f2..a870ea9 100644 --- a/tests/testGlobalEM1D_TD_jac_layers.py +++ b/tests/testGlobalEM1D_TD_jac_layers.py @@ -1,18 +1,12 @@ from __future__ import print_function import unittest import numpy as np -from simpegEM1D import ( - GlobalEM1DProblemTD, GlobalEM1DSurveyTD, - get_vertical_discretization_time -) -from SimPEG import ( - regularization, Inversion, InvProblem, - DataMisfit, Utils, Mesh, Maps, Optimization, - Tests -) - -from simpegEM1D import skytem_HM_2015 -wave = skytem_HM_2015() +import simpegEM1D as em1d +from simpegEM1D.utils import get_vertical_discretization_time +from simpegEM1D.waveforms import TriangleFun +from SimPEG import * +from discretize import TensorMesh +from pymatsolver import PardisoSolver np.random.seed(41) @@ -21,17 +15,18 @@ class GlobalEM1DTD(unittest.TestCase): def setUp(self, parallel=True): - time = np.logspace(-6, -3, 21) - hz = get_vertical_discretization_time( - time, facter_tmax=0.5, factor_tmin=10. + + times = np.logspace(-5, -2, 31) + n_layer = 20 + thicknesses = get_vertical_discretization_time( + times, facter_tmax=0.5, factor_tmin=10., n_layer=n_layer-1 ) - time_input_currents = wave.current_times[-7:] - input_currents = wave.currents[-7:] n_sounding = 5 dx = 20. hx = np.ones(n_sounding) * dx - mesh = Mesh.TensorMesh([hx, hz], x0='00') + hz = np.r_[thicknesses, thicknesses[-1]] + mesh = TensorMesh([hx, hz], x0='00') inds = mesh.gridCC[:, 1] < 25 inds_1 = mesh.gridCC[:, 1] < 50 sigma = np.ones(mesh.nC) * 1./100. @@ -43,82 +38,94 @@ def setUp(self, parallel=True): x = mesh.vectorCCx y = np.zeros_like(x) z = np.ones_like(x) * 30. - rx_locations = np.c_[x, y, z] - src_locations = np.c_[x, y, z] + receiver_locations = np.c_[x, y, z] + source_locations = np.c_[x, y, z] topo = np.c_[x, y, z-30.].astype(float) - n_sounding = rx_locations.shape[0] - - rx_type_global = np.array( - ["dBzdt"], dtype=str - ).repeat(n_sounding, axis=0) - field_type_global = np.array( - ['secondary'], dtype=str - ).repeat(n_sounding, axis=0) - wave_type_global = np.array( - ['general'], dtype=str - ).repeat(n_sounding, axis=0) - - time_global = [time for i in range(n_sounding)] - - src_type_global = np.array( - ["CircularLoop"], dtype=str - ).repeat(n_sounding, axis=0) - a_global = np.array( - [13.], dtype=float - ).repeat(n_sounding, axis=0) - input_currents_global = [ - input_currents for i in range(n_sounding) - ] - time_input_currents_global = [ - time_input_currents for i in range(n_sounding) - ] - - mapping = Maps.ExpMap(mesh) - - survey = GlobalEM1DSurveyTD( - rx_locations=rx_locations, - src_locations=src_locations, - topo=topo, - time=time_global, - src_type=src_type_global, - rx_type=rx_type_global, - field_type=field_type_global, - wave_type=wave_type_global, - a=a_global, - input_currents=input_currents_global, - time_input_currents=time_input_currents_global + sigma_map = maps.ExpMap(mesh) + + source_list = [] + + for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [] + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation="z", + component="b" + ) + ) + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation="z", + component="dbdt" + ) + ) + + time_input_currents = np.r_[-np.logspace(-2, -5, 31), 0.] + input_currents = TriangleFun(time_input_currents+0.01, 5e-3, 0.01) + + source_list.append( + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, + location=source_location, + a=5., I=1., + wave_type="general", + time_input_currents=time_input_currents, + input_currents=input_currents, + n_pulse = 1, + base_frequency = 25., + use_lowpass_filter=False, + high_cut_frequency=210*1e3 + ) + ) + + survey = em1d.survey.EM1DSurveyTD(source_list) + + simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=sigma_map, + topo=topo, parallel=False, n_cpu=2, verbose=False, solver=PardisoSolver ) - problem = GlobalEM1DProblemTD( - mesh, sigmaMap=mapping, hz=hz, parallel=parallel, n_cpu=2 - ) - problem.pair(survey) + dpred = simulation.dpred(mSynth) + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + uncertainties = 0.1*np.abs(dpred)*np.ones(np.shape(dpred)) + dobs = dpred + noise + data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) - survey.makeSyntheticData(mSynth) + dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) + dmis.W = 1./uncertainties - # Now set up the problem to do some minimization - dmis = DataMisfit.l2_DataMisfit(survey) reg = regularization.Tikhonov(mesh) - opt = Optimization.InexactGaussNewton( + + opt = optimization.InexactGaussNewton( maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6 ) - invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.) - inv = Inversion.BaseInversion(invProb) + + invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=0.) + inv = inversion.BaseInversion(invProb) + + self.data = data_object + self.dmis = dmis self.inv = inv self.reg = reg - self.p = problem + self.sim = simulation self.mesh = mesh self.m0 = mSynth self.survey = survey - self.dmis = dmis + def test_misfit(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: ( - self.survey.dpred(m), - lambda mx: self.p.Jvec(self.m0, mx) + self.sim.dpred(m), + lambda mx: self.sim.Jvec(self.m0, mx) ), self.m0, plotIt=False, @@ -129,15 +136,15 @@ def test_misfit(self): def test_adjoint(self): # Adjoint Test v = np.random.rand(self.mesh.nC) - w = np.random.rand(self.survey.dobs.shape[0]) - wtJv = w.dot(self.p.Jvec(self.m0, v)) - vtJtw = v.dot(self.p.Jtvec(self.m0, w)) + w = np.random.rand(self.data.dobs.shape[0]) + wtJv = w.dot(self.sim.Jvec(self.m0, v)) + vtJtw = v.dot(self.sim.Jtvec(self.m0, w)) passed = np.abs(wtJv - vtJtw) < 1e-10 print('Adjoint Test', np.abs(wtJv - vtJtw), passed) self.assertTrue(passed) def test_dataObj(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: [self.dmis(m), self.dmis.deriv(m)], self.m0, plotIt=False, @@ -148,101 +155,114 @@ def test_dataObj(self): class GlobalEM1DTD_Height(unittest.TestCase): def setUp(self, parallel=True): - time = np.logspace(-6, -3, 21) - time_input_currents = wave.current_times[-7:] - input_currents = wave.currents[-7:] - hz = get_vertical_discretization_time( - time, facter_tmax=0.5, factor_tmin=10. - ) - hz = np.r_[1.] + times = np.logspace(-5, -2, 31) + + hz = 1. n_sounding = 10 dx = 20. hx = np.ones(n_sounding) * dx e = np.ones(n_sounding) - mSynth = np.r_[e*np.log(1./100.), e*20] + mSynth = np.r_[e*np.log(1./100.), e*30] + mesh = TensorMesh([hx, hz], x0='00') + + wires = maps.Wires(('sigma', n_sounding),('height', n_sounding)) + expmap = maps.ExpMap(nP=n_sounding) + sigma_map = expmap * wires.sigma - x = np.arange(n_sounding) + x = mesh.vectorCCx y = np.zeros_like(x) z = np.ones_like(x) * 30. - rx_locations = np.c_[x, y, z] - src_locations = np.c_[x, y, z] + receiver_locations = np.c_[x, y, z] + source_locations = np.c_[x, y, z] topo = np.c_[x, y, z-30.].astype(float) - rx_type_global = np.array( - ["dBzdt"], dtype=str - ).repeat(n_sounding, axis=0) - field_type_global = np.array( - ['secondary'], dtype=str - ).repeat(n_sounding, axis=0) - wave_type_global = np.array( - ['general'], dtype=str - ).repeat(n_sounding, axis=0) - - time_global = [time for i in range(n_sounding)] - - src_type_global = np.array( - ["CircularLoop"], dtype=str - ).repeat(n_sounding, axis=0) - a_global = np.array( - [13.], dtype=float - ).repeat(n_sounding, axis=0) - input_currents_global = [ - input_currents for i in range(n_sounding) - ] - time_input_currents_global = [ - time_input_currents for i in range(n_sounding) - ] - - wires = Maps.Wires(('sigma', n_sounding),('h', n_sounding)) - expmap = Maps.ExpMap(nP=n_sounding) - sigmaMap = expmap * wires.sigma - - survey = GlobalEM1DSurveyTD( - rx_locations=rx_locations, - src_locations=src_locations, - topo=topo, - time=time_global, - src_type=src_type_global, - rx_type=rx_type_global, - field_type=field_type_global, - wave_type=wave_type_global, - a=a_global, - input_currents=input_currents_global, - time_input_currents=time_input_currents_global, - half_switch=True + source_list = [] + + for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [] + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation="z", + component="b" + ) + ) + + receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation="z", + component="dbdt" + ) + ) + + time_input_currents = np.r_[-np.logspace(-2, -5, 31), 0.] + input_currents = TriangleFun(time_input_currents+0.01, 5e-3, 0.01) + + source_list.append( + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, + location=source_location, + a=5., I=1., + wave_type="general", + time_input_currents=time_input_currents, + input_currents=input_currents, + n_pulse = 1, + base_frequency = 25., + use_lowpass_filter=False, + high_cut_frequency=210*1e3 + ) + ) + + survey = em1d.survey.EM1DSurveyTD(source_list) + + simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, sigmaMap=sigma_map, hMap=wires.height, + topo=topo, parallel=False, n_cpu=2, verbose=False, solver=PardisoSolver ) - problem = GlobalEM1DProblemTD( - [], sigmaMap=sigmaMap, hMap=wires.h, hz=hz, parallel=parallel, n_cpu=2 - ) - problem.pair(survey) + dpred = simulation.dpred(mSynth) + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + uncertainties = 0.1*np.abs(dpred)*np.ones(np.shape(dpred)) + dobs = dpred + noise + data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) - survey.makeSyntheticData(mSynth) + dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) + dmis.W = 1./uncertainties - # Now set up the problem to do some minimization - mesh = Mesh.TensorMesh([int(n_sounding * 2)]) - dmis = DataMisfit.l2_DataMisfit(survey) - reg = regularization.Tikhonov(mesh) - opt = Optimization.InexactGaussNewton( + reg_mesh = TensorMesh([int(n_sounding)]) + reg_sigma = regularization.Tikhonov(reg_mesh, mapping=wires.sigma) + reg_height = regularization.Tikhonov(reg_mesh, mapping=wires.height) + + reg = reg_sigma + reg_height + + opt = optimization.InexactGaussNewton( maxIterLS=20, maxIter=10, tolF=1e-6, tolX=1e-6, tolG=1e-6, maxIterCG=6 ) - invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.) - inv = Inversion.BaseInversion(invProb) + + invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=0.) + inv = inversion.BaseInversion(invProb) + + self.data = data_object + self.dmis = dmis self.inv = inv self.reg = reg - self.p = problem - self.mesh = mesh - self.m0 = mSynth + self.sim = simulation + self.mesh = reg_mesh + self.m0 = mSynth * 1.2 self.survey = survey - self.dmis = dmis + def test_misfit(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: ( - self.survey.dpred(m), - lambda mx: self.p.Jvec(self.m0, mx) + self.sim.dpred(m), + lambda mx: self.sim.Jvec(self.m0, mx) ), self.m0, plotIt=False, @@ -252,16 +272,16 @@ def test_misfit(self): def test_adjoint(self): # Adjoint Test - v = np.random.rand(self.mesh.nC) - w = np.random.rand(self.survey.dobs.shape[0]) - wtJv = w.dot(self.p.Jvec(self.m0, v)) - vtJtw = v.dot(self.p.Jtvec(self.m0, w)) + v = np.random.rand(2*self.mesh.nC) + w = np.random.rand(self.data.dobs.shape[0]) + wtJv = w.dot(self.sim.Jvec(self.m0, v)) + vtJtw = v.dot(self.sim.Jtvec(self.m0, w)) passed = np.abs(wtJv - vtJtw) < 1e-10 print('Adjoint Test', np.abs(wtJv - vtJtw), passed) self.assertTrue(passed) def test_dataObj(self): - passed = Tests.checkDerivative( + passed = tests.checkDerivative( lambda m: [self.dmis(m), self.dmis.deriv(m)], self.m0, plotIt=False, diff --git a/tests/testGlobalEM1D_TD_jac_layers_dual_moment.py b/tests/testGlobalEM1D_TD_jac_layers_dual_moment.py new file mode 100644 index 0000000..21a7338 --- /dev/null +++ b/tests/testGlobalEM1D_TD_jac_layers_dual_moment.py @@ -0,0 +1,178 @@ +from __future__ import print_function +import unittest +import numpy as np +import simpegEM1D as em1d +from simpegEM1D.utils import get_vertical_discretization_time +from simpegEM1D.waveforms import TriangleFun +from SimPEG import * +from discretize import TensorMesh +from pymatsolver import PardisoSolver +from simpegEM1D import skytem_HM_2015, skytem_LM_2015 + + +np.random.seed(41) + + +class GlobalEM1DTD(unittest.TestCase): + + def setUp(self, parallel=True): + wave_HM = skytem_HM_2015() + wave_LM = skytem_LM_2015() + time_HM = wave_HM.time_gate_center[0::2] + time_LM = wave_LM.time_gate_center[0::2] + + time_input_currents_HM = wave_HM.current_times[-7:] + input_currents_HM = wave_HM.currents[-7:] + time_input_currents_LM = wave_LM.current_times[-13:] + input_currents_LM = wave_LM.currents[-13:] + + n_layer = 20 + thicknesses = get_vertical_discretization_time( + time_LM, facter_tmax=0.5, factor_tmin=10., n_layer=n_layer-1 + ) + + n_sounding = 5 + dx = 20. + hx = np.ones(n_sounding) * dx + hz = np.r_[thicknesses, thicknesses[-1]] + mesh = TensorMesh([hx, hz], x0='00') + inds = mesh.gridCC[:, 1] < 25 + inds_1 = mesh.gridCC[:, 1] < 50 + sigma = np.ones(mesh.nC) * 1./100. + sigma[inds_1] = 1./10. + sigma[inds] = 1./50. + sigma_em1d = sigma.reshape(mesh.vnC, order='F').flatten() + mSynth = np.log(sigma_em1d) + + x = mesh.vectorCCx + y = np.zeros_like(x) + z = np.ones_like(x) * 30. + source_locations = np.c_[x, y, z] + source_current = 1. + source_orientation = 'z' + receiver_offset_r = 13.25 + receiver_offset_z = 2. + + receiver_locations = np.c_[x+receiver_offset_r, np.zeros(n_sounding), 30.*np.ones(n_sounding)+receiver_offset_z] + receiver_orientation = "z" # "x", "y" or "z" + + topo = np.c_[x, y, z-30.].astype(float) + + sigma_map = maps.ExpMap(mesh) + + source_list = [] + + for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [] + + receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, + times=time_HM, + times_dual_moment=time_LM, + orientation=receiver_orientation, + component="dbdt" + ) + ] + + receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, + times=time_HM, + times_dual_moment=time_LM, + orientation=receiver_orientation, + component="b" + ) + ] + + source_list.append( + em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, + location=source_location, + moment_amplitude=source_current, + orientation=source_orientation, + wave_type="general", + moment_type='dual', + time_input_currents=time_input_currents_HM, + input_currents=input_currents_HM, + n_pulse = 1, + base_frequency = 25., + time_input_currents_dual_moment = time_input_currents_LM, + input_currents_dual_moment = input_currents_LM, + base_frequency_dual_moment = 210 + ) + ) + + survey = em1d.survey.EM1DSurveyTD(source_list) + + simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=sigma_map, + topo=topo, parallel=False, n_cpu=2, verbose=False, solver=PardisoSolver + ) + + dpred = simulation.dpred(mSynth) + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + uncertainties = 0.1*np.abs(dpred)*np.ones(np.shape(dpred)) + dobs = dpred + noise + data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) + dmis.W = 1./uncertainties + + reg = regularization.Tikhonov(mesh) + + opt = optimization.InexactGaussNewton( + maxIterLS=20, maxIter=10, tolF=1e-6, + tolX=1e-6, tolG=1e-6, maxIterCG=6 + ) + + invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=0.) + inv = inversion.BaseInversion(invProb) + + self.data = data_object + self.dmis = dmis + self.inv = inv + self.reg = reg + self.sim = simulation + self.mesh = mesh + self.m0 = mSynth + self.survey = survey + + + def test_misfit(self): + passed = tests.checkDerivative( + lambda m: ( + self.sim.dpred(m), + lambda mx: self.sim.Jvec(self.m0, mx) + ), + self.m0, + plotIt=False, + num=3 + ) + self.assertTrue(passed) + + def test_adjoint(self): + # Adjoint Test + v = np.random.rand(self.mesh.nC) + w = np.random.rand(self.data.dobs.shape[0]) + wtJv = w.dot(self.sim.Jvec(self.m0, v)) + vtJtw = v.dot(self.sim.Jtvec(self.m0, w)) + passed = np.abs(wtJv - vtJtw) < 1e-10 + print('Adjoint Test', np.abs(wtJv - vtJtw), passed) + self.assertTrue(passed) + + def test_dataObj(self): + passed = tests.checkDerivative( + lambda m: [self.dmis(m), self.dmis.deriv(m)], + self.m0, + plotIt=False, + num=3 + ) + self.assertTrue(passed) + +if __name__ == '__main__': + unittest.main() diff --git a/tutorials/assets/em1dfm_data.obs b/tutorials/assets/em1dfm_data.obs new file mode 100644 index 0000000..9279a70 --- /dev/null +++ b/tutorials/assets/em1dfm_data.obs @@ -0,0 +1,5 @@ +3.8200e+02 9.3664e+02 7.3894e+02 +1.8220e+03 1.7232e+03 1.1115e+03 +7.9700e+03 2.9979e+03 1.9208e+03 +3.5920e+04 5.4208e+03 1.9754e+03 +1.3010e+05 7.1201e+03 1.3787e+03 diff --git a/tutorials/assets/em1dfm_stitched_data.obs b/tutorials/assets/em1dfm_stitched_data.obs new file mode 100644 index 0000000..20bd439 --- /dev/null +++ b/tutorials/assets/em1dfm_stitched_data.obs @@ -0,0 +1,300 @@ +5.0000e+01 0.0000e+00 3.0000e+01 2.5000e+01 1.5606e+01 9.6046e+01 +5.0000e+01 0.0000e+00 3.0000e+01 1.0000e+02 3.8519e+02 8.9716e+02 +5.0000e+01 0.0000e+00 3.0000e+01 3.8200e+02 1.5032e+03 3.2671e+03 +5.0000e+01 0.0000e+00 3.0000e+01 1.8220e+03 7.4660e+01 2.1133e+02 +5.0000e+01 0.0000e+00 3.0000e+01 7.9700e+03 4.1500e+02 6.0974e+02 +5.0000e+01 0.0000e+00 3.0000e+01 3.5920e+04 1.2827e+03 2.2959e+03 +1.5204e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.5603e+01 9.2510e+01 +1.5204e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.8297e+02 8.5130e+02 +1.5204e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.4161e+03 3.4851e+03 +1.5204e+02 0.0000e+00 3.0000e+01 1.8220e+03 7.2045e+01 2.1442e+02 +1.5204e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.1677e+02 6.2407e+02 +1.5204e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2663e+03 2.3338e+03 +2.5408e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.6366e+01 9.3543e+01 +2.5408e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.6136e+02 8.4677e+02 +2.5408e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.5129e+03 3.5034e+03 +2.5408e+02 0.0000e+00 3.0000e+01 1.8220e+03 7.1123e+01 2.2543e+02 +2.5408e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.4347e+02 6.5359e+02 +2.5408e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2158e+03 2.3554e+03 +3.5612e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.5981e+01 9.3973e+01 +3.5612e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.7641e+02 8.6617e+02 +3.5612e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.5054e+03 3.4991e+03 +3.5612e+02 0.0000e+00 3.0000e+01 1.8220e+03 7.2118e+01 2.1138e+02 +3.5612e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.2440e+02 6.4941e+02 +3.5612e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.3020e+03 2.3466e+03 +4.5816e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.8785e+01 1.0889e+02 +4.5816e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.9850e+02 8.5479e+02 +4.5816e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.4083e+03 3.4963e+03 +4.5816e+02 0.0000e+00 3.0000e+01 1.8220e+03 7.8620e+01 2.1678e+02 +4.5816e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.2793e+02 6.3598e+02 +4.5816e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2196e+03 2.2412e+03 +5.6020e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.8525e+01 1.1133e+02 +5.6020e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.9753e+02 8.6251e+02 +5.6020e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.4942e+03 3.5131e+03 +5.6020e+02 0.0000e+00 3.0000e+01 1.8220e+03 7.5944e+01 2.3371e+02 +5.6020e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.0939e+02 6.1540e+02 +5.6020e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2397e+03 2.3132e+03 +6.6224e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.8689e+01 1.1003e+02 +6.6224e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.8302e+02 8.1974e+02 +6.6224e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.4260e+03 3.4989e+03 +6.6224e+02 0.0000e+00 3.0000e+01 1.8220e+03 8.2381e+01 2.3498e+02 +6.6224e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.1104e+02 6.5562e+02 +6.6224e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2166e+03 2.3490e+03 +7.6429e+02 0.0000e+00 3.0000e+01 2.5000e+01 1.8309e+01 1.0647e+02 +7.6429e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.9946e+02 8.1501e+02 +7.6429e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.5265e+03 3.4564e+03 +7.6429e+02 0.0000e+00 3.0000e+01 1.8220e+03 7.7327e+01 2.2469e+02 +7.6429e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.2125e+02 6.2057e+02 +7.6429e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2726e+03 2.3345e+03 +8.6633e+02 0.0000e+00 3.0000e+01 2.5000e+01 2.1328e+01 1.2342e+02 +8.6633e+02 0.0000e+00 3.0000e+01 1.0000e+02 4.2183e+02 8.2353e+02 +8.6633e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.5354e+03 3.5192e+03 +8.6633e+02 0.0000e+00 3.0000e+01 1.8220e+03 8.1432e+01 2.3799e+02 +8.6633e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.1647e+02 6.2336e+02 +8.6633e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2688e+03 2.3384e+03 +9.6837e+02 0.0000e+00 3.0000e+01 2.5000e+01 2.1199e+01 1.2374e+02 +9.6837e+02 0.0000e+00 3.0000e+01 1.0000e+02 3.9738e+02 8.4230e+02 +9.6837e+02 0.0000e+00 3.0000e+01 3.8200e+02 1.4646e+03 3.3011e+03 +9.6837e+02 0.0000e+00 3.0000e+01 1.8220e+03 8.1993e+01 2.2868e+02 +9.6837e+02 0.0000e+00 3.0000e+01 7.9700e+03 4.3144e+02 6.3013e+02 +9.6837e+02 0.0000e+00 3.0000e+01 3.5920e+04 1.2143e+03 2.2167e+03 +1.0704e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.1469e+01 1.1775e+02 +1.0704e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1509e+02 8.7510e+02 +1.0704e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4920e+03 3.3553e+03 +1.0704e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.4999e+01 2.3355e+02 +1.0704e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.2070e+02 6.4082e+02 +1.0704e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.1888e+03 2.2539e+03 +1.1724e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.1188e+01 1.2397e+02 +1.1724e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1035e+02 8.4336e+02 +1.1724e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5244e+03 3.4664e+03 +1.1724e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.3320e+01 2.3924e+02 +1.1724e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.1676e+02 6.4500e+02 +1.1724e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.3046e+03 2.2683e+03 +1.2745e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.1608e+01 1.2223e+02 +1.2745e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.8776e+02 8.5215e+02 +1.2745e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5077e+03 3.3253e+03 +1.2745e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.2602e+01 2.4414e+02 +1.2745e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9790e+02 6.0698e+02 +1.2745e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2090e+03 2.2844e+03 +1.3765e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.1214e+01 1.2295e+02 +1.3765e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9100e+02 8.2347e+02 +1.3765e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5303e+03 3.3509e+03 +1.3765e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.7446e+01 2.3867e+02 +1.3765e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.3435e+02 5.9844e+02 +1.3765e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2254e+03 2.1671e+03 +1.4786e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.3874e+01 1.2952e+02 +1.4786e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2650e+02 8.3204e+02 +1.4786e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5097e+03 3.5291e+03 +1.4786e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.2258e+01 2.2705e+02 +1.4786e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.1204e+02 6.4131e+02 +1.4786e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2140e+03 2.1710e+03 +1.5806e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.4476e+01 1.3067e+02 +1.5806e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2429e+02 8.8372e+02 +1.5806e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4682e+03 3.5048e+03 +1.5806e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.0070e+01 2.4261e+02 +1.5806e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.1940e+02 6.5024e+02 +1.5806e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2490e+03 2.2790e+03 +1.6827e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.4133e+01 1.2661e+02 +1.6827e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2478e+02 8.4708e+02 +1.6827e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4092e+03 3.3138e+03 +1.6827e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.0613e+01 2.4592e+02 +1.6827e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0889e+02 6.1549e+02 +1.6827e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.3036e+03 2.2417e+03 +1.7847e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.3911e+01 1.3046e+02 +1.7847e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2146e+02 8.5448e+02 +1.7847e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4688e+03 3.4341e+03 +1.7847e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.8268e+01 2.3633e+02 +1.7847e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9646e+02 6.2443e+02 +1.7847e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.3046e+03 2.3417e+03 +1.8867e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.3556e+01 1.3905e+02 +1.8867e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0851e+02 8.6441e+02 +1.8867e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4133e+03 3.4519e+03 +1.8867e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.7074e+01 2.2931e+02 +1.8867e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.2219e+02 6.3849e+02 +1.8867e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2320e+03 2.2737e+03 +1.9888e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.4114e+01 1.3419e+02 +1.9888e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2730e+02 8.6813e+02 +1.9888e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5116e+03 3.2653e+03 +1.9888e+03 0.0000e+00 3.0000e+01 1.8220e+03 8.4782e+01 2.3191e+02 +1.9888e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9307e+02 6.0247e+02 +1.9888e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2594e+03 2.1716e+03 +2.0908e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.7125e+01 1.3835e+02 +2.0908e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1291e+02 8.2919e+02 +2.0908e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4762e+03 3.2894e+03 +2.0908e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.3909e+01 2.3123e+02 +2.0908e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.1411e+02 6.0495e+02 +2.0908e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2736e+03 2.2501e+03 +2.1929e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.5927e+01 1.3775e+02 +2.1929e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0857e+02 8.7900e+02 +2.1929e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4204e+03 3.2969e+03 +2.1929e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.1328e+01 2.4547e+02 +2.1929e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.1122e+02 6.0887e+02 +2.1929e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2325e+03 2.2430e+03 +2.2949e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.6466e+01 1.4223e+02 +2.2949e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9750e+02 8.2999e+02 +2.2949e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5190e+03 3.4143e+03 +2.2949e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.0534e+01 2.2686e+02 +2.2949e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.8470e+02 6.2387e+02 +2.2949e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.3057e+03 2.2634e+03 +2.3969e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.7194e+01 1.3788e+02 +2.3969e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0436e+02 8.5087e+02 +2.3969e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4702e+03 3.4273e+03 +2.3969e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.0233e+01 2.4573e+02 +2.3969e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9560e+02 6.5777e+02 +2.3969e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2301e+03 2.3404e+03 +2.4990e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.5965e+01 1.3594e+02 +2.4990e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0391e+02 8.7976e+02 +2.4990e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4245e+03 3.5097e+03 +2.4990e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.4302e+01 2.4087e+02 +2.4990e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9836e+02 6.2446e+02 +2.4990e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2371e+03 2.1872e+03 +2.6010e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.5599e+01 1.4449e+02 +2.6010e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9919e+02 8.4703e+02 +2.6010e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4335e+03 3.2928e+03 +2.6010e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.0165e+01 2.2902e+02 +2.6010e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.7989e+02 6.4923e+02 +2.6010e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2662e+03 2.1977e+03 +2.7031e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.7619e+01 1.4593e+02 +2.7031e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1157e+02 8.2439e+02 +2.7031e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5014e+03 3.5535e+03 +2.7031e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.3633e+01 2.4034e+02 +2.7031e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9419e+02 6.2174e+02 +2.7031e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2331e+03 2.1575e+03 +2.8051e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.9016e+01 1.5350e+02 +2.8051e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1546e+02 8.2468e+02 +2.8051e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4890e+03 3.4021e+03 +2.8051e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.1567e+01 2.2608e+02 +2.8051e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9143e+02 6.2606e+02 +2.8051e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2069e+03 2.2966e+03 +2.9071e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.7609e+01 1.4929e+02 +2.9071e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2932e+02 8.8045e+02 +2.9071e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4214e+03 3.3545e+03 +2.9071e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.1376e+01 2.3736e+02 +2.9071e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9422e+02 6.3765e+02 +2.9071e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2772e+03 2.2733e+03 +3.0092e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.8409e+01 1.5025e+02 +3.0092e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2510e+02 8.0933e+02 +3.0092e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4715e+03 3.3544e+03 +3.0092e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.2744e+01 2.3631e+02 +3.0092e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.7580e+02 6.1658e+02 +3.0092e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2570e+03 2.3300e+03 +3.1112e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.9725e+01 1.4391e+02 +3.1112e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2754e+02 8.5695e+02 +3.1112e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4535e+03 3.3952e+03 +3.1112e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.0874e+01 2.2690e+02 +3.1112e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.8478e+02 6.1954e+02 +3.1112e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2868e+03 2.1938e+03 +3.2133e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.8879e+01 1.4675e+02 +3.2133e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9582e+02 8.1620e+02 +3.2133e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4859e+03 3.2470e+03 +3.2133e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.4619e+01 2.3150e+02 +3.2133e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.8577e+02 6.4483e+02 +3.2133e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2692e+03 2.3082e+03 +3.3153e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.7708e+01 1.4521e+02 +3.3153e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2056e+02 8.5777e+02 +3.3153e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5207e+03 3.5285e+03 +3.3153e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.2469e+01 2.3651e+02 +3.3153e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0313e+02 6.0714e+02 +3.3153e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2741e+03 2.3038e+03 +3.4173e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.0433e+01 1.5763e+02 +3.4173e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0402e+02 8.7872e+02 +3.4173e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4227e+03 3.4858e+03 +3.4173e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7655e+01 2.2335e+02 +3.4173e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.8139e+02 6.0888e+02 +3.4173e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2395e+03 2.2904e+03 +3.5194e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.1628e+01 1.4889e+02 +3.5194e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1783e+02 8.3463e+02 +3.5194e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5369e+03 3.4505e+03 +3.5194e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.3081e+01 2.2217e+02 +3.5194e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0273e+02 6.4240e+02 +3.5194e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2030e+03 2.3307e+03 +3.6214e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.1363e+01 1.4516e+02 +3.6214e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9396e+02 8.5422e+02 +3.6214e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4936e+03 3.4384e+03 +3.6214e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.4984e+01 2.2766e+02 +3.6214e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0723e+02 6.1819e+02 +3.6214e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2651e+03 2.1447e+03 +3.7235e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.1743e+01 1.4574e+02 +3.7235e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9875e+02 8.7826e+02 +3.7235e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4072e+03 3.4710e+03 +3.7235e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7492e+01 2.3601e+02 +3.7235e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9074e+02 6.0640e+02 +3.7235e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2081e+03 2.1700e+03 +3.8255e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.9782e+01 1.5309e+02 +3.8255e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0955e+02 8.2608e+02 +3.8255e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5373e+03 3.3086e+03 +3.8255e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7866e+01 2.2745e+02 +3.8255e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0504e+02 6.5760e+02 +3.8255e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.3063e+03 2.3156e+03 +3.9276e+03 0.0000e+00 3.0000e+01 2.5000e+01 2.9858e+01 1.5070e+02 +3.9276e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2754e+02 8.7186e+02 +3.9276e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4989e+03 3.5045e+03 +3.9276e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.6990e+01 2.3450e+02 +3.9276e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.1077e+02 6.1764e+02 +3.9276e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2007e+03 2.3129e+03 +4.0296e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.0244e+01 1.5649e+02 +4.0296e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2716e+02 8.7276e+02 +4.0296e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4284e+03 3.3413e+03 +4.0296e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7552e+01 2.3344e+02 +4.0296e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.7408e+02 6.2319e+02 +4.0296e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2739e+03 2.2989e+03 +4.1316e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.2120e+01 1.4770e+02 +4.1316e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2481e+02 8.2810e+02 +4.1316e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4980e+03 3.2320e+03 +4.1316e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.5473e+01 2.3833e+02 +4.1316e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9768e+02 6.0198e+02 +4.1316e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2081e+03 2.2211e+03 +4.2337e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.4061e+01 1.5519e+02 +4.2337e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0291e+02 8.2246e+02 +4.2337e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4968e+03 3.2816e+03 +4.2337e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7601e+01 2.2712e+02 +4.2337e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.7813e+02 6.1279e+02 +4.2337e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2776e+03 2.3223e+03 +4.3357e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.4862e+01 1.5547e+02 +4.3357e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.1347e+02 8.1402e+02 +4.3357e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4877e+03 3.2334e+03 +4.3357e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.3674e+01 2.4144e+02 +4.3357e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0534e+02 6.1165e+02 +4.3357e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2684e+03 2.2538e+03 +4.4378e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.3594e+01 1.6007e+02 +4.4378e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2552e+02 8.3098e+02 +4.4378e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5240e+03 3.5471e+03 +4.4378e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7724e+01 2.4151e+02 +4.4378e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9422e+02 6.3991e+02 +4.4378e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2298e+03 2.2566e+03 +4.5398e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.4216e+01 1.5941e+02 +4.5398e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2319e+02 8.7728e+02 +4.5398e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4371e+03 3.4961e+03 +4.5398e+03 0.0000e+00 3.0000e+01 1.8220e+03 1.0025e+02 2.3968e+02 +4.5398e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.8610e+02 6.3267e+02 +4.5398e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2130e+03 2.2504e+03 +4.6418e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.2566e+01 1.4697e+02 +4.6418e+03 0.0000e+00 3.0000e+01 1.0000e+02 3.9844e+02 8.3702e+02 +4.6418e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4047e+03 3.2312e+03 +4.6418e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.2777e+01 2.3249e+02 +4.6418e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.7673e+02 6.2574e+02 +4.6418e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.3066e+03 2.3129e+03 +4.7439e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.2164e+01 1.5814e+02 +4.7439e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2067e+02 8.6221e+02 +4.7439e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.5238e+03 3.5021e+03 +4.7439e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.5642e+01 2.3404e+02 +4.7439e+03 0.0000e+00 3.0000e+01 7.9700e+03 3.9722e+02 6.5210e+02 +4.7439e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2102e+03 2.2731e+03 +4.8459e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.2371e+01 1.5482e+02 +4.8459e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0348e+02 8.3424e+02 +4.8459e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4448e+03 3.2629e+03 +4.8459e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.4784e+01 2.2872e+02 +4.8459e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0674e+02 6.2209e+02 +4.8459e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2435e+03 2.3019e+03 +4.9480e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.2148e+01 1.5122e+02 +4.9480e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.2037e+02 8.8401e+02 +4.9480e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4135e+03 3.4919e+03 +4.9480e+03 0.0000e+00 3.0000e+01 1.8220e+03 9.7472e+01 2.3739e+02 +4.9480e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0967e+02 6.4613e+02 +4.9480e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2232e+03 2.2441e+03 +5.0500e+03 0.0000e+00 3.0000e+01 2.5000e+01 3.4708e+01 1.5626e+02 +5.0500e+03 0.0000e+00 3.0000e+01 1.0000e+02 4.0571e+02 8.4041e+02 +5.0500e+03 0.0000e+00 3.0000e+01 3.8200e+02 1.4309e+03 3.5081e+03 +5.0500e+03 0.0000e+00 3.0000e+01 1.8220e+03 1.0064e+02 2.2170e+02 +5.0500e+03 0.0000e+00 3.0000e+01 7.9700e+03 4.0311e+02 6.4101e+02 +5.0500e+03 0.0000e+00 3.0000e+01 3.5920e+04 1.2109e+03 2.3528e+03 diff --git a/tutorials/assets/em1dtm_data.obs b/tutorials/assets/em1dtm_data.obs new file mode 100644 index 0000000..3450ddb --- /dev/null +++ b/tutorials/assets/em1dtm_data.obs @@ -0,0 +1,31 @@ +1.0000e-05 9.0158e-11 +1.2589e-05 8.0479e-11 +1.5849e-05 6.8170e-11 +1.9953e-05 5.7555e-11 +2.5119e-05 4.9883e-11 +3.1623e-05 4.0871e-11 +3.9811e-05 3.2908e-11 +5.0119e-05 2.7785e-11 +6.3096e-05 2.2333e-11 +7.9433e-05 1.8236e-11 +1.0000e-04 1.4945e-11 +1.2589e-04 1.2650e-11 +1.5849e-04 1.0859e-11 +1.9953e-04 9.5498e-12 +2.5119e-04 8.2613e-12 +3.1623e-04 7.2103e-12 +3.9811e-04 6.3823e-12 +5.0119e-04 5.6965e-12 +6.3096e-04 4.9735e-12 +7.9433e-04 4.2812e-12 +1.0000e-03 3.7500e-12 +1.2589e-03 3.0255e-12 +1.5849e-03 2.5082e-12 +1.9953e-03 1.9741e-12 +2.5119e-03 1.5232e-12 +3.1623e-03 1.1415e-12 +3.9811e-03 8.5775e-13 +5.0119e-03 6.1457e-13 +6.3096e-03 4.2825e-13 +7.9433e-03 2.8916e-13 +1.0000e-02 1.9264e-13 diff --git a/tutorials/assets/em1dtm_stitched_data.obs b/tutorials/assets/em1dtm_stitched_data.obs new file mode 100644 index 0000000..87784c7 --- /dev/null +++ b/tutorials/assets/em1dtm_stitched_data.obs @@ -0,0 +1,800 @@ +5.0000e+01 0.0000e+00 2.0000e+01 1.0000e-05 -1.7030e-06 +5.0000e+01 0.0000e+00 2.0000e+01 1.5849e-05 -7.1828e-07 +5.0000e+01 0.0000e+00 2.0000e+01 2.5119e-05 -2.6075e-07 +5.0000e+01 0.0000e+00 2.0000e+01 3.9811e-05 -1.0011e-07 +5.0000e+01 0.0000e+00 2.0000e+01 6.3096e-05 -5.3884e-08 +5.0000e+01 0.0000e+00 2.0000e+01 1.0000e-04 -3.3666e-08 +5.0000e+01 0.0000e+00 2.0000e+01 1.5849e-04 -1.9062e-08 +5.0000e+01 0.0000e+00 2.0000e+01 2.5119e-04 -1.0820e-08 +5.0000e+01 0.0000e+00 2.0000e+01 3.9811e-04 -5.2386e-09 +5.0000e+01 0.0000e+00 2.0000e+01 6.3096e-04 -2.3888e-09 +5.0000e+01 0.0000e+00 2.0000e+01 1.0000e-03 -8.9294e-10 +5.0000e+01 0.0000e+00 2.0000e+01 1.5849e-03 -3.2550e-10 +5.0000e+01 0.0000e+00 2.0000e+01 2.5119e-03 -1.0926e-10 +5.0000e+01 0.0000e+00 2.0000e+01 3.9811e-03 -3.8134e-11 +5.0000e+01 0.0000e+00 2.0000e+01 6.3096e-03 -1.2488e-11 +5.0000e+01 0.0000e+00 2.0000e+01 1.0000e-02 -3.8548e-12 +1.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7284e-06 +1.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -7.0382e-07 +1.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.4771e-07 +1.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -1.0374e-07 +1.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.0189e-08 +1.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -3.0197e-08 +1.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.8410e-08 +1.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -1.0375e-08 +1.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.8375e-09 +1.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.6287e-09 +1.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.1654e-09 +1.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -4.2738e-10 +1.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.5563e-10 +1.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -4.9697e-11 +1.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.5000e-11 +1.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -4.4725e-12 +2.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7037e-06 +2.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -7.1782e-07 +2.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.4725e-07 +2.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -9.6624e-08 +2.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.1847e-08 +2.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.8956e-08 +2.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.8352e-08 +2.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -1.0027e-08 +2.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.8561e-09 +2.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.7571e-09 +2.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.1785e-09 +2.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -4.3515e-10 +2.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.5896e-10 +2.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -4.9094e-11 +2.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.4420e-11 +2.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -4.6177e-12 +3.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.8247e-06 +3.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -7.2016e-07 +3.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.5854e-07 +3.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -1.0365e-07 +3.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.0790e-08 +3.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.8951e-08 +3.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.7522e-08 +3.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -1.0229e-08 +3.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.7504e-09 +3.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.6107e-09 +3.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.1918e-09 +3.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -4.4422e-10 +3.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.5376e-10 +3.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -4.8578e-11 +3.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.5569e-11 +3.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -4.4616e-12 +4.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7396e-06 +4.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -6.8361e-07 +4.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.5048e-07 +4.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -9.7975e-08 +4.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -4.9881e-08 +4.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.8759e-08 +4.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.8499e-08 +4.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -1.0337e-08 +4.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.6881e-09 +4.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.8606e-09 +4.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.2037e-09 +4.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -4.3778e-10 +4.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.4646e-10 +4.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -4.8491e-11 +4.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.5792e-11 +4.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -4.5680e-12 +5.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7820e-06 +5.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -6.7675e-07 +5.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.5283e-07 +5.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -1.0043e-07 +5.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.2930e-08 +5.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.8182e-08 +5.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.8426e-08 +5.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -1.0933e-08 +5.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.8445e-09 +5.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.7862e-09 +5.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.1335e-09 +5.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -4.5596e-10 +5.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.5046e-10 +5.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -4.7509e-11 +5.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.5521e-11 +5.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -4.5789e-12 +6.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.8208e-06 +6.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -6.6626e-07 +6.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.4152e-07 +6.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -1.0353e-07 +6.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.0653e-08 +6.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.9216e-08 +6.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.8139e-08 +6.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -1.0113e-08 +6.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.6383e-09 +6.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.7918e-09 +6.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.1631e-09 +6.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -4.2764e-10 +6.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.4581e-10 +6.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -5.1087e-11 +6.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.4563e-11 +6.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -4.6809e-12 +7.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7236e-06 +7.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -6.8830e-07 +7.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.4717e-07 +7.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -1.0201e-07 +7.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.0100e-08 +7.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.9478e-08 +7.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.5973e-08 +7.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -9.3466e-09 +7.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.6540e-09 +7.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.9692e-09 +7.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.3137e-09 +7.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -5.4780e-10 +7.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.9847e-10 +7.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -6.2187e-11 +7.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.8456e-11 +7.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -5.9021e-12 +8.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7147e-06 +8.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -7.1685e-07 +8.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.5499e-07 +8.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -1.0377e-07 +8.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -5.1738e-08 +8.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.9780e-08 +8.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.7352e-08 +8.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -9.8108e-09 +8.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.5354e-09 +8.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.8060e-09 +8.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.3662e-09 +8.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -5.5172e-10 +8.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.8703e-10 +8.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -6.3567e-11 +8.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.8501e-11 +8.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -5.7443e-12 +9.5000e+02 0.0000e+00 2.0000e+01 1.0000e-05 -1.7446e-06 +9.5000e+02 0.0000e+00 2.0000e+01 1.5849e-05 -6.6193e-07 +9.5000e+02 0.0000e+00 2.0000e+01 2.5119e-05 -2.3758e-07 +9.5000e+02 0.0000e+00 2.0000e+01 3.9811e-05 -9.8512e-08 +9.5000e+02 0.0000e+00 2.0000e+01 6.3096e-05 -4.9658e-08 +9.5000e+02 0.0000e+00 2.0000e+01 1.0000e-04 -2.7787e-08 +9.5000e+02 0.0000e+00 2.0000e+01 1.5849e-04 -1.6575e-08 +9.5000e+02 0.0000e+00 2.0000e+01 2.5119e-04 -9.6398e-09 +9.5000e+02 0.0000e+00 2.0000e+01 3.9811e-04 -5.7052e-09 +9.5000e+02 0.0000e+00 2.0000e+01 6.3096e-04 -2.8634e-09 +9.5000e+02 0.0000e+00 2.0000e+01 1.0000e-03 -1.3525e-09 +9.5000e+02 0.0000e+00 2.0000e+01 1.5849e-03 -5.1318e-10 +9.5000e+02 0.0000e+00 2.0000e+01 2.5119e-03 -1.8853e-10 +9.5000e+02 0.0000e+00 2.0000e+01 3.9811e-03 -6.1537e-11 +9.5000e+02 0.0000e+00 2.0000e+01 6.3096e-03 -1.9015e-11 +9.5000e+02 0.0000e+00 2.0000e+01 1.0000e-02 -6.0663e-12 +1.0500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7577e-06 +1.0500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8448e-07 +1.0500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5486e-07 +1.0500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.5120e-08 +1.0500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.7941e-08 +1.0500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8061e-08 +1.0500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7369e-08 +1.0500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -1.0040e-08 +1.0500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.4039e-09 +1.0500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.8525e-09 +1.0500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3621e-09 +1.0500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.2093e-10 +1.0500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -1.8887e-10 +1.0500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -6.5311e-11 +1.0500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -1.9227e-11 +1.0500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -5.9031e-12 +1.1500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.8342e-06 +1.1500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1094e-07 +1.1500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3904e-07 +1.1500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6663e-08 +1.1500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.0753e-08 +1.1500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7859e-08 +1.1500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7021e-08 +1.1500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.3521e-09 +1.1500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.3091e-09 +1.1500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.9265e-09 +1.1500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2931e-09 +1.1500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.3534e-10 +1.1500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -1.8179e-10 +1.1500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -5.9226e-11 +1.1500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -1.9683e-11 +1.1500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -5.5146e-12 +1.2500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7728e-06 +1.2500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.0787e-07 +1.2500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5835e-07 +1.2500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0271e-07 +1.2500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.7793e-08 +1.2500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9578e-08 +1.2500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6038e-08 +1.2500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.6468e-09 +1.2500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.4219e-09 +1.2500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.9443e-09 +1.2500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2925e-09 +1.2500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.4615e-10 +1.2500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -1.9315e-10 +1.2500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -6.5455e-11 +1.2500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -1.9328e-11 +1.2500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -5.6424e-12 +1.3500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7671e-06 +1.3500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8400e-07 +1.3500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4473e-07 +1.3500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6341e-08 +1.3500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9765e-08 +1.3500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7385e-08 +1.3500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7416e-08 +1.3500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.5132e-09 +1.3500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.2450e-09 +1.3500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.9059e-09 +1.3500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2608e-09 +1.3500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.2533e-10 +1.3500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -1.9835e-10 +1.3500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -5.9836e-11 +1.3500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -1.9131e-11 +1.3500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -5.7195e-12 +1.4500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7016e-06 +1.4500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.9970e-07 +1.4500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3908e-07 +1.4500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0190e-07 +1.4500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.2674e-08 +1.4500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8781e-08 +1.4500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6572e-08 +1.4500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.7725e-09 +1.4500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0385e-09 +1.4500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.8370e-09 +1.4500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3376e-09 +1.4500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9761e-10 +1.4500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.1179e-10 +1.4500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.7667e-11 +1.4500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.3445e-11 +1.4500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.4300e-12 +1.5500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7707e-06 +1.5500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.2200e-07 +1.5500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5359e-07 +1.5500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0194e-07 +1.5500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1041e-08 +1.5500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8047e-08 +1.5500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6229e-08 +1.5500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.0670e-09 +1.5500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.1240e-09 +1.5500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6338e-09 +1.5500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3926e-09 +1.5500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.5487e-10 +1.5500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.2651e-10 +1.5500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.6886e-11 +1.5500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.3627e-11 +1.5500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.2542e-12 +1.6500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7700e-06 +1.6500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.2233e-07 +1.6500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4772e-07 +1.6500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0338e-07 +1.6500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.8739e-08 +1.6500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8698e-08 +1.6500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6742e-08 +1.6500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.2132e-09 +1.6500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.1209e-09 +1.6500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.7602e-09 +1.6500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3644e-09 +1.6500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.0381e-10 +1.6500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.1877e-10 +1.6500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.8287e-11 +1.6500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.4831e-11 +1.6500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -6.7949e-12 +1.7500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.8369e-06 +1.7500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.2502e-07 +1.7500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3986e-07 +1.7500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.5229e-08 +1.7500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.2928e-08 +1.7500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9630e-08 +1.7500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5755e-08 +1.7500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.4412e-09 +1.7500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.8889e-09 +1.7500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6702e-09 +1.7500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3294e-09 +1.7500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8517e-10 +1.7500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.2691e-10 +1.7500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.3740e-11 +1.7500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.4772e-11 +1.7500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.0195e-12 +1.8500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7323e-06 +1.8500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8322e-07 +1.8500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5008e-07 +1.8500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6647e-08 +1.8500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.8082e-08 +1.8500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9088e-08 +1.8500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7001e-08 +1.8500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.9962e-09 +1.8500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9801e-09 +1.8500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.8600e-09 +1.8500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3646e-09 +1.8500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.6706e-10 +1.8500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.2295e-10 +1.8500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.3405e-11 +1.8500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.3110e-11 +1.8500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.0187e-12 +1.9500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6886e-06 +1.9500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.6885e-07 +1.9500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4769e-07 +1.9500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.8298e-08 +1.9500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.0975e-08 +1.9500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7628e-08 +1.9500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6013e-08 +1.9500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1581e-09 +1.9500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.3578e-09 +1.9500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.7064e-09 +1.9500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3966e-09 +1.9500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.0032e-10 +1.9500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.1095e-10 +1.9500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.7312e-11 +1.9500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.3991e-11 +1.9500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.4875e-12 +2.0500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7090e-06 +2.0500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.6662e-07 +2.0500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4550e-07 +2.0500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0053e-07 +2.0500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.7719e-08 +2.0500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9867e-08 +2.0500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6950e-08 +2.0500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.7506e-09 +2.0500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.1828e-09 +2.0500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.8492e-09 +2.0500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2688e-09 +2.0500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9366e-10 +2.0500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.2154e-10 +2.0500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.4849e-11 +2.0500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.3148e-11 +2.0500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.0406e-12 +2.1500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7347e-06 +2.1500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1069e-07 +2.1500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4201e-07 +2.1500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6175e-08 +2.1500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9151e-08 +2.1500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9279e-08 +2.1500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6299e-08 +2.1500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.6373e-09 +2.1500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.2668e-09 +2.1500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.8531e-09 +2.1500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3797e-09 +2.1500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.0605e-10 +2.1500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.1984e-10 +2.1500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -7.3970e-11 +2.1500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.4508e-11 +2.1500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -7.2410e-12 +2.2500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7131e-06 +2.2500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.7923e-07 +2.2500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5202e-07 +2.2500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.9760e-08 +2.2500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9540e-08 +2.2500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8956e-08 +2.2500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6545e-08 +2.2500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.0565e-09 +2.2500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.1755e-09 +2.2500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5064e-09 +2.2500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3673e-09 +2.2500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8343e-10 +2.2500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.3966e-10 +2.2500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -8.3449e-11 +2.2500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.7397e-11 +2.2500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.9568e-12 +2.3500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7454e-06 +2.3500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.9691e-07 +2.3500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4990e-07 +2.3500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6651e-08 +2.3500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.8717e-08 +2.3500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7351e-08 +2.3500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5882e-08 +2.3500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.3951e-09 +2.3500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.1690e-09 +2.3500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5833e-09 +2.3500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2899e-09 +2.3500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.1415e-10 +2.3500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.3575e-10 +2.3500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.0725e-11 +2.3500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.9054e-11 +2.3500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.6312e-12 +2.4500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6910e-06 +2.4500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.6149e-07 +2.4500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5743e-07 +2.4500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0014e-07 +2.4500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1337e-08 +2.4500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9983e-08 +2.4500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6197e-08 +2.4500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.3596e-09 +2.4500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9919e-09 +2.4500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.7411e-09 +2.4500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2556e-09 +2.4500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.6970e-10 +2.4500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.3016e-10 +2.4500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -8.9084e-11 +2.4500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.8102e-11 +2.4500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.6333e-12 +2.5500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7273e-06 +2.5500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.0017e-07 +2.5500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4054e-07 +2.5500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6368e-08 +2.5500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1900e-08 +2.5500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9400e-08 +2.5500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7077e-08 +2.5500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.8221e-09 +2.5500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0011e-09 +2.5500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4794e-09 +2.5500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2874e-09 +2.5500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.0270e-10 +2.5500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5332e-10 +2.5500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -8.5490e-11 +2.5500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.0161e-11 +2.5500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.5661e-12 +2.6500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7024e-06 +2.6500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1855e-07 +2.6500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4227e-07 +2.6500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0531e-07 +2.6500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.0573e-08 +2.6500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7092e-08 +2.6500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5633e-08 +2.6500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1896e-09 +2.6500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0772e-09 +2.6500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5663e-09 +2.6500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3040e-09 +2.6500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8679e-10 +2.6500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5337e-10 +2.6500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -8.4022e-11 +2.6500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.9598e-11 +2.6500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.7782e-12 +2.7500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.8326e-06 +2.7500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.9762e-07 +2.7500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5357e-07 +2.7500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0451e-07 +2.7500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9377e-08 +2.7500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9434e-08 +2.7500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5906e-08 +2.7500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.4066e-09 +2.7500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0251e-09 +2.7500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6359e-09 +2.7500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3124e-09 +2.7500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8716e-10 +2.7500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5017e-10 +2.7500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.1667e-11 +2.7500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.9782e-11 +2.7500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.9307e-12 +2.8500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7800e-06 +2.8500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.2347e-07 +2.8500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4967e-07 +2.8500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.9500e-08 +2.8500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.2100e-08 +2.8500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9239e-08 +2.8500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6501e-08 +2.8500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.4409e-09 +2.8500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9489e-09 +2.8500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.7112e-09 +2.8500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2660e-09 +2.8500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8117e-10 +2.8500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.4182e-10 +2.8500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -8.3457e-11 +2.8500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.7376e-11 +2.8500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -8.5048e-12 +2.9500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7123e-06 +2.9500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8204e-07 +2.9500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3865e-07 +2.9500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0427e-07 +2.9500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9437e-08 +2.9500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7782e-08 +2.9500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6559e-08 +2.9500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.9004e-09 +2.9500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.8976e-09 +2.9500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5045e-09 +2.9500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2996e-09 +2.9500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.0171e-10 +2.9500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5468e-10 +2.9500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -8.6409e-11 +2.9500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -2.7175e-11 +2.9500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -9.0497e-12 +3.0500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.8292e-06 +3.0500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8686e-07 +3.0500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5520e-07 +3.0500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0515e-07 +3.0500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1520e-08 +3.0500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7197e-08 +3.0500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7145e-08 +3.0500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.5074e-09 +3.0500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0143e-09 +3.0500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6458e-09 +3.0500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2627e-09 +3.0500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.1793e-10 +3.0500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5359e-10 +3.0500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0164e-10 +3.0500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.2050e-11 +3.0500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0028e-11 +3.1500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7270e-06 +3.1500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.0515e-07 +3.1500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3700e-07 +3.1500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.7265e-08 +3.1500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9035e-08 +3.1500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -3.0011e-08 +3.1500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7022e-08 +3.1500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.9001e-09 +3.1500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9011e-09 +3.1500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5328e-09 +3.1500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2591e-09 +3.1500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9630e-10 +3.1500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5615e-10 +3.1500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.9637e-11 +3.1500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.3125e-11 +3.1500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0561e-11 +3.2500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7743e-06 +3.2500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8807e-07 +3.2500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4586e-07 +3.2500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0013e-07 +3.2500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9172e-08 +3.2500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7486e-08 +3.2500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7076e-08 +3.2500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1842e-09 +3.2500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0011e-09 +3.2500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5835e-09 +3.2500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2774e-09 +3.2500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.6005e-10 +3.2500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5759e-10 +3.2500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.7762e-11 +3.2500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.3496e-11 +3.2500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0402e-11 +3.3500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.8368e-06 +3.3500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.7824e-07 +3.3500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5800e-07 +3.3500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.7433e-08 +3.3500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.0852e-08 +3.3500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8231e-08 +3.3500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6259e-08 +3.3500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.9485e-09 +3.3500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.2037e-09 +3.3500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4077e-09 +3.3500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2490e-09 +3.3500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.7640e-10 +3.3500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5292e-10 +3.3500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.1974e-11 +3.3500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.2820e-11 +3.3500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0112e-11 +3.4500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7065e-06 +3.4500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.7433e-07 +3.4500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4276e-07 +3.4500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.7092e-08 +3.4500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9537e-08 +3.4500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7831e-08 +3.4500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6204e-08 +3.4500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.8054e-09 +3.4500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0602e-09 +3.4500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4282e-09 +3.4500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.1990e-09 +3.4500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.0869e-10 +3.4500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5287e-10 +3.4500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.2694e-11 +3.4500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.2585e-11 +3.4500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0210e-11 +3.5500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6625e-06 +3.5500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.9109e-07 +3.5500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4517e-07 +3.5500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.8857e-08 +3.5500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1056e-08 +3.5500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7961e-08 +3.5500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5664e-08 +3.5500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.3000e-09 +3.5500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9129e-09 +3.5500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4920e-09 +3.5500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.3021e-09 +3.5500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.6192e-10 +3.5500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.6526e-10 +3.5500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.7305e-11 +3.5500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.2304e-11 +3.5500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0825e-11 +3.6500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7373e-06 +3.6500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.5873e-07 +3.6500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5960e-07 +3.6500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.6036e-08 +3.6500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9732e-08 +3.6500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7395e-08 +3.6500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6039e-08 +3.6500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1293e-09 +3.6500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9820e-09 +3.6500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6128e-09 +3.6500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2382e-09 +3.6500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.6094e-10 +3.6500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5538e-10 +3.6500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.4546e-11 +3.6500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.3703e-11 +3.6500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0756e-11 +3.7500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7626e-06 +3.7500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.2444e-07 +3.7500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3843e-07 +3.7500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0147e-07 +3.7500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1092e-08 +3.7500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8687e-08 +3.7500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6679e-08 +3.7500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1377e-09 +3.7500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.7868e-09 +3.7500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4451e-09 +3.7500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2438e-09 +3.7500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9415e-10 +3.7500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5629e-10 +3.7500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.5287e-11 +3.7500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.4461e-11 +3.7500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0175e-11 +3.8500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7052e-06 +3.8500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.7620e-07 +3.8500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5818e-07 +3.8500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.5019e-08 +3.8500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.7802e-08 +3.8500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7969e-08 +3.8500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6615e-08 +3.8500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.6034e-09 +3.8500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0797e-09 +3.8500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5564e-09 +3.8500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2685e-09 +3.8500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9891e-10 +3.8500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5885e-10 +3.8500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.5995e-11 +3.8500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.4004e-11 +3.8500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0193e-11 +3.9500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.8001e-06 +3.9500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.0374e-07 +3.9500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4711e-07 +3.9500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0091e-07 +3.9500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.8779e-08 +3.9500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7127e-08 +3.9500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7030e-08 +3.9500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.2722e-09 +3.9500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9114e-09 +3.9500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5050e-09 +3.9500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2838e-09 +3.9500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -6.1083e-10 +3.9500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5812e-10 +3.9500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.1918e-11 +3.9500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.3133e-11 +3.9500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.0570e-11 +4.0500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7660e-06 +4.0500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.2341e-07 +4.0500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4844e-07 +4.0500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0475e-07 +4.0500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.8843e-08 +4.0500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7914e-08 +4.0500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5819e-08 +4.0500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1327e-09 +4.0500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.7725e-09 +4.0500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.3961e-09 +4.0500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2258e-09 +4.0500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9113e-10 +4.0500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.4479e-10 +4.0500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0140e-10 +4.0500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.6558e-11 +4.0500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.1629e-11 +4.1500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6949e-06 +4.1500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.5599e-07 +4.1500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5762e-07 +4.1500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0267e-07 +4.1500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.0394e-08 +4.1500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8486e-08 +4.1500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6676e-08 +4.1500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.8890e-09 +4.1500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.7149e-09 +4.1500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4380e-09 +4.1500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2050e-09 +4.1500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.4398e-10 +4.1500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.4872e-10 +4.1500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0449e-10 +4.1500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.5102e-11 +4.1500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.1499e-11 +4.2500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7072e-06 +4.2500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1487e-07 +4.2500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4353e-07 +4.2500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.9359e-08 +4.2500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.1626e-08 +4.2500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9395e-08 +4.2500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6641e-08 +4.2500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.4338e-09 +4.2500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.1869e-09 +4.2500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4796e-09 +4.2500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2459e-09 +4.2500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8836e-10 +4.2500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5925e-10 +4.2500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.8180e-11 +4.2500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.4890e-11 +4.2500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.2184e-11 +4.3500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7803e-06 +4.3500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1988e-07 +4.3500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5069e-07 +4.3500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0540e-07 +4.3500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9573e-08 +4.3500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9989e-08 +4.3500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5757e-08 +4.3500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.6403e-09 +4.3500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9640e-09 +4.3500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4405e-09 +4.3500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2499e-09 +4.3500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.7772e-10 +4.3500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5319e-10 +4.3500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0296e-10 +4.3500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.4729e-11 +4.3500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.2221e-11 +4.4500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6847e-06 +4.4500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1799e-07 +4.4500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4198e-07 +4.4500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.8487e-08 +4.4500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9722e-08 +4.4500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8152e-08 +4.4500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.5740e-08 +4.4500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -8.8384e-09 +4.4500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.8064e-09 +4.4500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5527e-09 +4.4500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2733e-09 +4.4500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9873e-10 +4.4500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5517e-10 +4.4500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0369e-10 +4.4500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.6006e-11 +4.4500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.1532e-11 +4.5500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7532e-06 +4.5500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.9761e-07 +4.5500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.5328e-07 +4.5500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.7516e-08 +4.5500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9559e-08 +4.5500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9650e-08 +4.5500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6620e-08 +4.5500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.4826e-09 +4.5500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.8330e-09 +4.5500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6338e-09 +4.5500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2538e-09 +4.5500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.9171e-10 +4.5500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.4036e-10 +4.5500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -9.9617e-11 +4.5500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.7412e-11 +4.5500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.2505e-11 +4.6500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7013e-06 +4.6500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.5898e-07 +4.6500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4354e-07 +4.6500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0258e-07 +4.6500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.0397e-08 +4.6500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.8163e-08 +4.6500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.7094e-08 +4.6500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.0209e-09 +4.6500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -5.0755e-09 +4.6500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4244e-09 +4.6500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2640e-09 +4.6500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.5507e-10 +4.6500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.5557e-10 +4.6500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0015e-10 +4.6500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.7578e-11 +4.6500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.2466e-11 +4.7500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.7777e-06 +4.7500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -7.1553e-07 +4.7500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3941e-07 +4.7500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -9.7325e-08 +4.7500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.9944e-08 +4.7500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9078e-08 +4.7500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6047e-08 +4.7500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.1888e-09 +4.7500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.7428e-09 +4.7500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.4783e-09 +4.7500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.1987e-09 +4.7500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.6826e-10 +4.7500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.6570e-10 +4.7500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0122e-10 +4.7500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.4782e-11 +4.7500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.1356e-11 +4.8500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6994e-06 +4.8500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.8679e-07 +4.8500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.4644e-07 +4.8500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0158e-07 +4.8500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -4.7697e-08 +4.8500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.7221e-08 +4.8500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6537e-08 +4.8500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.0283e-09 +4.8500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.9449e-09 +4.8500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.6150e-09 +4.8500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2366e-09 +4.8500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.8345e-10 +4.8500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.4231e-10 +4.8500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0052e-10 +4.8500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.6082e-11 +4.8500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.1376e-11 +4.9500e+03 0.0000e+00 2.0000e+01 1.0000e-05 -1.6855e-06 +4.9500e+03 0.0000e+00 2.0000e+01 1.5849e-05 -6.9276e-07 +4.9500e+03 0.0000e+00 2.0000e+01 2.5119e-05 -2.3922e-07 +4.9500e+03 0.0000e+00 2.0000e+01 3.9811e-05 -1.0509e-07 +4.9500e+03 0.0000e+00 2.0000e+01 6.3096e-05 -5.2751e-08 +4.9500e+03 0.0000e+00 2.0000e+01 1.0000e-04 -2.9505e-08 +4.9500e+03 0.0000e+00 2.0000e+01 1.5849e-04 -1.6890e-08 +4.9500e+03 0.0000e+00 2.0000e+01 2.5119e-04 -9.4031e-09 +4.9500e+03 0.0000e+00 2.0000e+01 3.9811e-04 -4.7773e-09 +4.9500e+03 0.0000e+00 2.0000e+01 6.3096e-04 -2.5602e-09 +4.9500e+03 0.0000e+00 2.0000e+01 1.0000e-03 -1.2740e-09 +4.9500e+03 0.0000e+00 2.0000e+01 1.5849e-03 -5.7879e-10 +4.9500e+03 0.0000e+00 2.0000e+01 2.5119e-03 -2.6535e-10 +4.9500e+03 0.0000e+00 2.0000e+01 3.9811e-03 -1.0680e-10 +4.9500e+03 0.0000e+00 2.0000e+01 6.3096e-03 -3.4762e-11 +4.9500e+03 0.0000e+00 2.0000e+01 1.0000e-02 -1.2049e-11 diff --git a/tutorials/assets/em1dtm_stitched_data_skytem.obs b/tutorials/assets/em1dtm_stitched_data_skytem.obs new file mode 100644 index 0000000..5b4f375 --- /dev/null +++ b/tutorials/assets/em1dtm_stitched_data_skytem.obs @@ -0,0 +1,1300 @@ +5.0000e+01 0.0000e+00 3.0000e+01 1.2715e-05 -4.2631e-10 +5.0000e+01 0.0000e+00 3.0000e+01 2.0715e-05 -2.8403e-10 +5.0000e+01 0.0000e+00 3.0000e+01 3.3215e-05 -2.0863e-10 +5.0000e+01 0.0000e+00 3.0000e+01 5.3715e-05 -1.6779e-10 +5.0000e+01 0.0000e+00 3.0000e+01 8.6215e-05 -1.3146e-10 +5.0000e+01 0.0000e+00 3.0000e+01 1.3672e-04 -9.7454e-11 +5.0000e+01 0.0000e+00 3.0000e+01 2.1771e-04 -6.3052e-11 +5.0000e+01 0.0000e+00 3.0000e+01 3.4671e-04 -3.7947e-11 +5.0000e+01 0.0000e+00 3.0000e+01 5.5172e-04 -1.9629e-11 +5.0000e+01 0.0000e+00 3.0000e+01 8.7721e-04 -9.1949e-12 +5.0000e+01 0.0000e+00 3.0000e+01 1.3942e-03 -3.8319e-12 +5.0000e+01 0.0000e+00 3.0000e+01 2.2167e-03 -1.3786e-12 +5.0000e+01 0.0000e+00 3.0000e+01 3.5237e-03 -4.0902e-13 +5.0000e+01 0.0000e+00 3.0000e+01 5.6012e-03 -1.2181e-13 +5.0000e+01 0.0000e+00 3.0000e+01 8.9022e-03 -3.1796e-14 +5.0000e+01 0.0000e+00 3.0000e+01 1.0215e-05 -3.6693e-09 +5.0000e+01 0.0000e+00 3.0000e+01 1.6215e-05 -1.7696e-09 +5.0000e+01 0.0000e+00 3.0000e+01 2.6215e-05 -8.2731e-10 +5.0000e+01 0.0000e+00 3.0000e+01 4.2215e-05 -3.9150e-10 +5.0000e+01 0.0000e+00 3.0000e+01 6.8215e-05 -2.2198e-10 +5.0000e+01 0.0000e+00 3.0000e+01 1.0872e-04 -1.3396e-10 +5.0000e+01 0.0000e+00 3.0000e+01 1.7222e-04 -8.2787e-11 +5.0000e+01 0.0000e+00 3.0000e+01 2.7471e-04 -4.8253e-11 +5.0000e+01 0.0000e+00 3.0000e+01 4.3771e-04 -2.2157e-11 +5.0000e+01 0.0000e+00 3.0000e+01 6.9571e-04 -8.8775e-12 +5.0000e+01 0.0000e+00 3.0000e+01 1.1057e-03 -3.0308e-12 +1.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.1659e-10 +1.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.9507e-10 +1.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -2.0912e-10 +1.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.6284e-10 +1.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.1661e-10 +1.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -9.1838e-11 +1.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -6.3225e-11 +1.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -4.1342e-11 +1.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.2989e-11 +1.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.1243e-11 +1.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -4.4749e-12 +1.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -1.7570e-12 +1.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -5.8062e-13 +1.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.6350e-13 +1.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -4.0216e-14 +1.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.5684e-09 +1.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.8775e-09 +1.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.3434e-10 +1.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -3.8598e-10 +1.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.1785e-10 +1.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.2214e-10 +1.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -7.0793e-11 +1.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -4.3754e-11 +1.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -2.2165e-11 +1.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.5353e-12 +1.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.5755e-12 +2.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.1526e-10 +2.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.8558e-10 +2.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -2.0565e-10 +2.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.6285e-10 +2.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.1340e-10 +2.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -8.4768e-11 +2.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -6.5054e-11 +2.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -3.8543e-11 +2.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.3198e-11 +2.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.0536e-11 +2.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -4.4771e-12 +2.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -1.7182e-12 +2.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -5.3311e-13 +2.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.5641e-13 +2.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -4.2171e-14 +2.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.6228e-09 +2.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.8505e-09 +2.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.7396e-10 +2.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -3.9719e-10 +2.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.1314e-10 +2.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.2158e-10 +2.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -7.0529e-11 +2.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -4.0667e-11 +2.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -2.0993e-11 +2.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.4215e-12 +2.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.5748e-12 +3.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.2910e-10 +3.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.8338e-10 +3.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -1.9469e-10 +3.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.5219e-10 +3.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.1263e-10 +3.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -9.0137e-11 +3.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -5.9694e-11 +3.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -3.7929e-11 +3.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.2936e-11 +3.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.1261e-11 +3.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -4.8708e-12 +3.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -1.6544e-12 +3.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -5.3608e-13 +3.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.5668e-13 +3.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -4.1325e-14 +3.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.6701e-09 +3.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.9418e-09 +3.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.5456e-10 +3.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -4.0931e-10 +3.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.0326e-10 +3.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.2222e-10 +3.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -7.6076e-11 +3.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -3.9747e-11 +3.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -2.2405e-11 +3.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.8987e-12 +3.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.4249e-12 +4.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -3.9000e-10 +4.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.8633e-10 +4.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -2.0965e-10 +4.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.4737e-10 +4.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.1640e-10 +4.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -9.1785e-11 +4.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -5.9716e-11 +4.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -4.1511e-11 +4.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.2660e-11 +4.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.0805e-11 +4.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -4.5822e-12 +4.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -1.7511e-12 +4.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -5.5563e-13 +4.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.6340e-13 +4.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -4.2770e-14 +4.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.4788e-09 +4.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.9368e-09 +4.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.5014e-10 +4.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -3.9418e-10 +4.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.0679e-10 +4.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.1628e-10 +4.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -7.3934e-11 +4.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -3.9742e-11 +4.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -2.2028e-11 +4.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.1955e-12 +4.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.3983e-12 +5.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.0031e-10 +5.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.9132e-10 +5.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -2.1536e-10 +5.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.5404e-10 +5.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.2170e-10 +5.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -8.8147e-11 +5.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -6.5439e-11 +5.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -3.8366e-11 +5.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.2337e-11 +5.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.1099e-11 +5.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -4.5563e-12 +5.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -1.7262e-12 +5.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -5.8164e-13 +5.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.5894e-13 +5.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -4.0141e-14 +5.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.6946e-09 +5.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.8875e-09 +5.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.0797e-10 +5.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -4.1828e-10 +5.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.0427e-10 +5.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.1843e-10 +5.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -6.8972e-11 +5.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -4.3327e-11 +5.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -2.1113e-11 +5.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.2124e-12 +5.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.4073e-12 +6.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.0077e-10 +6.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.9122e-10 +6.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -2.1447e-10 +6.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.6203e-10 +6.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.1246e-10 +6.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -8.6866e-11 +6.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -6.2667e-11 +6.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -4.1629e-11 +6.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.1936e-11 +6.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.1135e-11 +6.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -4.6232e-12 +6.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -1.7842e-12 +6.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -5.4903e-13 +6.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.6355e-13 +6.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -4.2611e-14 +6.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.3502e-09 +6.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.7902e-09 +6.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.0898e-10 +6.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -4.1891e-10 +6.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.0430e-10 +6.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.2587e-10 +6.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -7.1189e-11 +6.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -3.9933e-11 +6.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -2.1133e-11 +6.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.2637e-12 +6.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.4721e-12 +7.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.2637e-10 +7.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.9284e-10 +7.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -1.9530e-10 +7.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.5476e-10 +7.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.0832e-10 +7.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -7.8753e-11 +7.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -5.7914e-11 +7.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -3.6828e-11 +7.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.1959e-11 +7.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.1301e-11 +7.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -5.0883e-12 +7.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -2.1208e-12 +7.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -6.8725e-13 +7.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -2.0593e-13 +7.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -5.4703e-14 +7.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.7123e-09 +7.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.8158e-09 +7.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.4104e-10 +7.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -4.1672e-10 +7.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.0499e-10 +7.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.2451e-10 +7.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -6.6099e-11 +7.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -3.5744e-11 +7.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -1.9442e-11 +7.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -8.9152e-12 +7.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.8321e-12 +8.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -3.8980e-10 +8.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.8338e-10 +8.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -1.9562e-10 +8.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.5694e-10 +8.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.0703e-10 +8.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -7.9560e-11 +8.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -5.7867e-11 +8.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -3.7550e-11 +8.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.1878e-11 +8.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.1411e-11 +8.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -5.6162e-12 +8.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -2.0104e-12 +8.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -7.0299e-13 +8.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.9661e-13 +8.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -5.0139e-14 +8.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.6851e-09 +8.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.8713e-09 +8.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.7586e-10 +8.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -3.8720e-10 +8.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.1440e-10 +8.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.2508e-10 +8.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -6.4460e-11 +8.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -3.5368e-11 +8.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -1.9818e-11 +8.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -9.1277e-12 +8.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.5559e-12 +9.5000e+02 0.0000e+00 3.0000e+01 1.2715e-05 -4.2619e-10 +9.5000e+02 0.0000e+00 3.0000e+01 2.0715e-05 -2.9245e-10 +9.5000e+02 0.0000e+00 3.0000e+01 3.3215e-05 -1.9894e-10 +9.5000e+02 0.0000e+00 3.0000e+01 5.3715e-05 -1.5014e-10 +9.5000e+02 0.0000e+00 3.0000e+01 8.6215e-05 -1.0665e-10 +9.5000e+02 0.0000e+00 3.0000e+01 1.3672e-04 -8.6070e-11 +9.5000e+02 0.0000e+00 3.0000e+01 2.1771e-04 -5.4681e-11 +9.5000e+02 0.0000e+00 3.0000e+01 3.4671e-04 -3.9694e-11 +9.5000e+02 0.0000e+00 3.0000e+01 5.5172e-04 -2.3032e-11 +9.5000e+02 0.0000e+00 3.0000e+01 8.7721e-04 -1.2303e-11 +9.5000e+02 0.0000e+00 3.0000e+01 1.3942e-03 -5.4588e-12 +9.5000e+02 0.0000e+00 3.0000e+01 2.2167e-03 -2.1203e-12 +9.5000e+02 0.0000e+00 3.0000e+01 3.5237e-03 -7.0647e-13 +9.5000e+02 0.0000e+00 3.0000e+01 5.6012e-03 -1.9419e-13 +9.5000e+02 0.0000e+00 3.0000e+01 8.9022e-03 -5.1780e-14 +9.5000e+02 0.0000e+00 3.0000e+01 1.0215e-05 -3.6191e-09 +9.5000e+02 0.0000e+00 3.0000e+01 1.6215e-05 -1.7898e-09 +9.5000e+02 0.0000e+00 3.0000e+01 2.6215e-05 -8.8557e-10 +9.5000e+02 0.0000e+00 3.0000e+01 4.2215e-05 -4.0442e-10 +9.5000e+02 0.0000e+00 3.0000e+01 6.8215e-05 -2.1727e-10 +9.5000e+02 0.0000e+00 3.0000e+01 1.0872e-04 -1.1745e-10 +9.5000e+02 0.0000e+00 3.0000e+01 1.7222e-04 -6.4452e-11 +9.5000e+02 0.0000e+00 3.0000e+01 2.7471e-04 -3.5702e-11 +9.5000e+02 0.0000e+00 3.0000e+01 4.3771e-04 -1.8551e-11 +9.5000e+02 0.0000e+00 3.0000e+01 6.9571e-04 -8.8491e-12 +9.5000e+02 0.0000e+00 3.0000e+01 1.1057e-03 -3.6048e-12 +1.0500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0624e-10 +1.0500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.9176e-10 +1.0500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9231e-10 +1.0500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4368e-10 +1.0500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0660e-10 +1.0500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.7677e-11 +1.0500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4838e-11 +1.0500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.7129e-11 +1.0500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.3340e-11 +1.0500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1846e-11 +1.0500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.5958e-12 +1.0500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.0310e-12 +1.0500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -7.2811e-13 +1.0500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.0973e-13 +1.0500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -5.3536e-14 +1.0500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6563e-09 +1.0500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9406e-09 +1.0500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.9030e-10 +1.0500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0274e-10 +1.0500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0315e-10 +1.0500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2024e-10 +1.0500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.3358e-11 +1.0500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5245e-11 +1.0500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -2.0334e-11 +1.0500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.9527e-12 +1.0500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.6710e-12 +1.1500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1565e-10 +1.1500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7783e-10 +1.1500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9224e-10 +1.1500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4751e-10 +1.1500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1676e-10 +1.1500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.1335e-11 +1.1500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.5419e-11 +1.1500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.6522e-11 +1.1500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1925e-11 +1.1500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1925e-11 +1.1500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.5724e-12 +1.1500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.0932e-12 +1.1500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -7.2343e-13 +1.1500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.0355e-13 +1.1500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -5.1735e-14 +1.1500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.4226e-09 +1.1500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8693e-09 +1.1500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.7658e-10 +1.1500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9676e-10 +1.1500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2132e-10 +1.1500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1329e-10 +1.1500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.5768e-11 +1.1500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.7578e-11 +1.1500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.9919e-11 +1.1500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -9.6460e-12 +1.1500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.6006e-12 +1.2500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2441e-10 +1.2500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7985e-10 +1.2500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9910e-10 +1.2500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5227e-10 +1.2500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1427e-10 +1.2500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.5570e-11 +1.2500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.9852e-11 +1.2500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.8133e-11 +1.2500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.2237e-11 +1.2500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.2171e-11 +1.2500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.4304e-12 +1.2500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -1.9680e-12 +1.2500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -7.1864e-13 +1.2500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.0147e-13 +1.2500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -5.4575e-14 +1.2500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6984e-09 +1.2500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8062e-09 +1.2500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.9149e-10 +1.2500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1769e-10 +1.2500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0801e-10 +1.2500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2395e-10 +1.2500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6184e-11 +1.2500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6655e-11 +1.2500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -2.0227e-11 +1.2500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.9350e-12 +1.2500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.7871e-12 +1.3500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0037e-10 +1.3500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.9243e-10 +1.3500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9110e-10 +1.3500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5059e-10 +1.3500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0733e-10 +1.3500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2759e-11 +1.3500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.6485e-11 +1.3500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.9616e-11 +1.3500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.3774e-11 +1.3500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1779e-11 +1.3500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.6336e-12 +1.3500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.0165e-12 +1.3500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -7.2677e-13 +1.3500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.0544e-13 +1.3500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -5.3126e-14 +1.3500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6643e-09 +1.3500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9460e-09 +1.3500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.7076e-10 +1.3500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2025e-10 +1.3500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1109e-10 +1.3500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1914e-10 +1.3500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9635e-11 +1.3500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6652e-11 +1.3500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.8524e-11 +1.3500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -9.3266e-12 +1.3500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.7643e-12 +1.4500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0639e-10 +1.4500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7236e-10 +1.4500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0345e-10 +1.4500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4078e-10 +1.4500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0610e-10 +1.4500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5224e-11 +1.4500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4112e-11 +1.4500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4854e-11 +1.4500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1743e-11 +1.4500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.2425e-11 +1.4500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.4376e-12 +1.4500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.2423e-12 +1.4500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.1637e-13 +1.4500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.5259e-13 +1.4500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.3074e-14 +1.4500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6273e-09 +1.4500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8689e-09 +1.4500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.3931e-10 +1.4500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9211e-10 +1.4500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1297e-10 +1.4500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1439e-10 +1.4500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.3612e-11 +1.4500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5735e-11 +1.4500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.8260e-11 +1.4500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.0248e-12 +1.4500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.5365e-12 +1.5500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2566e-10 +1.5500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7726e-10 +1.5500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0371e-10 +1.5500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5121e-10 +1.5500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0863e-10 +1.5500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.7439e-11 +1.5500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.2734e-11 +1.5500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.6654e-11 +1.5500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1505e-11 +1.5500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.2337e-11 +1.5500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -6.0100e-12 +1.5500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.2788e-12 +1.5500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -7.9936e-13 +1.5500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.5312e-13 +1.5500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.2593e-14 +1.5500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5721e-09 +1.5500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.7793e-09 +1.5500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.9087e-10 +1.5500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2456e-10 +1.5500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0387e-10 +1.5500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2599e-10 +1.5500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9560e-11 +1.5500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3469e-11 +1.5500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.8107e-11 +1.5500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.7972e-12 +1.5500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.4602e-12 +1.6500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1452e-10 +1.6500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7793e-10 +1.6500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9834e-10 +1.6500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4788e-10 +1.6500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0630e-10 +1.6500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.1813e-11 +1.6500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.1882e-11 +1.6500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5511e-11 +1.6500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0963e-11 +1.6500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.2121e-11 +1.6500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -6.0143e-12 +1.6500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.2404e-12 +1.6500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.4076e-13 +1.6500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.4614e-13 +1.6500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.5389e-14 +1.6500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.4811e-09 +1.6500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9370e-09 +1.6500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.6559e-10 +1.6500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1392e-10 +1.6500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2412e-10 +1.6500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2011e-10 +1.6500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6270e-11 +1.6500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5139e-11 +1.6500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7689e-11 +1.6500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.5728e-12 +1.6500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.4945e-12 +1.7500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0894e-10 +1.7500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8010e-10 +1.7500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0829e-10 +1.7500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4908e-10 +1.7500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1114e-10 +1.7500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0647e-11 +1.7500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3366e-11 +1.7500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.6953e-11 +1.7500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1783e-11 +1.7500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1656e-11 +1.7500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.8188e-12 +1.7500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4478e-12 +1.7500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.3174e-13 +1.7500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.5943e-13 +1.7500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.2220e-14 +1.7500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6673e-09 +1.7500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9045e-09 +1.7500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.3770e-10 +1.7500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1307e-10 +1.7500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1711e-10 +1.7500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1626e-10 +1.7500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.8236e-11 +1.7500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3834e-11 +1.7500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.8435e-11 +1.7500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.2239e-12 +1.7500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.6293e-12 +1.8500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9316e-10 +1.8500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7816e-10 +1.8500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9418e-10 +1.8500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5073e-10 +1.8500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1443e-10 +1.8500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.6071e-11 +1.8500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3966e-11 +1.8500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5947e-11 +1.8500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.2392e-11 +1.8500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1704e-11 +1.8500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.5633e-12 +1.8500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.2330e-12 +1.8500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.2634e-13 +1.8500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.3648e-13 +1.8500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.4861e-14 +1.8500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6278e-09 +1.8500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8139e-09 +1.8500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2360e-10 +1.8500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0866e-10 +1.8500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1176e-10 +1.8500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1748e-10 +1.8500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9825e-11 +1.8500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3584e-11 +1.8500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7042e-11 +1.8500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.5789e-12 +1.8500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.6751e-12 +1.9500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0715e-10 +1.9500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6708e-10 +1.9500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9814e-10 +1.9500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5527e-10 +1.9500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0493e-10 +1.9500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.1434e-11 +1.9500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3113e-11 +1.9500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5001e-11 +1.9500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1841e-11 +1.9500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.2044e-11 +1.9500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.9367e-12 +1.9500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4205e-12 +1.9500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -7.7967e-13 +1.9500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.4256e-13 +1.9500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.7293e-14 +1.9500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5734e-09 +1.9500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9019e-09 +1.9500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.7994e-10 +1.9500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2051e-10 +1.9500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0425e-10 +1.9500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1551e-10 +1.9500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.7387e-11 +1.9500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6610e-11 +1.9500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6901e-11 +1.9500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.2778e-12 +1.9500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.6172e-12 +2.0500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0858e-10 +2.0500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8252e-10 +2.0500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9072e-10 +2.0500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5128e-10 +2.0500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0538e-10 +2.0500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.1608e-11 +2.0500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.6136e-11 +2.0500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5333e-11 +2.0500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1107e-11 +2.0500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1463e-11 +2.0500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -6.0052e-12 +2.0500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.2861e-12 +2.0500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.0699e-13 +2.0500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.5919e-13 +2.0500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -6.7167e-14 +2.0500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5918e-09 +2.0500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8271e-09 +2.0500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.4388e-10 +2.0500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1828e-10 +2.0500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2115e-10 +2.0500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2527e-10 +2.0500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.4574e-11 +2.0500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4993e-11 +2.0500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7459e-11 +2.0500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.7508e-12 +2.0500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.7446e-12 +2.1500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1089e-10 +2.1500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8380e-10 +2.1500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9174e-10 +2.1500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4185e-10 +2.1500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1302e-10 +2.1500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0830e-11 +2.1500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4991e-11 +2.1500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5604e-11 +2.1500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0031e-11 +2.1500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1590e-11 +2.1500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.6693e-12 +2.1500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.3921e-12 +2.1500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.4569e-13 +2.1500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.9484e-13 +2.1500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -8.0884e-14 +2.1500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.4478e-09 +2.1500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9008e-09 +2.1500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.9353e-10 +2.1500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2756e-10 +2.1500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2438e-10 +2.1500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1891e-10 +2.1500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6769e-11 +2.1500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4754e-11 +2.1500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6537e-11 +2.1500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4750e-12 +2.1500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.4754e-12 +2.2500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2567e-10 +2.2500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6833e-10 +2.2500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9044e-10 +2.2500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4084e-10 +2.2500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0709e-10 +2.2500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2442e-11 +2.2500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.5318e-11 +2.2500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4995e-11 +2.2500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0972e-11 +2.2500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1593e-11 +2.2500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.8593e-12 +2.2500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.6124e-12 +2.2500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.1246e-13 +2.2500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.0065e-13 +2.2500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -7.7659e-14 +2.2500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6229e-09 +2.2500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8948e-09 +2.2500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.8839e-10 +2.2500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9626e-10 +2.2500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0436e-10 +2.2500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1962e-10 +2.2500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.4953e-11 +2.2500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4159e-11 +2.2500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6647e-11 +2.2500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4411e-12 +2.2500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2763e-12 +2.3500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2036e-10 +2.3500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7974e-10 +2.3500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9177e-10 +2.3500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4352e-10 +2.3500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0861e-10 +2.3500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.9061e-11 +2.3500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.1090e-11 +2.3500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.3472e-11 +2.3500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0246e-11 +2.3500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1203e-11 +2.3500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.8881e-12 +2.3500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.3786e-12 +2.3500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.3252e-13 +2.3500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.8327e-13 +2.3500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -8.1458e-14 +2.3500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.7141e-09 +2.3500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8926e-09 +2.3500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.7625e-10 +2.3500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9634e-10 +2.3500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0368e-10 +2.3500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2513e-10 +2.3500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6124e-11 +2.3500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6830e-11 +2.3500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6989e-11 +2.3500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4504e-12 +2.3500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.3936e-12 +2.4500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1682e-10 +2.4500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8295e-10 +2.4500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0721e-10 +2.4500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5394e-10 +2.4500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1504e-10 +2.4500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.7062e-11 +2.4500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0666e-11 +2.4500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.2579e-11 +2.4500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0161e-11 +2.4500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1504e-11 +2.4500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -6.0190e-12 +2.4500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.5652e-12 +2.4500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.9923e-13 +2.4500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.8935e-13 +2.4500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -8.0330e-14 +2.4500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6748e-09 +2.4500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8834e-09 +2.4500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.3743e-10 +2.4500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9006e-10 +2.4500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1333e-10 +2.4500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1793e-10 +2.4500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.7412e-11 +2.4500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5905e-11 +2.4500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6085e-11 +2.4500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.9484e-12 +2.4500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2603e-12 +2.5500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0501e-10 +2.5500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8727e-10 +2.5500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0787e-10 +2.5500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5344e-10 +2.5500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0684e-10 +2.5500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2880e-11 +2.5500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4938e-11 +2.5500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4831e-11 +2.5500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1128e-11 +2.5500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1044e-11 +2.5500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.9611e-12 +2.5500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.3836e-12 +2.5500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.4421e-13 +2.5500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.0409e-13 +2.5500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -7.7829e-14 +2.5500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5100e-09 +2.5500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9249e-09 +2.5500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.4655e-10 +2.5500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0526e-10 +2.5500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0752e-10 +2.5500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2365e-10 +2.5500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6660e-11 +2.5500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5453e-11 +2.5500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7265e-11 +2.5500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.0454e-12 +2.5500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.3553e-12 +2.6500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9428e-10 +2.6500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6846e-10 +2.6500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0963e-10 +2.6500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4815e-10 +2.6500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0536e-10 +2.6500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.8224e-11 +2.6500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0547e-11 +2.6500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.3181e-11 +2.6500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9479e-11 +2.6500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1610e-11 +2.6500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.6658e-12 +2.6500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.5883e-12 +2.6500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.9766e-13 +2.6500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.9052e-13 +2.6500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -7.7684e-14 +2.6500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6081e-09 +2.6500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8657e-09 +2.6500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.3039e-10 +2.6500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0240e-10 +2.6500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2460e-10 +2.6500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1839e-10 +2.6500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.5577e-11 +2.6500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3265e-11 +2.6500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6955e-11 +2.6500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.7183e-12 +2.6500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.3936e-12 +2.7500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9930e-10 +2.7500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7728e-10 +2.7500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9829e-10 +2.7500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5029e-10 +2.7500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0417e-10 +2.7500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5722e-11 +2.7500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.1443e-11 +2.7500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5381e-11 +2.7500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0076e-11 +2.7500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1926e-11 +2.7500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -6.0074e-12 +2.7500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.5448e-12 +2.7500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.6229e-13 +2.7500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.9450e-13 +2.7500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -8.1628e-14 +2.7500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.4490e-09 +2.7500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8857e-09 +2.7500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2285e-10 +2.7500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2468e-10 +2.7500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0640e-10 +2.7500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2720e-10 +2.7500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9725e-11 +2.7500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3575e-11 +2.7500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6765e-11 +2.7500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -8.1393e-12 +2.7500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2049e-12 +2.8500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9696e-10 +2.8500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6397e-10 +2.8500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0473e-10 +2.8500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5405e-10 +2.8500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0792e-10 +2.8500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0322e-11 +2.8500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.2547e-11 +2.8500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4509e-11 +2.8500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.1043e-11 +2.8500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1378e-11 +2.8500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.7616e-12 +2.8500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4018e-12 +2.8500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.6410e-13 +2.8500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -2.7480e-13 +2.8500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -7.3716e-14 +2.8500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.7107e-09 +2.8500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8840e-09 +2.8500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.3153e-10 +2.8500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9814e-10 +2.8500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0879e-10 +2.8500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2343e-10 +2.8500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -7.0644e-11 +2.8500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6214e-11 +2.8500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7744e-11 +2.8500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.8185e-12 +2.8500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2904e-12 +2.9500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2620e-10 +2.9500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6831e-10 +2.9500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9385e-10 +2.9500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4207e-10 +2.9500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0905e-10 +2.9500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2840e-11 +2.9500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3148e-11 +2.9500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.2679e-11 +2.9500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0502e-11 +2.9500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0918e-11 +2.9500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.7784e-12 +2.9500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.3958e-12 +2.9500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -8.7800e-13 +2.9500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.0459e-13 +2.9500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -7.9385e-14 +2.9500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6550e-09 +2.9500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.7779e-09 +2.9500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.9488e-10 +2.9500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1770e-10 +2.9500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2232e-10 +2.9500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1944e-10 +2.9500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6858e-11 +2.9500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5481e-11 +2.9500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7540e-11 +2.9500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.6787e-12 +2.9500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2911e-12 +3.0500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9356e-10 +3.0500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8605e-10 +3.0500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0600e-10 +3.0500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4933e-10 +3.0500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1316e-10 +3.0500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2780e-11 +3.0500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3886e-11 +3.0500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4279e-11 +3.0500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0645e-11 +3.0500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1379e-11 +3.0500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.7032e-12 +3.0500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.5351e-12 +3.0500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.5317e-13 +3.0500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.3002e-13 +3.0500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.0092e-14 +3.0500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5721e-09 +3.0500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8166e-09 +3.0500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.4164e-10 +3.0500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0920e-10 +3.0500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1867e-10 +3.0500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2248e-10 +3.0500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.4486e-11 +3.0500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.7150e-11 +3.0500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6705e-11 +3.0500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4616e-12 +3.0500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1964e-12 +3.1500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0579e-10 +3.1500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8769e-10 +3.1500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0593e-10 +3.1500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4128e-10 +3.1500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1496e-10 +3.1500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.9158e-11 +3.1500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.5313e-11 +3.1500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.3648e-11 +3.1500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.8740e-11 +3.1500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0748e-11 +3.1500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.4060e-12 +3.1500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.6263e-12 +3.1500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.7185e-13 +3.1500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.3103e-13 +3.1500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.4087e-14 +3.1500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5353e-09 +3.1500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8304e-09 +3.1500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2155e-10 +3.1500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2520e-10 +3.1500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1407e-10 +3.1500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2700e-10 +3.1500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.5811e-11 +3.1500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3759e-11 +3.1500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7776e-11 +3.1500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.3212e-12 +3.1500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2326e-12 +3.2500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0261e-10 +3.2500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7120e-10 +3.2500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9039e-10 +3.2500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4123e-10 +3.2500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0394e-10 +3.2500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0894e-11 +3.2500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3273e-11 +3.2500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4125e-11 +3.2500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9580e-11 +3.2500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1232e-11 +3.2500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.6522e-12 +3.2500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.5733e-12 +3.2500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.8120e-13 +3.2500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.3413e-13 +3.2500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.4240e-14 +3.2500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6823e-09 +3.2500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9009e-09 +3.2500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.5197e-10 +3.2500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0953e-10 +3.2500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1859e-10 +3.2500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1638e-10 +3.2500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9025e-11 +3.2500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6706e-11 +3.2500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7454e-11 +3.2500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.2867e-12 +3.2500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2019e-12 +3.3500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2687e-10 +3.3500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8985e-10 +3.3500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9776e-10 +3.3500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4075e-10 +3.3500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1022e-10 +3.3500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0480e-11 +3.3500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.1788e-11 +3.3500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4029e-11 +3.3500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0358e-11 +3.3500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0532e-11 +3.3500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.6850e-12 +3.3500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.6133e-12 +3.3500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.9592e-13 +3.3500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.0857e-13 +3.3500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -8.9220e-14 +3.3500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5565e-09 +3.3500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.7976e-09 +3.3500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.3740e-10 +3.3500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1653e-10 +3.3500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0406e-10 +3.3500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1643e-10 +3.3500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6353e-11 +3.3500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3667e-11 +3.3500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6287e-11 +3.3500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.6337e-12 +3.3500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1390e-12 +3.4500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0426e-10 +3.4500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7487e-10 +3.4500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0171e-10 +3.4500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5127e-10 +3.4500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1325e-10 +3.4500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0506e-11 +3.4500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0943e-11 +3.4500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.1758e-11 +3.4500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.8797e-11 +3.4500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0442e-11 +3.4500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.4009e-12 +3.4500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4872e-12 +3.4500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.3126e-13 +3.4500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.2838e-13 +3.4500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.1029e-14 +3.4500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5078e-09 +3.4500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.7816e-09 +3.4500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.4912e-10 +3.4500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.8666e-10 +3.4500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1171e-10 +3.4500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2564e-10 +3.4500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.5373e-11 +3.4500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5751e-11 +3.4500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6977e-11 +3.4500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4435e-12 +3.4500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2689e-12 +3.5500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9127e-10 +3.5500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8690e-10 +3.5500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0832e-10 +3.5500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4627e-10 +3.5500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0582e-10 +3.5500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.7944e-11 +3.5500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4727e-11 +3.5500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.2197e-11 +3.5500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0071e-11 +3.5500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0471e-11 +3.5500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.3276e-12 +3.5500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.6361e-12 +3.5500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.9927e-13 +3.5500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.3805e-13 +3.5500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.4530e-14 +3.5500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6697e-09 +3.5500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8701e-09 +3.5500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.6826e-10 +3.5500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0224e-10 +3.5500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0777e-10 +3.5500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2239e-10 +3.5500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -7.0154e-11 +3.5500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4453e-11 +3.5500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7531e-11 +3.5500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.1510e-12 +3.5500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1449e-12 +3.6500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9741e-10 +3.6500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6883e-10 +3.6500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0417e-10 +3.6500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4582e-10 +3.6500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0916e-10 +3.6500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5501e-11 +3.6500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0860e-11 +3.6500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.3222e-11 +3.6500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0513e-11 +3.6500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.1053e-11 +3.6500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.3638e-12 +3.6500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4453e-12 +3.6500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.3516e-13 +3.6500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.0874e-13 +3.6500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.1521e-14 +3.6500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6674e-09 +3.6500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8933e-09 +3.6500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2719e-10 +3.6500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2024e-10 +3.6500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2220e-10 +3.6500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1767e-10 +3.6500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.7372e-11 +3.6500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6126e-11 +3.6500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6633e-11 +3.6500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.3487e-12 +3.6500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.0079e-12 +3.7500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2098e-10 +3.7500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6576e-10 +3.7500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.8906e-10 +3.7500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4801e-10 +3.7500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0777e-10 +3.7500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.9975e-11 +3.7500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4747e-11 +3.7500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4073e-11 +3.7500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.8825e-11 +3.7500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0542e-11 +3.7500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.6410e-12 +3.7500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4684e-12 +3.7500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.8634e-13 +3.7500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.1094e-13 +3.7500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.1383e-14 +3.7500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.3935e-09 +3.7500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8476e-09 +3.7500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.1414e-10 +3.7500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1579e-10 +3.7500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1225e-10 +3.7500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2594e-10 +3.7500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6580e-11 +3.7500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5506e-11 +3.7500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6991e-11 +3.7500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4278e-12 +3.7500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1141e-12 +3.8500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.8532e-10 +3.8500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7172e-10 +3.8500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0276e-10 +3.8500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4295e-10 +3.8500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1340e-10 +3.8500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.7460e-11 +3.8500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4864e-11 +3.8500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.5150e-11 +3.8500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9140e-11 +3.8500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0835e-11 +3.8500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.5890e-12 +3.8500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4695e-12 +3.8500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.8916e-13 +3.8500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.2073e-13 +3.8500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -8.8330e-14 +3.8500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.3520e-09 +3.8500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8719e-09 +3.8500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.6857e-10 +3.8500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9417e-10 +3.8500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1224e-10 +3.8500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2587e-10 +3.8500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.8538e-11 +3.8500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5779e-11 +3.8500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6219e-11 +3.8500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.5241e-12 +3.8500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.0104e-12 +3.9500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.8588e-10 +3.9500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6633e-10 +3.9500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9886e-10 +3.9500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4945e-10 +3.9500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0893e-10 +3.9500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2606e-11 +3.9500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0834e-11 +3.9500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.1804e-11 +3.9500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9247e-11 +3.9500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -9.9803e-12 +3.9500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.4763e-12 +3.9500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4175e-12 +3.9500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -1.0245e-12 +3.9500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.2821e-13 +3.9500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0206e-13 +3.9500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5529e-09 +3.9500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9124e-09 +3.9500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2627e-10 +3.9500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.1626e-10 +3.9500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2143e-10 +3.9500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2037e-10 +3.9500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.8553e-11 +3.9500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5224e-11 +3.9500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7153e-11 +3.9500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.3880e-12 +3.9500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1452e-12 +4.0500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1825e-10 +4.0500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.6629e-10 +4.0500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9457e-10 +4.0500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4876e-10 +4.0500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0403e-10 +4.0500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5190e-11 +4.0500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.1303e-11 +4.0500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4432e-11 +4.0500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0271e-11 +4.0500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0124e-11 +4.0500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.1464e-12 +4.0500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4839e-12 +4.0500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.5285e-13 +4.0500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.2996e-13 +4.0500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0376e-13 +4.0500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5328e-09 +4.0500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8424e-09 +4.0500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2160e-10 +4.0500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2570e-10 +4.0500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2314e-10 +4.0500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2257e-10 +4.0500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9306e-11 +4.0500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.3850e-11 +4.0500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6396e-11 +4.0500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.5137e-12 +4.0500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1967e-12 +4.1500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9682e-10 +4.1500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7372e-10 +4.1500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0497e-10 +4.1500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5090e-10 +4.1500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0418e-10 +4.1500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.6031e-11 +4.1500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3178e-11 +4.1500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4696e-11 +4.1500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9134e-11 +4.1500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0993e-11 +4.1500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.2671e-12 +4.1500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4571e-12 +4.1500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -1.0441e-12 +4.1500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.4703e-13 +4.1500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.8801e-14 +4.1500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.3617e-09 +4.1500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8517e-09 +4.1500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.1311e-10 +4.1500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2801e-10 +4.1500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2284e-10 +4.1500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2019e-10 +4.1500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6499e-11 +4.1500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4908e-11 +4.1500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6750e-11 +4.1500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.9738e-12 +4.1500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -2.9965e-12 +4.2500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.2518e-10 +4.2500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.9002e-10 +4.2500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0126e-10 +4.2500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4267e-10 +4.2500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0941e-10 +4.2500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.2639e-11 +4.2500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0801e-11 +4.2500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.3402e-11 +4.2500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9186e-11 +4.2500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0800e-11 +4.2500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.3632e-12 +4.2500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.3630e-12 +4.2500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.6269e-13 +4.2500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.5183e-13 +4.2500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0015e-13 +4.2500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5349e-09 +4.2500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.7780e-09 +4.2500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.1373e-10 +4.2500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.8746e-10 +4.2500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2403e-10 +4.2500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2008e-10 +4.2500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.5452e-11 +4.2500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4365e-11 +4.2500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7607e-11 +4.2500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.3549e-12 +4.2500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -2.9658e-12 +4.3500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1406e-10 +4.3500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8704e-10 +4.3500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9013e-10 +4.3500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4668e-10 +4.3500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1416e-10 +4.3500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.9903e-11 +4.3500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3250e-11 +4.3500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4952e-11 +4.3500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -2.0262e-11 +4.3500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0351e-11 +4.3500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.0911e-12 +4.3500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.3328e-12 +4.3500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.5848e-13 +4.3500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.5017e-13 +4.3500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.6188e-14 +4.3500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.7134e-09 +4.3500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8423e-09 +4.3500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.1286e-10 +4.3500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2508e-10 +4.3500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2304e-10 +4.3500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1792e-10 +4.3500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9298e-11 +4.3500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4242e-11 +4.3500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7180e-11 +4.3500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4661e-12 +4.3500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1687e-12 +4.4500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.0024e-10 +4.4500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8107e-10 +4.4500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0753e-10 +4.4500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4609e-10 +4.4500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1503e-10 +4.4500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0655e-11 +4.4500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.2225e-11 +4.4500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.2673e-11 +4.4500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9097e-11 +4.4500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0023e-11 +4.4500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.5345e-12 +4.4500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4221e-12 +4.4500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -1.0469e-12 +4.4500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.2774e-13 +4.4500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.9495e-14 +4.4500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5105e-09 +4.4500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.7971e-09 +4.4500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.1109e-10 +4.4500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9041e-10 +4.4500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.1869e-10 +4.4500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1770e-10 +4.4500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.8335e-11 +4.4500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.4092e-11 +4.4500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7237e-11 +4.4500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.4598e-12 +4.4500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2004e-12 +4.5500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9321e-10 +4.5500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7382e-10 +4.5500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0014e-10 +4.5500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4560e-10 +4.5500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1114e-10 +4.5500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5550e-11 +4.5500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.2562e-11 +4.5500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.1802e-11 +4.5500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9662e-11 +4.5500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0675e-11 +4.5500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.2212e-12 +4.5500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4450e-12 +4.5500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -1.0195e-12 +4.5500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.6205e-13 +4.5500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -9.8914e-14 +4.5500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.7098e-09 +4.5500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8300e-09 +4.5500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.9700e-10 +4.5500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2026e-10 +4.5500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0675e-10 +4.5500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1661e-10 +4.5500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.9757e-11 +4.5500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5959e-11 +4.5500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7112e-11 +4.5500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.7092e-12 +4.5500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -2.9038e-12 +4.6500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1810e-10 +4.6500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8917e-10 +4.6500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0864e-10 +4.6500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4686e-10 +4.6500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.1273e-10 +4.6500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -8.0698e-11 +4.6500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.0473e-11 +4.6500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4814e-11 +4.6500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.8791e-11 +4.6500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0798e-11 +4.6500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.4743e-12 +4.6500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4974e-12 +4.6500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -1.0285e-12 +4.6500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.6167e-13 +4.6500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0469e-13 +4.6500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.3626e-09 +4.6500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8683e-09 +4.6500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.0935e-10 +4.6500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.9996e-10 +4.6500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0543e-10 +4.6500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2185e-10 +4.6500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.8067e-11 +4.6500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.5381e-11 +4.6500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.7328e-11 +4.6500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.1935e-12 +4.6500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.2116e-12 +4.7500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9875e-10 +4.7500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.8932e-10 +4.7500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0466e-10 +4.7500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.4653e-10 +4.7500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0639e-10 +4.7500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.9879e-11 +4.7500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4398e-11 +4.7500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4645e-11 +4.7500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.8629e-11 +4.7500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0750e-11 +4.7500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.3586e-12 +4.7500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.5566e-12 +4.7500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.5891e-13 +4.7500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.3762e-13 +4.7500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0465e-13 +4.7500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.4503e-09 +4.7500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9106e-09 +4.7500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.4767e-10 +4.7500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -3.8624e-10 +4.7500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2084e-10 +4.7500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2063e-10 +4.7500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -7.1059e-11 +4.7500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6481e-11 +4.7500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6334e-11 +4.7500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.3157e-12 +4.7500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -2.9809e-12 +4.8500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -4.1812e-10 +4.8500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.7091e-10 +4.8500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -2.0142e-10 +4.8500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5374e-10 +4.8500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0624e-10 +4.8500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5629e-11 +4.8500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.3338e-11 +4.8500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.1818e-11 +4.8500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9188e-11 +4.8500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0639e-11 +4.8500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.5538e-12 +4.8500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4438e-12 +4.8500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.9864e-13 +4.8500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.4472e-13 +4.8500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0537e-13 +4.8500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.5031e-09 +4.8500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.8554e-09 +4.8500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.2249e-10 +4.8500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.0741e-10 +4.8500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.0677e-10 +4.8500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.1612e-10 +4.8500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -6.6649e-11 +4.8500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6044e-11 +4.8500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6971e-11 +4.8500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.2861e-12 +4.8500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1049e-12 +4.9500e+03 0.0000e+00 3.0000e+01 1.2715e-05 -3.9135e-10 +4.9500e+03 0.0000e+00 3.0000e+01 2.0715e-05 -2.9127e-10 +4.9500e+03 0.0000e+00 3.0000e+01 3.3215e-05 -1.9330e-10 +4.9500e+03 0.0000e+00 3.0000e+01 5.3715e-05 -1.5404e-10 +4.9500e+03 0.0000e+00 3.0000e+01 8.6215e-05 -1.0428e-10 +4.9500e+03 0.0000e+00 3.0000e+01 1.3672e-04 -7.5099e-11 +4.9500e+03 0.0000e+00 3.0000e+01 2.1771e-04 -5.4537e-11 +4.9500e+03 0.0000e+00 3.0000e+01 3.4671e-04 -3.4867e-11 +4.9500e+03 0.0000e+00 3.0000e+01 5.5172e-04 -1.9784e-11 +4.9500e+03 0.0000e+00 3.0000e+01 8.7721e-04 -1.0445e-11 +4.9500e+03 0.0000e+00 3.0000e+01 1.3942e-03 -5.3089e-12 +4.9500e+03 0.0000e+00 3.0000e+01 2.2167e-03 -2.4837e-12 +4.9500e+03 0.0000e+00 3.0000e+01 3.5237e-03 -9.5445e-13 +4.9500e+03 0.0000e+00 3.0000e+01 5.6012e-03 -3.3166e-13 +4.9500e+03 0.0000e+00 3.0000e+01 8.9022e-03 -1.0619e-13 +4.9500e+03 0.0000e+00 3.0000e+01 1.0215e-05 -3.6609e-09 +4.9500e+03 0.0000e+00 3.0000e+01 1.6215e-05 -1.9386e-09 +4.9500e+03 0.0000e+00 3.0000e+01 2.6215e-05 -8.6119e-10 +4.9500e+03 0.0000e+00 3.0000e+01 4.2215e-05 -4.2716e-10 +4.9500e+03 0.0000e+00 3.0000e+01 6.8215e-05 -2.2551e-10 +4.9500e+03 0.0000e+00 3.0000e+01 1.0872e-04 -1.2481e-10 +4.9500e+03 0.0000e+00 3.0000e+01 1.7222e-04 -7.0745e-11 +4.9500e+03 0.0000e+00 3.0000e+01 2.7471e-04 -3.6553e-11 +4.9500e+03 0.0000e+00 3.0000e+01 4.3771e-04 -1.6824e-11 +4.9500e+03 0.0000e+00 3.0000e+01 6.9571e-04 -7.2240e-12 +4.9500e+03 0.0000e+00 3.0000e+01 1.1057e-03 -3.1049e-12 diff --git a/tutorials/plot_1_fdem_fwd.py b/tutorials/plot_1_fdem_fwd.py new file mode 100644 index 0000000..a7b58ca --- /dev/null +++ b/tutorials/plot_1_fdem_fwd.py @@ -0,0 +1,169 @@ +""" +Single Sounding Forward Simulation of 1D Frequency-Domain Data +============================================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +from matplotlib import pyplot as plt +from discretize import TensorMesh + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer + +plt.rcParams.update({'font.size': 16}) +save_file = False + +##################################################################### +# Create Survey +# ------------- +# +# + +source_location = np.array([0., 0., 30.]) +source_current = 1. +source_radius = 5. +moment_amplitude = 1. + +receiver_location = np.array([10., 0., 30.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "ppm" # "secondary", "total" or "ppm" + +frequencies = np.array([382, 1822, 7970, 35920, 130100], dtype=float) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real" + ) +) +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag" + ) +) + +# Sources +#source_list = [ +# em1d.sources.HarmonicHorizontalLoopSource( +# receiver_list=receiver_list, location=source_location, a=source_radius, +# I=source_current +# ) +#] + +source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) +] + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Physical properties +background_conductivity = 1e-1 +layer_conductivity = 1e0 + +# Layer thicknesses +thicknesses = np.array([20., 40.]) +n_layer = len(thicknesses) + 1 + +# physical property models +model = background_conductivity*np.ones(n_layer) +model[1] = layer_conductivity + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + +# Plot conductivity model +plotting_mesh = TensorMesh([np.r_[thicknesses, 40.]]) +plotLayer(model, plotting_mesh, showlayers=False) + +####################################################################### +# Define the Forward Simulation and Predict Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, +) + +dpred = simulation.dpred(model) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(frequencies, np.abs(dpred[0:len(frequencies)]), 'k-o', lw=3, ms=10) +ax.loglog(frequencies, np.abs(dpred[len(frequencies):]), 'k:o', lw=3, ms=10) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["Real", "Imaginary"]) + +if save_file == True: + + noise = 0.05*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_data.obs' + np.savetxt( + fname, + np.c_[frequencies, dpred[0:len(frequencies)], dpred[len(frequencies):]], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_fdem_fwd_dispersive.py b/tutorials/plot_1_fdem_fwd_dispersive.py new file mode 100644 index 0000000..a7482a5 --- /dev/null +++ b/tutorials/plot_1_fdem_fwd_dispersive.py @@ -0,0 +1,184 @@ +""" +Forward Simulation for Dispersive Physical Properties +===================================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +from matplotlib import pyplot as plt + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D.analytics import ColeCole + + +##################################################################### +# Create Survey +# ------------- +# +# + +source_location = np.array([0., 0., 0.]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +moment_amplitude = 1. + +receiver_location = np.array([8., 0., 0.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +frequencies = np.logspace(-1, 8, 51) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real" + ) +) + +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type="secondary", component="imag" + ) +) + +# Sources +source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation=source_orientation, + moment_amplitude=moment_amplitude + ) +] + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Layer thicknesses +thicknesses = np.array([20., 20.]) +n_layer = len(thicknesses) + 1 + +# half-space physical properties +sigma = 1e-2 +eta = 0.5 +tau = 0.001 +c = 0.5 +chi = 0. + +# physical property models +sigma_model = sigma * np.ones(n_layer) +eta_model = eta * np.ones(n_layer) +tau_model = tau * np.ones(n_layer) +c_model = c * np.ones(n_layer) +chi_model = chi * np.ones(n_layer) + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + +# Compute and plot complex conductivity at all frequencies +sigma_complex = ColeCole(frequencies, sigma, eta, tau, c) + +fig = plt.figure() +ax = fig.add_subplot(111) +ax.semilogx(frequencies, sigma*np.ones(len(frequencies)), "b", lw=3) +ax.semilogx(frequencies, np.real(sigma_complex), "r", lw=3) +ax.semilogx(frequencies, np.imag(sigma_complex), "r--", lw=3) +ax.set_xlim(np.min(frequencies), np.max(frequencies)) +ax.set_ylim(0., 1.1*sigma) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("Conductivity") +ax.legend( + ["$\sigma_{\infty}$", "$Re[\sigma (\omega)]$", "$Im[\sigma (\omega)]$"], + loc="center right" +) +plt.show() + +####################################################################### +# Define the Forward Simulation and Predict Data +# ----------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, + chi=chi_model +) + +dpred = simulation.dpred(sigma_model) + +# Simulate response for complex conductivity +simulation_colecole = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, + eta=eta, tau=tau, c=c, chi=chi_model +) + +dpred_colecole = simulation_colecole.dpred(sigma_model) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(frequencies, np.abs(dpred[0:len(frequencies)]), 'b-', lw=2) +ax.loglog(frequencies, np.abs(dpred[len(frequencies):]), 'b--', lw=2) +ax.loglog(frequencies, np.abs(dpred_colecole[0:len(frequencies)]), 'r-', lw=2) +ax.loglog(frequencies, np.abs(dpred_colecole[len(frequencies):]), 'r--', lw=2) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|H| (A/m)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(( + 'Real (non-chargeable)', 'Imaginary (non-chargeable)', + 'Real (chargeable)', 'Imaginary (chargeable)' +)) + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_fdem_fwd_height.py b/tutorials/plot_1_fdem_fwd_height.py new file mode 100644 index 0000000..6c7822b --- /dev/null +++ b/tutorials/plot_1_fdem_fwd_height.py @@ -0,0 +1,167 @@ +""" +Forward Simulation of 1D Frequency-Domain Data +============================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +from matplotlib import pyplot as plt +from discretize import TensorMesh + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer + +plt.rcParams.update({'font.size': 16}) +save_file = False + +##################################################################### +# Create Survey +# ------------- +# +# + +h = 30. # source +source_location = np.array([0., 0., 30.]) # Third entry will be redundant +source_current = 1. +source_radius = 5. +moment_amplitude = 1. + +source_receiver_offset = np.array([10., 0., 0.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "ppm" # "secondary", "total" or "ppm" + +frequencies = np.array([382, 1822, 7970, 35920, 130100], dtype=float) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + source_receiver_offset, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real", use_source_receiver_offset=True + ) +) +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + source_receiver_offset, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag", use_source_receiver_offset=True + ) +) + +source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) +] + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Physical properties +background_conductivity = 1e-1 +layer_conductivity = 1e0 + +# Layer thicknesses +thicknesses = np.array([20., 40.]) +n_layer = len(thicknesses) + 1 + +# physical property models +model = background_conductivity*np.ones(n_layer) +model[1] = layer_conductivity + +# add source heigh to model +model = np.r_[model, h] + +# Define a mapping for conductivities +wires = maps.Wires(('sigma', n_layer),('h', 1)) +sigma_map = wires.sigma +h_map = wires.h + +# Plot conductivity model +plotting_mesh = TensorMesh([np.r_[thicknesses, 40.]]) +plotLayer(model[0:-1], plotting_mesh, showlayers=False) + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=sigma_map, hMap=h_map, +) + +dpred = simulation.dpred(model) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(frequencies, np.abs(dpred[0:len(frequencies)]), 'k-o', lw=3, ms=10) +ax.loglog(frequencies, np.abs(dpred[len(frequencies):]), 'k:o', lw=3, ms=10) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["Real", "Imaginary"]) + +if save_file == True: + + noise = 0.05*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_data.obs' + np.savetxt( + fname, + np.c_[frequencies, dpred[0:len(frequencies)], dpred[len(frequencies):]], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_fdem_fwd_sources.py b/tutorials/plot_1_fdem_fwd_sources.py new file mode 100644 index 0000000..e39250f --- /dev/null +++ b/tutorials/plot_1_fdem_fwd_sources.py @@ -0,0 +1,201 @@ +""" +Forward Simulation over a Chargeable Earth +========================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +from matplotlib import pyplot as plt + +from SimPEG import maps +import simpegEM1D as em1d +from empymod.transform import dlf, fourier_dlf, get_dlf_points +from empymod import filters + +##################################################################### +# Create Survey +# ------------- +# +# + +source_location = np.array([0., 0., 2.]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +source_radius = np.sqrt(1/np.pi) + +phi = (np.pi/4)*np.r_[1, 3, 5, 7, 1] +node_locations = np.c_[np.cos(phi), np.sin(phi), np.zeros(len(phi))] + +receiver_location_1 = np.array([10., 0., 1.]) +receiver_location_2 = np.array([0., 0., 1.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +frequencies = np.logspace(-1, 8, 51) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location_1, frequencies, orientation='z', + field_type=field_type, component="real" + ) +) + +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location_1, frequencies, orientation='z', + field_type=field_type, component="imag" + ) +) + +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location_2, frequencies, orientation='z', + field_type=field_type, component="real" + ) +) + +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location_2, frequencies, orientation='z', + field_type=field_type, component="imag" + ) +) + +# Sources +source_list = [] + +source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list[0:2], location=source_location, + orientation="z", moment_amplitude=1. + ) +) + +#source_list.append( +# em1d.sources.HarmonicMagneticDipoleSource( +# receiver_list=receiver_list[2:], location=source_location, +# orientation="z", I=source_current +# ) +#) + +source_list.append( + em1d.sources.HarmonicHorizontalLoopSource( + receiver_list=receiver_list[2:], location=source_location, + a=source_radius, I=source_current + ) +) + +#source_list.append( +# em1d.sources.HarmonicLineSource( +# receiver_list=receiver_list, location=node_locations, +# I=source_current +# ) +#) + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Layer thicknesses +thicknesses = np.array([20., 20.]) +n_layer = len(thicknesses) + 1 + +# half-space physical properties +sigma = 1e-2 +eta = 0.5 +tau = 0.001 +c = 0.5 +chi = 0. + +# physical property models +sigma_model = sigma * np.ones(n_layer) +eta_model = eta * np.ones(n_layer) +tau_model = tau * np.ones(n_layer) +c_model = c * np.ones(n_layer) +chi_model = chi * np.ones(n_layer) + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, + chi=chi_model +) + +dpred = simulation.dpred(sigma_model) + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + +dpred = np.reshape(dpred, (4, len(frequencies))).T + + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(frequencies, np.abs(dpred[:,0]), 'b-', lw=2) +ax.loglog(frequencies, np.abs(dpred[:,1]), 'b--', lw=2) +ax.loglog(frequencies, np.abs(dpred[:,2]), 'r-', lw=2) +ax.loglog(frequencies, np.abs(dpred[:,3]), 'r--', lw=2) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|H| (A/m)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(( + 'Real (dipole)', 'Imaginary (dipole)', + 'Real (loop)', 'Imaginary (loop)', + 'Real (line)', 'Imaginary (line)' +)) + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_fdem_inv.py b/tutorials/plot_1_fdem_inv.py new file mode 100644 index 0000000..aa8929c --- /dev/null +++ b/tutorials/plot_1_fdem_inv.py @@ -0,0 +1,391 @@ +""" +Inversion of 1D Frequency-Domain Data +============================================== + + +""" + + +######################################################################### +# Import modules +# -------------- +# + +import os, shutil +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt + +from discretize import TensorMesh + +import simpegEM1D as em1d +from simpegEM1D.utils import get_vertical_discretization_frequency, plotLayer +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +plt.rcParams.update({'font.size': 16, 'lines.linewidth': 2, 'lines.markersize':8}) + +# sphinx_gallery_thumbnail_number = 3 + +############################################# +# Define File Names +# ----------------- +# +# File paths for assets we are loading. To set up the inversion, we require +# topography and field observations. The true model defined on the whole mesh +# is loaded to compare with the inversion result. +# + +data_filename = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_data.obs' + + + +############################################# +# Load Data and Plot +# ------------------ +# +# Here we load and plot synthetic gravity anomaly data. Topography is generally +# defined as an (N, 3) array. Gravity data is generally defined with 4 columns: +# x, y, z and data. +# + +# Load field data +dobs = np.loadtxt(str(data_filename)) + +# Define receiver locations and observed data +frequencies = dobs[:, 0] +dobs = mkvc(dobs[:, 1:]) + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(frequencies, np.abs(dobs[0:len(frequencies)]), 'k-o', lw=3) +ax.loglog(frequencies, np.abs(dobs[len(frequencies):]), 'k:o', lw=3) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["Real", "Imaginary"]) + + + +############################################# +# Defining the Survey +# ------------------- + +source_location = np.array([0., 0., 30.]) +source_current = 1. +source_radius = 5. +moment_amplitude=1. + +receiver_location = np.array([10., 0., 30.]) +receiver_orientation = "z" +field_type = "ppm" + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real" + ) +) +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag" + ) +) + +# Sources +#source_list = [ +# em1d.sources.HarmonicHorizontalLoopSource( +# receiver_list=receiver_list, location=source_location, a=source_radius, +# I=source_current +# ) +#] + +source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) +] + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################# +# Assign Uncertainties +# -------------------- +# +# + +uncertainties = 0.05*np.abs(dobs)*np.ones(np.shape(dobs)) + + +############################################### +# Define Data +# -------------------- +# +# Here is where we define the data that are inverted. The data are defined by +# the survey, the observation values and the uncertainties. +# + +data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + +############################################################### +# Defining a 1D Layered Earth (1D Tensor Mesh) +# -------------------------------------------- +# +# Here, we define the layer thicknesses for our 1D simulation. To do this, we use +# the TensorMesh class. +# + +# Based on estimate of background conductivity, make layers + +#inv_thicknesses = get_vertical_discretization_frequency( +# frequencies, sigma_background=0.1, +# factor_fmax=20, factor_fmin=1., n_layer=50, +#) + +inv_thicknesses = np.logspace(0,1.5,25) + +# Define a mesh for plotting and regularization. +mesh = TensorMesh([(np.r_[inv_thicknesses, inv_thicknesses[-1]])], '0') + +print(mesh) + + +######################################################## +# Define a Starting and Reference Model +# ------------------------------------- +# +# Here, we create starting and/or reference models for the inversion as +# well as the mapping from the model space to the active cells. Starting and +# reference models can be a constant background value or contain a-priori +# structures. Here, the starting model is log(0.001) S/m. +# +# Define log-conductivity values for each layer since our model is the +# log-conductivity. Don't make the values 0! +# Otherwise the gradient for the 1st iteration is zero and the inversion will +# not converge. + +# Define model. A resistivity (Ohm meters) or conductivity (S/m) for each layer. +starting_model = np.log(0.1*np.ones(mesh.nC)) + +# Define mapping from model to active cells. +model_mapping = maps.ExpMap() + + + + + + +####################################################################### +# Define the Physics +# ------------------ +# + +simulation = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=inv_thicknesses, sigmaMap=model_mapping +) + + +####################################################################### +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties + + + + +# Define the regularization (model objective function) +reg_map = maps.IdentityMap(nP=mesh.nC) +reg = regularization.Sparse( + mesh, mapping=reg_map, +# alpha_s=1, +) + +reg.mref = starting_model + +# Define sparse and blocky norms p, q +p = 0 +q = 0 +reg.norms = np.c_[p, q] + +#reg.eps_p = 1e-3 +#reg.eps_q = 1e-3 + +# Define how the optimization problem is solved. Here we will use an inexact +# Gauss-Newton approach that employs the conjugate gradient solver. +opt = optimization.ProjectedGNCG(maxIter=100, maxIterLS=20, maxIterCG=20, tolCG=1e-3) + +# Define the inverse problem +inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt) + + +####################################################################### +# Define Inversion Directives +# --------------------------- +# +# Here we define any directiveas that are carried out during the inversion. This +# includes the cooling schedule for the trade-off parameter (beta), stopping +# criteria for the inversion and saving inversion results at each iteration. +# + +# Apply and update sensitivity weighting as the model updates +#sensitivity_weights = directives.UpdateSensitivityWeights() + +# Reach target misfit for L2 solution, then use IRLS until model stops changing. +#IRLS = directives.Update_IRLS(max_irls_iterations=40, minGNiter=1, f_min_change=1e-5, chifact_start=2) +#IRLS = directives.Update_IRLS( +# max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, +# beta_tol=1e-2, f_min_change=1e-5, +# chifact_start = 1. +#) + +# Defining a starting value for the trade-off parameter (beta) between the data +# misfit and the regularization. +starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=1e1) + +# Update the preconditionner +update_Jacobi = directives.UpdatePreconditioner() + +# Options for outputting recovered models and predicted data for each beta. +save_iteration = directives.SaveOutputEveryIteration(save_txt=False) + +# The directives are defined as a list. +#directives_list = [ +# IRLS, +# starting_beta, +# save_iteration, +#] + + + + + +update_IRLS = directives.Update_IRLS( + max_irls_iterations=30, minGNiter=1, + coolEpsFact=1.5, update_beta=True +) + +# Updating the preconditionner if it is model dependent. +update_jacobi = directives.UpdatePreconditioner() + +# Setting a stopping criteria for the inversion. +#target_misfit = directives.TargetMisfit(chifact=1) + +# Add sensitivity weights +sensitivity_weights = directives.UpdateSensitivityWeights() + +# The directives are defined as a list. +directives_list = [ + sensitivity_weights, + starting_beta, + save_iteration, + update_IRLS, + update_jacobi, +] + +##################################################################### +# Running the Inversion +# --------------------- +# +# To define the inversion object, we need to define the inversion problem and +# the set of directives. We can then run the inversion. +# + +# Here we combine the inverse problem and the set of directives +inv = inversion.BaseInversion(inv_prob, directives_list) + +# Run the inversion +recovered_model = inv.run(starting_model) + + +##################################################################### +# Plotting Results +# --------------------- + + +# Load the true model and layer thicknesses +true_model = np.array([0.1, 1., 0.1]) +hz = np.r_[20., 40., 160.] +true_layers = TensorMesh([hz]) + +# Extract Least-Squares model +l2_model = inv_prob.l2model + +# Plot true model and recovered model +fig = plt.figure(figsize=(8, 9)) +x_min = np.min(np.r_[model_mapping * recovered_model, model_mapping * l2_model, true_model]) +x_max = np.max(np.r_[model_mapping * recovered_model, model_mapping * l2_model, true_model]) + +ax1 = fig.add_axes([0.2, 0.15, 0.7, 0.7]) +plotLayer(true_model, true_layers, ax=ax1, showlayers=False, color="k") +plotLayer(model_mapping * l2_model, mesh, ax=ax1, showlayers=False, color="b") +plotLayer(model_mapping * recovered_model, mesh, ax=ax1, showlayers=False, color="r") +ax1.set_xlim(0.01, 10) +ax1.legend(["True Model", "L2-Model", "Sparse Model"]) + +# Plot the true and apparent resistivities on a sounding curve +dpred_l2 = simulation.dpred(l2_model) +dpred_final = simulation.dpred(recovered_model) + +fig = plt.figure(figsize=(11, 6)) +ax1 = fig.add_axes([0.2, 0.1, 0.6, 0.8]) +ax1.loglog(frequencies, np.abs(dobs[0:len(frequencies)]), "k-o") +ax1.loglog(frequencies, np.abs(dobs[len(frequencies):]), "k:o") +ax1.loglog(frequencies, np.abs(dpred_l2[0:len(frequencies)]), "b-o") +ax1.loglog(frequencies, np.abs(dpred_l2[len(frequencies):]), "b:o") +ax1.loglog(frequencies, np.abs(dpred_final[0:len(frequencies)]), "r-o") +ax1.loglog(frequencies, np.abs(dpred_final[len(frequencies):]), "r:o") +ax1.set_xlabel("Frequencies (Hz)") +ax1.set_ylabel("|Hs/Hp| (ppm)") +ax1.legend([ + "Observed (real)", "Observed (imag)", + "L2-Model (real)", "L2-Model (imag)", + "Sparse (real)", "Sparse (imag)"], + loc="upper left" +) +plt.show() + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_fdem_inv_height.py b/tutorials/plot_1_fdem_inv_height.py new file mode 100644 index 0000000..a568d71 --- /dev/null +++ b/tutorials/plot_1_fdem_inv_height.py @@ -0,0 +1,391 @@ +""" +Inversion of 1D Frequency-Domain Data +============================================== + + +""" + + +######################################################################### +# Import modules +# -------------- +# + +import os, shutil +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt + +from discretize import TensorMesh + +import simpegEM1D as em1d +from simpegEM1D.utils import get_vertical_discretization_frequency, plotLayer +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +plt.rcParams.update({'font.size': 16, 'lines.linewidth': 2, 'lines.markersize':8}) + +# sphinx_gallery_thumbnail_number = 3 + +############################################# +# Define File Names +# ----------------- +# +# File paths for assets we are loading. To set up the inversion, we require +# topography and field observations. The true model defined on the whole mesh +# is loaded to compare with the inversion result. +# + +data_filename = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_data.obs' + + + +############################################# +# Load Data and Plot +# ------------------ +# +# Here we load and plot synthetic gravity anomaly data. Topography is generally +# defined as an (N, 3) array. Gravity data is generally defined with 4 columns: +# x, y, z and data. +# + +# Load field data +dobs = np.loadtxt(str(data_filename)) + +# Define receiver locations and observed data +frequencies = dobs[:, 0] +dobs = mkvc(dobs[:, 1:]) + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(frequencies, np.abs(dobs[0:len(frequencies)]), 'k-o', lw=3) +ax.loglog(frequencies, np.abs(dobs[len(frequencies):]), 'k:o', lw=3) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["Real", "Imaginary"]) + + + +############################################# +# Defining the Survey +# ------------------- + +source_location = np.array([0., 0., 30.]) +source_current = 1. +source_radius = 5. +moment_amplitude=1. + +source_receiver_offset = np.array([10., 0., 0.]) +receiver_orientation = "z" +field_type = "ppm" + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + source_receiver_offset, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real", use_source_receiver_offset=True + ) +) +receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + source_receiver_offset, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag", use_source_receiver_offset=True + ) +) + +source_list = [ + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) +] + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################# +# Assign Uncertainties +# -------------------- +# +# + +uncertainties = 0.05*np.abs(dobs)*np.ones(np.shape(dobs)) + + +############################################### +# Define Data +# -------------------- +# +# Here is where we define the data that are inverted. The data are defined by +# the survey, the observation values and the uncertainties. +# + +data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + +############################################################### +# Defining a 1D Layered Earth (1D Tensor Mesh) +# -------------------------------------------- +# +# Here, we define the layer thicknesses for our 1D simulation. To do this, we use +# the TensorMesh class. +# + +# Based on estimate of background conductivity, make layers + +#inv_thicknesses = get_vertical_discretization_frequency( +# frequencies, sigma_background=0.1, +# factor_fmax=20, factor_fmin=1., n_layer=50, +#) + +inv_thicknesses = np.logspace(0,1.5,25) + +# Define a mesh for plotting and regularization. +mesh = TensorMesh([(np.r_[inv_thicknesses, inv_thicknesses[-1]])], '0') + +print(mesh) + + +######################################################## +# Define a Starting and Reference Model +# ------------------------------------- +# +# Here, we create starting and/or reference models for the inversion as +# well as the mapping from the model space to the active cells. Starting and +# reference models can be a constant background value or contain a-priori +# structures. Here, the starting model is log(0.001) S/m. +# +# Define log-conductivity values for each layer since our model is the +# log-conductivity. Don't make the values 0! +# Otherwise the gradient for the 1st iteration is zero and the inversion will +# not converge. + +# Define model. A resistivity (Ohm meters) or conductivity (S/m) for each layer. +starting_conductivity = np.log(0.1*np.ones(mesh.nC)) +starting_height = 25. +starting_model = np.r_[starting_conductivity, starting_height] + +# Define mapping from model to active cells. +wires = maps.Wires(('sigma', mesh.nC),('h', 1)) +sigma_map = maps.ExpMap() * wires.sigma +h_map = wires.h + + + +####################################################################### +# Define the Physics +# ------------------ +# + +simulation = em1d.simulation.EM1DFMSimulation( + survey=survey, thicknesses=inv_thicknesses, sigmaMap=sigma_map, hMap=h_map +) + + +####################################################################### +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties + + + + +# Define the regularization (model objective function) +reg_sigma = regularization.Sparse( + mesh, mapping=wires.sigma, +# alpha_s=1, +) + +# Define sparse and blocky norms p, q +p = 0. +q = 0. +reg_sigma.norms = np.c_[p, q] + +#reg.eps_p = 1e-3 +#reg.eps_q = 1e-3 + +reg_height = regularization.Sparse( + TensorMesh([1]), mapping=wires.h, +) + +p = 0. +reg_sigma.p = p + +reg = reg_sigma + reg_height +reg.mref = starting_model + +# Define how the optimization problem is solved. Here we will use an inexact +# Gauss-Newton approach that employs the conjugate gradient solver. +opt = optimization.ProjectedGNCG(maxIter=100, maxIterLS=20, maxIterCG=20, tolCG=1e-3) + +# Define the inverse problem +inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt) + + +####################################################################### +# Define Inversion Directives +# --------------------------- +# +# Here we define any directiveas that are carried out during the inversion. This +# includes the cooling schedule for the trade-off parameter (beta), stopping +# criteria for the inversion and saving inversion results at each iteration. +# + +# Apply and update sensitivity weighting as the model updates +#sensitivity_weights = directives.UpdateSensitivityWeights() + +# Reach target misfit for L2 solution, then use IRLS until model stops changing. +#IRLS = directives.Update_IRLS(max_irls_iterations=40, minGNiter=1, f_min_change=1e-5, chifact_start=2) +#IRLS = directives.Update_IRLS( +# max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, +# beta_tol=1e-2, f_min_change=1e-5, +# chifact_start = 1. +#) + +# Defining a starting value for the trade-off parameter (beta) between the data +# misfit and the regularization. +starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=1e1) + +# Update the preconditionner +update_Jacobi = directives.UpdatePreconditioner() + +# Options for outputting recovered models and predicted data for each beta. +save_iteration = directives.SaveOutputEveryIteration(save_txt=False) + +# The directives are defined as a list. +#directives_list = [ +# IRLS, +# starting_beta, +# save_iteration, +#] + + + + + +update_IRLS = directives.Update_IRLS( + max_irls_iterations=30, minGNiter=1, + coolEpsFact=1.5, update_beta=True +) + +# Updating the preconditionner if it is model dependent. +update_jacobi = directives.UpdatePreconditioner() + +# Setting a stopping criteria for the inversion. +#target_misfit = directives.TargetMisfit(chifact=1) + +# Add sensitivity weights +sensitivity_weights = directives.UpdateSensitivityWeights() + +# The directives are defined as a list. +directives_list = [ + sensitivity_weights, + starting_beta, + save_iteration, + update_IRLS, + update_jacobi, +] + +##################################################################### +# Running the Inversion +# --------------------- +# +# To define the inversion object, we need to define the inversion problem and +# the set of directives. We can then run the inversion. +# + +# Here we combine the inverse problem and the set of directives +inv = inversion.BaseInversion(inv_prob, directives_list) + +# Run the inversion +recovered_model = inv.run(starting_model) + + +##################################################################### +# Plotting Results +# --------------------- + + +# Load the true model and layer thicknesses +true_model = np.array([0.1, 1., 0.1]) +hz = np.r_[20., 40., 160.] +true_layers = TensorMesh([hz]) + +# Extract Least-Squares model +l2_model = inv_prob.l2model + +# Plot true model and recovered model +fig = plt.figure(figsize=(8, 9)) +x_min = np.min(np.r_[sigma_map * recovered_model, sigma_map * l2_model, true_model]) +x_max = np.max(np.r_[sigma_map * recovered_model, sigma_map * l2_model, true_model]) + +ax1 = fig.add_axes([0.2, 0.15, 0.7, 0.7]) +plotLayer(true_model, true_layers, ax=ax1, showlayers=False, color="k") +plotLayer(sigma_map * l2_model, mesh, ax=ax1, showlayers=False, color="b") +plotLayer(sigma_map * recovered_model, mesh, ax=ax1, showlayers=False, color="r") +ax1.set_xlim(0.01, 10) +ax1.legend(["True Model", "L2-Model", "Sparse Model"]) + +# Plot the true and apparent resistivities on a sounding curve +dpred_l2 = simulation.dpred(l2_model) +dpred_final = simulation.dpred(recovered_model) + +fig = plt.figure(figsize=(11, 6)) +ax1 = fig.add_axes([0.2, 0.1, 0.6, 0.8]) +ax1.loglog(frequencies, np.abs(dobs[0:len(frequencies)]), "k-o") +ax1.loglog(frequencies, np.abs(dobs[len(frequencies):]), "k:o") +ax1.loglog(frequencies, np.abs(dpred_l2[0:len(frequencies)]), "b-o") +ax1.loglog(frequencies, np.abs(dpred_l2[len(frequencies):]), "b:o") +ax1.loglog(frequencies, np.abs(dpred_final[0:len(frequencies)]), "r-o") +ax1.loglog(frequencies, np.abs(dpred_final[len(frequencies):]), "r:o") +ax1.set_xlabel("Frequencies (Hz)") +ax1.set_ylabel("|Hs/Hp| (ppm)") +ax1.legend([ + "Observed (real)", "Observed (imag)", + "L2-Model (real)", "L2-Model (imag)", + "Sparse (real)", "Sparse (imag)"], + loc="upper left" +) +plt.show() + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_tdem_fwd.py b/tutorials/plot_1_tdem_fwd.py new file mode 100644 index 0000000..dad739d --- /dev/null +++ b/tutorials/plot_1_tdem_fwd.py @@ -0,0 +1,158 @@ +""" +Forward Simulation of 1D Time-Domain Data +============================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +from matplotlib import pyplot as plt +from discretize import TensorMesh + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer + +save_file = False +plt.rcParams.update({'font.size': 16}) + +##################################################################### +# Create Survey +# ------------- +# +# + +source_location = np.array([0., 0., 20.]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +source_radius = 6. + +receiver_location = np.array([0., 0., 20.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +times = np.logspace(-5, -2, 31) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="b" + ) +) + +# Sources +source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=source_location, + I=source_current, a=source_radius + ) +] + +#source_list = [ +# em1d.sources.TimeDomainMagneticDipoleSource( +# receiver_list=receiver_list, location=source_location, orientation="z", +# I=source_current +# ) +#] + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Physical properties +background_conductivity = 1e-1 +layer_conductivity = 1e0 + +# Layer thicknesses +thicknesses = np.array([40., 40.]) +n_layer = len(thicknesses) + 1 + +# physical property models +model = background_conductivity*np.ones(n_layer) +model[1] = layer_conductivity + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + +# Plot conductivity model +plotting_mesh = TensorMesh([np.r_[thicknesses, 40.]]) +plotLayer(model, plotting_mesh, showlayers=False) + +####################################################################### +# Define the Forward Simulation and Predict Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, +) + +dpred = simulation.dpred(model) + +# Simulate response +fig = plt.figure(figsize = (8, 7)) +ax = fig.add_axes([0.1, 0.1, 0.8, 0.85]) +ax.loglog(times, dpred, 'k-o') +ax.set_xlabel("Times (s)") +ax.set_ylabel("|B| (T)") +ax.set_title("Magnetic Flux") + + +################################################## + + +if save_file == True: + + noise = 0.05*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dtm_data.obs' + np.savetxt( + fname, + np.c_[times, dpred], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_tdem_fwd_chargeable.py b/tutorials/plot_1_tdem_fwd_chargeable.py new file mode 100644 index 0000000..d8d0655 --- /dev/null +++ b/tutorials/plot_1_tdem_fwd_chargeable.py @@ -0,0 +1,256 @@ +""" +Forward Simulation over a Chargeable Earth +========================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +from matplotlib import pyplot as plt + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D.analytics import ColeCole, LogUniform +from discretize.utils import mkvc + + + + + +from scipy.special import expi + +##################################################################### +# Create Survey +# ------------- +# +# + +source_location = np.array([0., 0., 0.5]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +source_radius = 10. + +receiver_location = np.array([0., 0., 0.5]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +times = np.logspace(-6, -1, 51) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="b" + ) +) +receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="dbdt" + ) +) + +# Sources +source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=source_location, + I=source_current, a=source_radius + ) +] + + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Layer thicknesses +thicknesses = np.array([40., 40.]) +n_layer = len(thicknesses) + 1 + +# half-space conductivity properties +sigma = 1e-1 +eta = 0.5 +tau = 0.01 +c = 0.75 + +# half-space magnetic viscosity properties +chi = 0.001 +dchi = 0.001 +tau1 = 1e-7 +tau2 = 1. + + +# physical property models +sigma_model = sigma * np.ones(n_layer) +eta_model = eta * np.ones(n_layer) +tau_model = tau * np.ones(n_layer) +c_model = c * np.ones(n_layer) +chi_model = chi * np.ones(n_layer) +dchi_model = dchi * np.ones(n_layer) +tau1_model = tau1 * np.ones(n_layer) +tau2_model = tau2 * np.ones(n_layer) + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + +# Compute and plot complex conductivity at all frequencies +frequencies = np.logspace(-3, 6, 91) +sigma_complex = ColeCole(frequencies, sigma, eta, tau, c) +chi_complex = LogUniform(frequencies, chi, dchi, tau1, tau2) + +fig = plt.figure() +ax = fig.add_subplot(111) +ax.semilogx(frequencies, sigma*np.ones(len(frequencies)), "b", lw=3) +ax.semilogx(frequencies, np.real(sigma_complex), "r", lw=3) +ax.semilogx(frequencies, np.imag(sigma_complex), "r--", lw=3) +ax.set_xlim(np.min(frequencies), np.max(frequencies)) +ax.set_ylim(0., 1.1*sigma) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("Conductivity") +ax.legend( + ["$\sigma_{DC}$", "$Re[\sigma (\omega)]$", "$Im[\sigma (\omega)]$"], + loc="center right" +) + +fig = plt.figure() +ax = fig.add_subplot(111) +ax.semilogx(frequencies, chi*np.ones(len(frequencies)), "b", lw=3) +ax.semilogx(frequencies, np.real(chi_complex), "r", lw=3) +ax.semilogx(frequencies, np.imag(chi_complex), "r--", lw=3) +ax.set_xlim(np.min(frequencies), np.max(frequencies)) +ax.set_ylim(-1.1*chi, 1.1*(chi+dchi)) +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("Susceptibility") +ax.legend( + ["$\chi_{DC}$", "$Re[\chi (\omega)]$", "$Im[\chi (\omega)]$"], + loc="center right" +) + +####################################################################### +# Define the Forward Simulation and Predict Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation_1 = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, + chi=chi_model +) + +dpred_1 = simulation_1.dpred(sigma_model) + +# Simulate response for complex conductivity +simulation_2 = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, + eta=eta, tau=tau, c=c, chi=chi_model +) + +dpred_2 = simulation_2.dpred(sigma_model) + +# Simulate response for viscous remanent magnetization +simulation_3 = em1d.simulation.EM1DTMSimulation( + survey=survey, sigmaMap=maps.IdentityMap(nP=1), + chi=chi, dchi=dchi, tau1=tau1, tau2=tau2, +) + +# m = mkvc(np.array(sigma)) +m = mkvc(np.array(1e-6)) +dpred_3 = simulation_3.dpred(m) + + +############################################ +# ANALYTIC + + +F = (1/np.log(tau2/tau1)) * (expi(times/tau2) + expi(-times/tau1)) + +dFdt = (1/np.log(tau2/tau1)) * (np.exp(-times/tau1) - np.exp(-times/tau2)) / times + + +mu0 = 4*np.pi*1e-7 +a = source_radius +z = 0.5 +h = 0.5 +B0 = (0.5*mu0*a**2) * (dchi/(2 + dchi)) * ((z + h)**2 + a**2)**-1.5 + + +Banal = B0*F +dBdtanal = B0*dFdt + + + + + + + +############################################ + + +fig = plt.figure(figsize = (6, 5)) +ax = fig.add_axes([0.1, 0.1, 0.8, 0.85]) +ax.loglog(times, np.abs(dpred_1[0:len(times)]), 'k', lw=3) +ax.loglog(times, np.abs(dpred_2[0:len(times)]), 'r', lw=3) +ax.loglog(times, np.abs(dpred_3[0:len(times)]), 'b', lw=3) +ax.loglog(times, np.abs(Banal), 'b*') +ax.legend(["Purely Inductive", "Chargeable", "Viscous Remanent Mag."]) +ax.set_xlabel("Times (s)") +ax.set_ylabel("|B| (T)") +ax.set_title("Magnetic Flux") + +fig = plt.figure(figsize = (6, 5)) +ax = fig.add_axes([0.1, 0.1, 0.8, 0.85]) +ax.loglog(times, np.abs(dpred_1[len(times):]), 'k', lw=3) +ax.loglog(times, np.abs(dpred_2[len(times):]), 'r', lw=3) +ax.loglog(times, np.abs(dpred_3[len(times):]), 'b', lw=3) +ax.loglog(times, np.abs(dBdtanal), 'b*') +ax.legend(["Purely Inductive", "Chargeable", "Viscous Remanent Mag."]) +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dB/dt| (T/s)") +ax.set_title("Time-Derivative of Magnetic Flux") + +################################################## + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_tdem_fwd_skytem.py b/tutorials/plot_1_tdem_fwd_skytem.py new file mode 100644 index 0000000..673e2e6 --- /dev/null +++ b/tutorials/plot_1_tdem_fwd_skytem.py @@ -0,0 +1,172 @@ +""" +Forward Simulation with Different Waveforms +=========================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +from matplotlib import pyplot as plt + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D import skytem_HM_2015, skytem_LM_2015 + + +##################################################################### +# Create Survey +# ------------- +# +# + +wave_HM = skytem_HM_2015() +wave_LM = skytem_LM_2015() +time_HM = wave_HM.time_gate_center[0::2] +time_LM = wave_LM.time_gate_center[0::2] + + +source_location = np.array([0., 0., 40.]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +moment_amplitude=1. +receiver_offset_r = 13.25 +receiver_offset_z = 2. +receiver_location = np.array([receiver_offset_r, 0., 40.+receiver_offset_z ]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +# Receiver list +rx = em1d.receivers.TimeDomainPointReceiver( + receiver_location, + times=time_HM, + times_dual_moment=time_LM, + orientation=receiver_orientation, + component="dbdt" +) +receiver_list = [rx] + +# Sources + +time_input_currents_HM = wave_HM.current_times[-7:] +input_currents_HM = wave_HM.currents[-7:] +time_input_currents_LM = wave_LM.current_times[-13:] +input_currents_LM = wave_LM.currents[-13:] + +src = em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, + location=source_location, + moment_amplitude=moment_amplitude, + orientation=source_orientation, + wave_type="general", + moment_type='dual', + time_input_currents=time_input_currents_HM, + input_currents=input_currents_HM, + n_pulse = 1, + base_frequency = 25., + time_input_currents_dual_moment = time_input_currents_LM, + input_currents_dual_moment = input_currents_LM, + base_frequency_dual_moment = 210 +) +source_list = [src] + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + +############################################### +# Plot the Waveforms +# ------------------ +# +# + +fig = plt.figure(figsize=(6, 4)) +ax = fig.add_axes([0.1, 0.1, 0.85, 0.8]) +ax.plot(time_input_currents_HM, input_currents_HM, 'b', lw=2, label='HM') +ax.plot(time_input_currents_LM, input_currents_LM, 'r', lw=2, label='LM') +ax.set_xlabel("Time (s)") +ax.set_ylabel("Normalized Current (A)") +ax.legend() + + + + + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Layer thicknesses +thicknesses = np.array([40., 40.]) +n_layer = len(thicknesses) + 1 + +# half-space physical properties +sigma = 1e-2 +# physical property models +sigma_model = sigma * np.ones(n_layer) + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + + +####################################################################### +# Define the Forward Simulation and Predict Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, +) + +dpred = simulation.dpred(sigma_model) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +fig = plt.figure(figsize = (6, 5)) +ax = fig.add_axes([0.1, 0.1, 0.8, 0.85]) +ax.loglog(rx.times, -dpred[:rx.times.size], 'b', lw=2, label='HM') +ax.loglog(rx.times_dual_moment, -dpred[rx.times.size:], 'r', lw=2, label='LM') + +ax.legend() +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dB/dt| (T/s)") +plt.show() + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_tdem_fwd_waveforms.py b/tutorials/plot_1_tdem_fwd_waveforms.py new file mode 100644 index 0000000..e76812b --- /dev/null +++ b/tutorials/plot_1_tdem_fwd_waveforms.py @@ -0,0 +1,227 @@ +""" +Forward Simulation with Different Waveforms +=========================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +from matplotlib import pyplot as plt + +from SimPEG import maps +import simpegEM1D as em1d +from simpegEM1D.waveforms import TriangleFun, VTEMFun +from simpegEM1D.analytics import ColeCole + + +##################################################################### +# Create Survey +# ------------- +# +# + +source_location = np.array([0., 0., 0.]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +source_radius = 10. +moment_amplitude=1. + +receiver_location = np.array([10., 0., 0.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +times = np.logspace(-5, -2, 41) + +# Receiver list +receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="dbdt" + ) +] + +# Sources +source_list = [] + +# Step off +source_list.append( + em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, + orientation=source_orientation, moment_amplitude=moment_amplitude, + wave_type="stepoff" + ) +) + +# Triangle Waveform +time_input_currents = np.r_[-np.logspace(-2, -5, 31), 0.] +input_currents = TriangleFun(time_input_currents+0.01, 5e-3, 0.01) +source_list.append( + em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, + moment_amplitude=moment_amplitude, + orientation=source_orientation, + wave_type="general", + time_input_currents=time_input_currents, + input_currents=input_currents, + n_pulse = 1, + base_frequency = 25., + use_lowpass_filter=False, + high_cut_frequency=210*1e3 + ) +) + +# VTEM waveform +time_input_currents_2 = np.r_[-np.logspace(-2, -5, 31), 0.] +input_currents_2 = VTEMFun(time_input_currents+0.01, 8e-3, 0.01, 1) +source_list.append( + em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, + moment_amplitude=moment_amplitude, + orientation=source_orientation, + wave_type="general", + time_input_currents=time_input_currents_2, + input_currents=input_currents_2, + n_pulse = 1, + base_frequency = 25., + use_lowpass_filter=False, + high_cut_frequency=210*1e3 + ) +) + + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + +############################################### +# Plot the Waveforms +# ------------------ +# +# + +fig = plt.figure(figsize=(6, 4)) +ax = fig.add_axes([0.1, 0.1, 0.85, 0.8]) +ax.plot(np.r_[-1e-2, 0., 1e-10, 1e-3], np.r_[1., 1., 0., 0.], 'k', lw=2) +ax.plot(time_input_currents, input_currents, 'b', lw=2) +ax.plot(time_input_currents_2, input_currents_2, 'r', lw=2) +ax.set_xlabel("Time (s)") +ax.set_ylabel("Normalized Current (A)") +ax.legend(["Step-off", "Triangular", "VTEM"]) + + + + + +############################################### +# Defining a 1D Layered Earth Model +# --------------------------------- +# +# Here, we define the layer thicknesses and electrical conductivities for our +# 1D simulation. If we have N layers, we define N electrical conductivity +# values and N-1 layer thicknesses. The lowest layer is assumed to extend to +# infinity. +# + +# Layer thicknesses +thicknesses = np.array([40., 40.]) +n_layer = len(thicknesses) + 1 + +# half-space physical properties +sigma = 1e-2 +eta = 0.5 +tau = 0.01 +c = 0.5 +chi = 0. + +# physical property models +sigma_model = sigma * np.ones(n_layer) +eta_model = eta * np.ones(n_layer) +tau_model = tau * np.ones(n_layer) +c_model = c * np.ones(n_layer) +chi_model = chi * np.ones(n_layer) + +# Define a mapping for conductivities +model_mapping = maps.IdentityMap(nP=n_layer) + +# Compute and plot complex conductivity at all frequencies +frequencies = np.logspace(-3, 6, 91) +#sigma_complex = ColeCole(frequencies, sigma, eta, tau, c) +# +#fig = plt.figure() +#ax = fig.add_subplot(111) +#ax.semilogx(frequencies, sigma*np.ones(len(frequencies)), "b", lw=2) +#ax.semilogx(frequencies, np.real(sigma_complex), "r", lw=2) +#ax.semilogx(frequencies, np.imag(sigma_complex), "r--", lw=2) +#ax.set_xlim(np.min(frequencies), np.max(frequencies)) +#ax.set_ylim(0., 1.1*sigma) +#ax.set_xlabel("Frequency (Hz)") +#ax.set_ylabel("Conductivity") +#ax.legend( +# ["$\sigma_{DC}$", "$Re[\sigma (\omega)]$", "$Im[\sigma (\omega)]$"], +# loc="center right" +#) + +####################################################################### +# Define the Forward Simulation and Predict Data +# ---------------------------------------------- +# + + +# Simulate response for static conductivity +simulation = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=model_mapping, + chi=chi_model +) + +dpred = simulation.dpred(sigma_model) + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +fig = plt.figure(figsize = (6, 5)) +d = np.reshape(dpred, (len(source_list), len(times))).T +ax = fig.add_axes([0.1, 0.1, 0.8, 0.85]) +colorlist = ['k', 'b', 'r'] +for ii, k in enumerate(colorlist): + ax.loglog(times, np.abs(d[:, ii]), k, lw=2) + +ax.legend(["Step-off", "Triangular", "VTEM"]) +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dB/dt| (T/s)") + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_1_tdem_inv.py b/tutorials/plot_1_tdem_inv.py new file mode 100644 index 0000000..965879e --- /dev/null +++ b/tutorials/plot_1_tdem_inv.py @@ -0,0 +1,378 @@ +""" +Inversion of 1D Frequency-Domain Data +============================================== + + +""" + + +######################################################################### +# Import modules +# -------------- +# + +import os, shutil +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt + +from discretize import TensorMesh + +import simpegEM1D as em1d +from simpegEM1D.utils import get_vertical_discretization_time, plotLayer +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +plt.rcParams.update({'font.size': 16, 'lines.linewidth': 2, 'lines.markersize':8}) + +# sphinx_gallery_thumbnail_number = 3 + +############################################# +# Define File Names +# ----------------- +# +# File paths for assets we are loading. To set up the inversion, we require +# topography and field observations. The true model defined on the whole mesh +# is loaded to compare with the inversion result. +# + +data_filename = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dtm_data.obs' + + + +############################################# +# Load Data and Plot +# ------------------ +# +# Here we load and plot synthetic gravity anomaly data. Topography is generally +# defined as an (N, 3) array. Gravity data is generally defined with 4 columns: +# x, y, z and data. +# + +# Load field data +dobs = np.loadtxt(str(data_filename)) + +# Define receiver locations and observed data +times = dobs[:, 0] +dobs = mkvc(dobs[:, -1]) + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +ax.loglog(times, np.abs(dobs), 'k-o', lw=3) +ax.set_xlabel("Times (s)") +ax.set_ylabel("|B| (T)") +ax.set_title("Magnetic Flux as a Function of Time") + + + +############################################# +# Defining the Survey +# ------------------- + +source_location = np.array([0., 0., 20.]) +source_orientation = "z" # "x", "y" or "z" +source_current = 1. +source_radius = 6. + +receiver_location = np.array([0., 0., 20.]) +receiver_orientation = "z" # "x", "y" or "z" +field_type = "secondary" # "secondary", "total" or "ppm" + +times = np.logspace(-5, -2, 31) + +# Receiver list +receiver_list = [] +receiver_list.append( + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="b" + ) +) + +# Sources +source_list = [ + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=source_location, + I=source_current, a=source_radius + ) +] + +# source_list = [ +# em1d.sources.TimeDomainMagneticDipoleSource( +# receiver_list=receiver_list, location=source_location, orientation="z", +# I=source_current +# ) +# ] + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + +############################################# +# Assign Uncertainties +# -------------------- +# +# + +uncertainties = 0.05*np.abs(dobs)*np.ones(np.shape(dobs)) + + +############################################### +# Define Data +# -------------------- +# +# Here is where we define the data that are inverted. The data are defined by +# the survey, the observation values and the uncertainties. +# + +data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + +############################################################### +# Defining a 1D Layered Earth (1D Tensor Mesh) +# -------------------------------------------- +# +# Here, we define the layer thicknesses for our 1D simulation. To do this, we use +# the TensorMesh class. +# + +# Based on estimate of background conductivity, make layers + +#inv_thicknesses = get_vertical_discretization_frequency( +# times, sigma_background=0.1, +# factor_fmax=20, factor_fmin=1., n_layer=50, +#) + +inv_thicknesses = np.logspace(0,1.5,25) + +# Define a mesh for plotting and regularization. +mesh = TensorMesh([(np.r_[inv_thicknesses, inv_thicknesses[-1]])], '0') + + +######################################################## +# Define a Starting and Reference Model +# ------------------------------------- +# +# Here, we create starting and/or reference models for the inversion as +# well as the mapping from the model space to the active cells. Starting and +# reference models can be a constant background value or contain a-priori +# structures. Here, the starting model is log(0.001) S/m. +# +# Define log-conductivity values for each layer since our model is the +# log-conductivity. Don't make the values 0! +# Otherwise the gradient for the 1st iteration is zero and the inversion will +# not converge. + +# Define model. A resistivity (Ohm meters) or conductivity (S/m) for each layer. +starting_model = np.log(0.1*np.ones(mesh.nC)) + +# Define mapping from model to active cells. +model_mapping = maps.ExpMap() + + + + + + +####################################################################### +# Define the Physics +# ------------------ +# + +simulation = em1d.simulation.EM1DTMSimulation( + survey=survey, thicknesses=inv_thicknesses, sigmaMap=model_mapping +) + + +####################################################################### +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties + + + + +# Define the regularization (model objective function) +reg_map = maps.IdentityMap(nP=mesh.nC) +reg = regularization.Sparse( + mesh, mapping=reg_map, +# alpha_s=1, +) + +reg.mref = starting_model + +# Define sparse and blocky norms p, q +p = 0 +q = 0 +reg.norms = np.c_[p, q] + +#reg.eps_p = 1e-3 +#reg.eps_q = 1e-3 + +# Define how the optimization problem is solved. Here we will use an inexact +# Gauss-Newton approach that employs the conjugate gradient solver. +opt = optimization.ProjectedGNCG(maxIter=100, maxIterLS=20, maxIterCG=20, tolCG=1e-3) + +# Define the inverse problem +inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt) + + +####################################################################### +# Define Inversion Directives +# --------------------------- +# +# Here we define any directiveas that are carried out during the inversion. This +# includes the cooling schedule for the trade-off parameter (beta), stopping +# criteria for the inversion and saving inversion results at each iteration. +# + +# Apply and update sensitivity weighting as the model updates +#sensitivity_weights = directives.UpdateSensitivityWeights() + +# Reach target misfit for L2 solution, then use IRLS until model stops changing. +#IRLS = directives.Update_IRLS(max_irls_iterations=40, minGNiter=1, f_min_change=1e-5, chifact_start=2) +#IRLS = directives.Update_IRLS( +# max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, +# beta_tol=1e-2, f_min_change=1e-5, +# chifact_start = 1. +#) + +# Defining a starting value for the trade-off parameter (beta) between the data +# misfit and the regularization. +starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=1e1) + +# Update the preconditionner +update_Jacobi = directives.UpdatePreconditioner() + +# Options for outputting recovered models and predicted data for each beta. +save_iteration = directives.SaveOutputEveryIteration(save_txt=False) + +# The directives are defined as a list. +#directives_list = [ +# IRLS, +# starting_beta, +# save_iteration, +#] + + + + + +update_IRLS = directives.Update_IRLS( + max_irls_iterations=30, minGNiter=1, + coolEpsFact=1.5, update_beta=True +) + +# Updating the preconditionner if it is model dependent. +update_jacobi = directives.UpdatePreconditioner() + +# Setting a stopping criteria for the inversion. +#target_misfit = directives.TargetMisfit(chifact=1) + +# Add sensitivity weights +sensitivity_weights = directives.UpdateSensitivityWeights() + +# The directives are defined as a list. +directives_list = [ + sensitivity_weights, + starting_beta, + save_iteration, + update_IRLS, + update_jacobi, +] + +##################################################################### +# Running the Inversion +# --------------------- +# +# To define the inversion object, we need to define the inversion problem and +# the set of directives. We can then run the inversion. +# + +# Here we combine the inverse problem and the set of directives +inv = inversion.BaseInversion(inv_prob, directives_list) + +# Run the inversion +recovered_model = inv.run(starting_model) + + +##################################################################### +# Plotting Results +# --------------------- + + +# Load the true model and layer thicknesses +true_model = np.array([0.1, 1., 0.1]) +hz = np.r_[40., 40., 160.] +true_layers = TensorMesh([hz]) + +# Extract Least-Squares model +l2_model = inv_prob.l2model +print(np.shape(l2_model)) + +# Plot true model and recovered model +fig = plt.figure(figsize=(8, 9)) +x_min = np.min(np.r_[model_mapping * recovered_model, model_mapping * l2_model, true_model]) +x_max = np.max(np.r_[model_mapping * recovered_model, model_mapping * l2_model, true_model]) + +ax1 = fig.add_axes([0.2, 0.15, 0.7, 0.7]) +plotLayer(true_model, true_layers, ax=ax1, showlayers=False, color="k") +plotLayer(model_mapping * l2_model, mesh, ax=ax1, showlayers=False, color="b") +plotLayer(model_mapping * recovered_model, mesh, ax=ax1, showlayers=False, color="r") +ax1.set_xlim(0.01, 10) +ax1.legend(["True Model", "L2-Model", "Sparse Model"]) + +# Plot the true and apparent resistivities on a sounding curve +dpred_l2 = simulation.dpred(l2_model) +dpred_final = simulation.dpred(recovered_model) + +fig = plt.figure(figsize=(11, 6)) +ax1 = fig.add_axes([0.2, 0.1, 0.6, 0.8]) +ax1.loglog(times, np.abs(dobs), "k-o") +ax1.loglog(times, np.abs(dpred_l2), "b-o") +ax1.loglog(times, np.abs(dpred_final), "r-o") +ax1.set_xlabel("times (Hz)") +ax1.set_ylabel("|Hs/Hp| (ppm)") +ax1.legend([ + "Observed", "L2-Model", "Sparse"], loc="upper right" +) +plt.show() + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_fdem_fwd_stitched.py b/tutorials/plot_2_fdem_fwd_stitched.py new file mode 100644 index 0000000..6b287d6 --- /dev/null +++ b/tutorials/plot_2_fdem_fwd_stitched.py @@ -0,0 +1,321 @@ +""" +Forward Simulation of Stitched Frequency-Domain Data +==================================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG import maps +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer, get_vertical_discretization_frequency + +plt.rcParams.update({'font.size': 16}) +save_file = False + + +##################################################################### +# topography +# ------------- +# +# +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + + + + + +##################################################################### +# Create Survey +# ------------- +# +# +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +n_sounding = len(x) + +source_locations = np.c_[x, np.zeros(n_sounding), 30 *np.ones(n_sounding)] +source_current = 1. +source_radius = 5. +moment_amplitude=1. + +receiver_locations = np.c_[x+10., np.zeros(n_sounding), 30 *np.ones(n_sounding)] +receiver_orientation = "z" # "x", "y" or "z" +field_type = "ppm" # "secondary", "total" or "ppm" + +frequencies = np.array([25., 100., 382, 1822, 7970, 35920], dtype=float) + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [] + + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="both" + ) + ) + # receiver_list.append( + # em1d.receivers.HarmonicPointReceiver( + # receiver_location, frequencies, orientation=receiver_orientation, + # field_type=field_type, component="imag" + # ) + # ) + +# Sources +# source_list = [ +# em1d.sources.HarmonicHorizontalLoopSource( +# receiver_list=receiver_list, location=source_location, a=source_radius, +# I=source_current +# ) +# ] + + source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) + ) + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################### +# Defining a Global Mesh +# ---------------------- +# + +n_layer = 30 +thicknesses = get_vertical_discretization_frequency( + frequencies, sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + +############################################### +# Defining a Model +# ---------------------- +# + +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +model = np.ones(n_param) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +model[poly_inds] = slope_conductivity + +mapping = maps.ExpMap(nP=n_param) + +# MODEL TO SOUNDING MODELS METHOD 1 +# sounding_models = model.reshape(mesh2D.vnC, order='F') +# sounding_models = np.fliplr(sounding_models) +# sounding_models = mkvc(sounding_models.T) + +# MODEL TO SOUNDING MODELS METHOD 2 +sounding_models = model.reshape(mesh_soundings.vnC, order='C') +sounding_models = np.flipud(sounding_models) +sounding_models = mkvc(sounding_models) + +chi = np.zeros_like(sounding_models) + + + + + + +fig = plt.figure(figsize=(9, 3)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod = np.log10(model) + +mesh2D.plotImage( + log_mod, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh2D.vectorNy.min(), mesh2D.vectorNy.max()) + +ax1.set_title("Conductivity Model") +ax1.set_xlabel("x (m)") +ax1.set_ylabel("z (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +fig = plt.figure(figsize=(4, 8)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod_sounding = np.log10(sounding_models) +sounding_models = np.log(sounding_models) + +mesh_soundings.plotImage( + log_mod_sounding, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh_soundings.vectorNy.min(), mesh_soundings.vectorNy.max()) + +ax1.set_title("Ordered Sounding Models") +ax1.set_xlabel("hz (m)") +ax1.set_ylabel("Profile Distance (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + + +# Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, chi=chi, + topo=topo, parallel=False, verbose=True, Solver=PardisoSolver +) + +# simulation = em1d.simulation.StitchedEM1DFMSimulation( +# survey=survey, thicknesses=thicknesses, sigmaMap=mapping, chi=chi, +# topo=topo, parallel=True, n_cpu=2, verbose=True, Solver=PardisoSolver +# ) + + +dpred = simulation.dpred(sounding_models) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +d = np.reshape(dpred, (n_sounding, 2*len(frequencies))).T + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, n_sounding): + ax.loglog(frequencies, np.abs(d[0:len(frequencies), ii]), '-', lw=2) + ax.loglog(frequencies, np.abs(d[len(frequencies):, ii]), '--', lw=2) + +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["real", "imaginary"]) + +# +#d = np.reshape(dpred, (n_sounding, 2*len(frequencies))) +#fig = plt.figure(figsize = (10, 5)) +#ax1 = fig.add_subplot(121) +#ax2 = fig.add_subplot(122) +# +#for ii in range(0, n_sounding): +# ax1.semilogy(x, np.abs(d[:, 0:len(frequencies)]), 'k-', lw=2) +# ax2.semilogy(x, np.abs(d[:, len(frequencies):]), 'k--', lw=2) + + + +if save_file == True: + + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_stitched_data.obs' + + loc = np.repeat(source_locations, len(frequencies), axis=0) + fvec = np.kron(np.ones(n_sounding), frequencies) + dout = np.c_[dpred[0::2], dpred[1::2]] + + np.savetxt( + fname, + np.c_[loc, fvec, dout], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_fdem_fwd_stitched_height.py b/tutorials/plot_2_fdem_fwd_stitched_height.py new file mode 100644 index 0000000..e59f832 --- /dev/null +++ b/tutorials/plot_2_fdem_fwd_stitched_height.py @@ -0,0 +1,314 @@ +""" +Forward Simulation of Stitched Frequency-Domain Data with Height +================================================================ + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG import maps +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer, get_vertical_discretization_frequency + +plt.rcParams.update({'font.size': 16}) +save_file = True + + +##################################################################### +# topography +# ------------- +# +# +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + + + + + +##################################################################### +# Create Survey +# ------------- +# +# +x = np.linspace(50,5050,50) +#x = np.linspace(50,250,3) +n_sounding = len(x) + +source_heights = 30.*np.ones(n_sounding) +source_locations = np.c_[x, np.zeros(n_sounding), 30 *np.ones(n_sounding)] +source_current = 1. +source_radius = 5. +moment_amplitude = 1. + +source_receiver_offsets = np.c_[10.*np.ones(n_sounding), np.zeros(n_sounding), np.zeros(n_sounding)] +receiver_orientation = "z" # "x", "y" or "z" +field_type = "ppm" # "secondary", "total" or "ppm" + +frequencies = np.array([25., 100., 382, 1822, 7970, 35920], dtype=float) + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(source_receiver_offsets[ii, :]) + + receiver_list = [] + + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="both", use_source_receiver_offset=True + ) + ) + # receiver_list.append( + # em1d.receivers.HarmonicPointReceiver( + # receiver_location, frequencies, orientation=receiver_orientation, + # field_type=field_type, component="imag", use_source_receiver_offset=True + # ) + # ) + + source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) + ) + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + +############################################### +# Defining a Global Mesh +# ---------------------- +# + +n_layer = 30 +thicknesses = get_vertical_discretization_frequency( + frequencies, sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + +############################################### +# Defining a Model +# ---------------------- +# + +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +model = np.ones(n_param) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +model[poly_inds] = slope_conductivity + +mapping = maps.ExpMap(nP=n_param) + +# MODEL TO SOUNDING MODELS METHOD 1 +# sounding_models = model.reshape(mesh2D.vnC, order='F') +# sounding_models = np.fliplr(sounding_models) +# sounding_models = mkvc(sounding_models.T) + +# MODEL TO SOUNDING MODELS METHOD 2 +sounding_models = model.reshape(mesh_soundings.vnC, order='C') +sounding_models = np.flipud(sounding_models) +sounding_models = mkvc(sounding_models) + +chi = np.zeros_like(sounding_models) + + + + + + +fig = plt.figure(figsize=(9, 3)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod = np.log10(model) + +mesh2D.plotImage( + log_mod, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh2D.vectorNy.min(), mesh2D.vectorNy.max()) + +ax1.set_title("Conductivity Model") +ax1.set_xlabel("x (m)") +ax1.set_ylabel("z (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +fig = plt.figure(figsize=(4, 8)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod_sounding = np.log10(sounding_models) +sounding_models = np.log(sounding_models) + +mesh_soundings.plotImage( + log_mod_sounding, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh_soundings.vectorNy.min(), mesh_soundings.vectorNy.max()) + +ax1.set_title("Ordered Sounding Models") +ax1.set_xlabel("hz (m)") +ax1.set_ylabel("Profile Distance (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + +wires = maps.Wires(('sigma', n_param),('h', n_sounding)) +sigma_map = maps.ExpMap(nP=n_param) * wires.sigma +h_map = wires.h + +model = np.r_[sounding_models, source_heights] + + +####################################################################### +# Define the Forward Simulation and Predict Data +# ---------------------------------------------- +# + + + +# Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=sigma_map, hMap=h_map, topo=topo, + parallel=False, n_cpu=2, verbose=True, Solver=PardisoSolver +) + +dpred = simulation.dpred(model) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +d = np.reshape(dpred, (n_sounding, 2*len(frequencies))).T + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, n_sounding): + ax.loglog(frequencies, np.abs(d[0:len(frequencies), ii]), '-', lw=2) + ax.loglog(frequencies, np.abs(d[len(frequencies):, ii]), '--', lw=2) + +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["real", "imaginary"]) + +# +#d = np.reshape(dpred, (n_sounding, 2*len(frequencies))) +#fig = plt.figure(figsize = (10, 5)) +#ax1 = fig.add_subplot(121) +#ax2 = fig.add_subplot(122) +# +#for ii in range(0, n_sounding): +# ax1.semilogy(x, np.abs(d[:, 0:len(frequencies)]), 'k-', lw=2) +# ax2.semilogy(x, np.abs(d[:, len(frequencies):]), 'k--', lw=2) + + + +if save_file == True: + + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_stitched_data.obs' + + loc = np.repeat(source_locations, len(frequencies), axis=0) + fvec = np.kron(np.ones(n_sounding), frequencies) + dout = np.c_[dpred[0::2], dpred[1::2]] + + np.savetxt( + fname, + np.c_[loc, fvec, dout], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_fdem_inv_stitched.py b/tutorials/plot_2_fdem_inv_stitched.py new file mode 100644 index 0000000..a852b4b --- /dev/null +++ b/tutorials/plot_2_fdem_inv_stitched.py @@ -0,0 +1,481 @@ +""" +Forward Simulation of Stitched Frequency-Domain Data +==================================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D import get_2d_mesh, LateralConstraint +from simpegEM1D.utils import plotLayer, get_vertical_discretization_frequency + +save_file = True + +plt.rcParams.update({'font.size': 16, 'lines.linewidth': 2, 'lines.markersize':8}) + + +############################################# +# Define File Names +# ----------------- +# +# File paths for assets we are loading. To set up the inversion, we require +# topography and field observations. The true model defined on the whole mesh +# is loaded to compare with the inversion result. +# + +data_filename = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dfm_stitched_data.obs' + + + +##################################################################### +# topography +# ------------- +# +# + +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + + + + + +############################################# +# Load Data and Plot +# ------------------ +# + +# Load field data +dobs = np.loadtxt(str(data_filename)) + + +source_locations = np.unique(dobs[:, 0:3], axis=0) +frequencies = np.unique(dobs[:, 3]) +dobs = mkvc(dobs[:, 4:].T) + +n_sounding = np.shape(source_locations)[0] + +dobs_plotting = np.reshape(dobs, (n_sounding, 2*len(frequencies))).T + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, n_sounding): + ax.loglog(frequencies, np.abs(dobs_plotting[0:len(frequencies), ii]), '-', lw=2) + ax.loglog(frequencies, np.abs(dobs_plotting[len(frequencies):, ii]), '--', lw=2) + +ax.set_xlabel("Frequency (Hz)") +ax.set_ylabel("|Hs/Hp| (ppm)") +ax.set_title("Magnetic Field as a Function of Frequency") +ax.legend(["real", "imaginary"]) + + + +###################################################### +# Create Survey +# ------------- +# + + +moment_amplitude = 1. + +receiver_locations = np.c_[source_locations[:, 0]+10., source_locations[:, 1:]] +receiver_orientation = "z" # "x", "y" or "z" +field_type = "ppm" # "secondary", "total" or "ppm" + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [] + + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="real" + ) + ) + receiver_list.append( + em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, orientation=receiver_orientation, + field_type=field_type, component="imag" + ) + ) + +# Sources +# source_list = [ +# em1d.sources.HarmonicHorizontalLoopSource( +# receiver_list=receiver_list, location=source_location, a=source_radius, +# I=source_current +# ) +# ] + + source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) + ) + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + + + +############################################# +# Assign Uncertainties +# -------------------- +# +# + +uncertainties = 0.1*np.abs(dobs)*np.ones(np.shape(dobs)) + + +############################################### +# Define Data +# -------------------- +# +# Here is where we define the data that are inverted. The data are defined by +# the survey, the observation values and the uncertainties. +# + +data_object = data.Data(survey, dobs=dobs, standard_deviation=uncertainties) + + + +############################################### +# Defining Meshes +# --------------- +# + +n_layer = 30 +thicknesses = get_vertical_discretization_frequency( + frequencies, sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + + + +############################################### +# Defining a Model +# ---------------------- +# + +conductivity = np.ones(n_param) * 0.1 + +mapping = maps.ExpMap(nP=n_param) +starting_model = np.log(conductivity) + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + + +# Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, topo=topo, + verbose=True, Solver=PardisoSolver +) + +# simulation = em1d.simulation.StitchedEM1DFMSimulation( +# survey=survey, thicknesses=thicknesses, sigmaMap=mapping, topo=topo, +# parallel=True, n_cpu=3, verbose=True, Solver=PardisoSolver +# ) + + +######################################################################## +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties + + +# Define the regularization (model objective function) +mesh_reg = get_2d_mesh(n_sounding, hz) +reg_map = maps.IdentityMap(nP=n_param) +reg = LateralConstraint( + mesh_reg, mapping=reg_map, + alpha_s = 0.1, + alpha_x = 1., + alpha_y = 1., +) +xy = utils.ndgrid(x, np.r_[0.]) +reg.get_grad_horizontal(xy, hz, dim=2, use_cell_weights=True) + + +# reg_map = maps.IdentityMap(nP=n_param) +# reg = regularization.Sparse( +# mesh_reg, mapping=reg_map, +# ) + +ps, px, py = 1, 1, 1 +reg.norms = np.c_[ps, px, py, 0] + +reg.mref = starting_model +reg.mrefInSmooth = False + +# reg.eps_p = 1e-6 +# reg.eps_q = 1e-6 + + +# Define how the optimization problem is solved. Here we will use an inexact +# Gauss-Newton approach that employs the conjugate gradient solver. +opt = optimization.InexactGaussNewton(maxIter = 40, maxIterCG=20) + +# Define the inverse problem +inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt) + + + + +####################################################################### +# Define Inversion Directives +# --------------------------- +# +# Here we define any directiveas that are carried out during the inversion. This +# includes the cooling schedule for the trade-off parameter (beta), stopping +# criteria for the inversion and saving inversion results at each iteration. +# + +# Apply and update sensitivity weighting as the model updates +#sensitivity_weights = directives.UpdateSensitivityWeights() + +# Reach target misfit for L2 solution, then use IRLS until model stops changing. +#IRLS = directives.Update_IRLS(max_irls_iterations=40, minGNiter=1, f_min_change=1e-5, chifact_start=2) +#IRLS = directives.Update_IRLS( +# max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, +# beta_tol=1e-2, f_min_change=1e-5, +# chifact_start = 1. +#) + +# Defining a starting value for the trade-off parameter (beta) between the data +# misfit and the regularization. +starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=10) + + +beta_schedule = directives.BetaSchedule(coolingFactor=2, coolingRate=2) + +# Update the preconditionner +update_Jacobi = directives.UpdatePreconditioner() + +# Options for outputting recovered models and predicted data for each beta. +save_iteration = directives.SaveOutputEveryIteration(save_txt=False) + + +update_IRLS = directives.Update_IRLS( + max_irls_iterations=20, minGNiter=1, + fix_Jmatrix=True, + f_min_change = 1e-3, + coolingRate=3 +) + + + +# Updating the preconditionner if it is model dependent. +update_jacobi = directives.UpdatePreconditioner() + +# Setting a stopping criteria for the inversion. +target_misfit = directives.TargetMisfit(chifact=1) + +# Add sensitivity weights +sensitivity_weights = directives.UpdateSensitivityWeights() + +target = directives.TargetMisfit() + +# The directives are defined as a list. +directives_list = [ + starting_beta, + beta_schedule, + save_iteration, + update_IRLS, +] + + +# opt.LSshorten = 0.5 +# opt.remember('xc') + +##################################################################### +# Running the Inversion +# --------------------- +# +# To define the inversion object, we need to define the inversion problem and +# the set of directives. We can then run the inversion. +# + +# Here we combine the inverse problem and the set of directives +inv = inversion.BaseInversion(inv_prob, directives_list) + +# Run the inversion +recovered_model = inv.run(starting_model) + + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +# True model +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +true_model = np.ones(n_param) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +true_model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +true_model[poly_inds] = slope_conductivity + + +l2_model = inv_prob.l2model +dpred_l2 = simulation.dpred(l2_model) +l2_model = np.exp(l2_model) + +dpred = simulation.dpred(recovered_model) +recovered_model = np.exp(recovered_model) + +mesh_plotting = TensorMesh([hx, np.flipud(hz)], x0='0N') +l2_model = l2_model.reshape(mesh_plotting.vnC, order='C') +l2_model = mkvc(np.fliplr(l2_model)) +recovered_model = recovered_model.reshape(mesh_plotting.vnC, order='C') +recovered_model = mkvc(np.fliplr(recovered_model)) + + +models_list = [true_model, l2_model, recovered_model] + + +for ii, mod in enumerate(models_list): + + fig = plt.figure(figsize=(9, 3)) + ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) + log_mod = np.log10(mod) + + mesh_plotting.plotImage( + log_mod, ax=ax1, grid=False, + clim=(np.log10(true_model.min()), np.log10(true_model.max())), +# clim=(np.log10(0.1), np.log10(1)), + pcolorOpts={"cmap": "viridis"}, + ) + ax1.set_ylim(mesh_plotting.vectorNy.min(), mesh_plotting.vectorNy.max()) + + ax1.set_title("Conductivity Model") + ax1.set_xlabel("x (m)") + ax1.set_ylabel("depth (m)") + + ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) + norm = mpl.colors.Normalize( + vmin=np.log10(true_model.min()), vmax=np.log10(true_model.max()) +# vmin=np.log10(0.1), vmax=np.log10(1) + ) + cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" + ) + cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +data_list = [dobs, dpred_l2, dpred] +color_list = ['k', 'b', 'r'] + +fig = plt.figure(figsize = (12, 6)) +ax1 = fig.add_axes([0.05, 0.1, 0.4, 0.8]) +ax2 = fig.add_axes([0.55, 0.1, 0.4, 0.8]) + +for ii in range(0, len(data_list)): + d1 = np.reshape(data_list[ii][0::2], (n_sounding, len(frequencies))) + d2 = np.reshape(data_list[ii][1::2], (n_sounding, len(frequencies))) + ax1.semilogy(x, np.abs(d1), color_list[ii], lw=1) + ax2.semilogy(x, np.abs(d2), color_list[ii], lw=1) + +ax.set_xlabel("Frequencies (s)") +ax.set_ylabel("Re[H] (A/m)") + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_fdem_inv_stitched_bookpurnong.py b/tutorials/plot_2_fdem_inv_stitched_bookpurnong.py new file mode 100644 index 0000000..0d8023a --- /dev/null +++ b/tutorials/plot_2_fdem_inv_stitched_bookpurnong.py @@ -0,0 +1,277 @@ + +""" +Inversion of RESOLVE data acquired at Bookpurnong, Austrailia +============================================================= + +XXX + +""" + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +import SimPEG +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D import get_2d_mesh, LateralConstraint +from simpegEM1D.utils import plotLayer, get_vertical_discretization_frequency + +##################################################################### +# Load data +# ------------- +# +# + +import h5py +import tarfile +import os +import shutil +def download_and_unzip_data( + url = "https://storage.googleapis.com/simpeg/bookpurnong/bookpurnong_inversion.tar.gz" +): + """ + Download the data from the storage bucket, unzip the tar file, return + the directory where the data are + """ + # download the data + downloads = utils.download(url) + + # directory where the downloaded files are + directory = downloads.split(".")[0] + + # unzip the tarfile + tar = tarfile.open(downloads, "r") + tar.extractall() + tar.close() + + return downloads, directory + + + +# download the data +downloads, directory = download_and_unzip_data() + +# Load resolve data +resolve = h5py.File( + os.path.sep.join([directory, "booky_resolve.hdf5"]), "r" +) +river_path = resolve["river_path"] # River path +nskip = 1 +nSounding = resolve["data"][::nskip, :].shape[0] # the # of soundings + +# Bird height from surface +b_height_resolve = (resolve["src_elevation"])[::nskip] + +# fetch the frequencies we are considering +cpi_inds = [0, 2, 6, 8, 10] # Indices for HCP in-phase +cpq_inds = [1, 3, 7, 9, 11] # Indices for HCP quadrature +frequency_cp = resolve["frequency_cp"] +xy = (resolve["xy"])[::nskip, :] +line = resolve['line'][::nskip] + + +data_cpi = resolve["data"][::nskip, cpi_inds].astype(float) +data_cpq = resolve["data"][::nskip, cpq_inds].astype(float) + + +##################################################################### +# Create Survey +# ------------- +# +# + +from scipy.constants import mu_0 +frequencies = np.array([382, 1822, 7970, 35920, 130100], dtype=float) +n_frequency = frequencies.size +# thicknesses = get_vertical_discretization_frequency(frequencies, sigma_background=1./50) +thicknesses = 1 * 1.1**np.arange(19) +n_layer = thicknesses.size + 1 +# survey parameters +rxOffset = 7.86 # tx-rx separation +n_sounding = xy.shape[0] +b_height_resolve = resolve["src_elevation"][::nskip] +topo_resolve = resolve["ground_elevation"][::nskip] +uniq_line = np.unique(line) +x = xy[:,0] +y = xy[:,1] +z = topo_resolve + b_height_resolve +receiver_locations = np.c_[x+rxOffset, y, z] +source_locations = np.c_[x, y, z] +topo = np.c_[x, y, topo_resolve].astype(float) + + +receiver_orientation = 'z' +field_type = 'ppm' +source_list = [] +moment_amplitude = 1. +for ii in range(0, n_sounding): + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + rx = em1d.receivers.HarmonicPointReceiver( + receiver_location, frequencies, + orientation=receiver_orientation, + field_type=field_type, + component="both" + ) + receiver_list = [rx] + source_list.append( + em1d.sources.HarmonicMagneticDipoleSource( + receiver_list=receiver_list, location=source_location, orientation="z", + moment_amplitude=moment_amplitude + ) + ) + + +# Survey +survey = em1d.survey.EM1DSurveyFD(source_list) + +####################################################################### +# Define the Forward Simulation +# ---------------------------------------------- + +mapping = maps.ExpMap(nP=int(n_sounding*n_layer)) + +simulation = em1d.simulation.StitchedEM1DFMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, topo=topo, + verbose=True, Solver=PardisoSolver, parallel=False +) + + +m0 = np.ones(mapping.nP) * np.log(1./50) + +DOBS = np.empty((simulation.n_sounding, 2, n_frequency)) +for i_freq in range(frequency_cp.size): + DOBS[:,0,i_freq] = data_cpi[:, i_freq] + DOBS[:,1,i_freq] = data_cpq[:, i_freq] + + +i_line = 3 +ind_line = line == uniq_line[i_line] +fig = plt.figure(figsize=(7, 7)) +ax = plt.subplot(111) +out = utils.plot2Ddata(xy, DOBS[:,0,0], scale='linear', contourOpts={'cmap':'jet', 'alpha':1}, ncontour=40, ax=ax) +# ax.plot(xy[:,0], xy[:,1], 'k.', ms=1) +ax.plot(river_path[:,0], river_path[:,1], 'k-') +cb = plt.colorbar(out[0], format="%.1e", ax=ax, fraction=0.05) +cb.set_label("Bz (ppm)") +ax.plot(xy[ind_line,0], xy[ind_line,1], 'k.', ms=3) + + +i_line = 4 +ind_line = line == uniq_line[i_line] +fig = plt.figure(figsize=(10, 5)) +for i_freq in range(n_frequency): + plt.semilogy(xy[ind_line,0], DOBS[ind_line,0,i_freq], 'k') +for i_freq in range(n_frequency): + plt.semilogy(xy[ind_line,0], DOBS[ind_line,1,i_freq], 'r') + + +######################################################################## +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. + +dobs = DOBS.flatten() +std = 0.1 +floor = 20. +uncertainties = std*abs(dobs)+floor +data_object = data.Data(survey, dobs=dobs, standard_deviation=uncertainties) + +from simpegEM1D import get_2d_mesh, LateralConstraint +hz = np.r_[thicknesses, thicknesses[-1]] +mesh_reg = get_2d_mesh(n_sounding, hz) +# Now we can create the regularization using the 2D mesh +reg = LateralConstraint(mesh_reg, mapping=maps.IdentityMap(nP=mesh_reg.nC)) + + +tri = reg.get_grad_horizontal(xy, hz) +fig = plt.figure(figsize=(10, 10)) +plt.triplot(xy[:,0], xy[:,1], tri.simplices) +plt.plot(xy[:,0], xy[:,1], '.') +# plt.show() + +m0 = np.ones(mesh_reg.nC) * np.log(1./100.) +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties +regmap = maps.IdentityMap(mesh_reg) + +reg = LateralConstraint( + mesh_reg, mapping=maps.IdentityMap(nP=mesh_reg.nC), + alpha_s = 1e-3, + alpha_x = 1., + alpha_y = 1., +) +tri = reg.get_grad_horizontal(xy, hz) +opt = optimization.InexactGaussNewton(maxIter = 10) +invProb = inverse_problem.BaseInvProblem(dmis, reg, opt) +beta = directives.BetaSchedule(coolingFactor=2, coolingRate=1) +betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.) +target = directives.TargetMisfit() +inv = inversion.BaseInversion(invProb, directiveList=[beta,betaest,target]) +simulation.counter = opt.counter = utils.Counter() +opt.LSshorten = 0.5 +opt.remember('xc') +mopt = inv.run(m0) + +sigma = mapping * mopt + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +PRED = invProb.dpred.reshape((simulation.n_sounding, 2, n_frequency)) + +i_line = 14 +ind_line = line == uniq_line[i_line] +fig = plt.figure(figsize=(10, 5)) +for i_freq in range(n_frequency): + plt.semilogy(xy[ind_line,0], DOBS[ind_line,0,i_freq], 'k') + plt.semilogy(xy[ind_line,0], PRED[ind_line,0,i_freq], 'k.') +for i_freq in range(n_frequency): + plt.semilogy(xy[ind_line,0], DOBS[ind_line,1,i_freq], 'b') + plt.semilogy(xy[ind_line,0], PRED[ind_line,1,i_freq], 'r.') +plt.ylabel("Hz (ppm)") + + +from simpegEM1D import ModelIO +IO = ModelIO( + hz = hz, + topography=topo, + line=line, + physical_property=1./sigma +) + +i_line = 23 +IO.plot_section( + plot_type='pcolor', aspect=10, i_line=i_line, clim=(0.3, 50) , + scale='log', cmap='Spectral', dx=50 +) + + + + diff --git a/tutorials/plot_2_tdem_fwd_stitched.py b/tutorials/plot_2_tdem_fwd_stitched.py new file mode 100644 index 0000000..f2ec5b9 --- /dev/null +++ b/tutorials/plot_2_tdem_fwd_stitched.py @@ -0,0 +1,306 @@ +""" +Forward Simulation of Stitched Time-Domain Data +=============================================== + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG import maps +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer, get_vertical_discretization_time + +plt.rcParams.update({'font.size': 16}) +save_file = False + + +##################################################################### +# topography +# ------------- +# +# + +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + + + + + +##################################################################### +# Create Survey +# ------------- +# +# +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +n_sounding = len(x) + +source_locations = np.c_[x, np.zeros(n_sounding), 20.*np.ones(n_sounding)] +source_current = 1. +source_radius = 5. + +receiver_locations = np.c_[x, np.zeros(n_sounding), 20.*np.ones(n_sounding)] +receiver_orientation = "z" # "x", "y" or "z" + +times = np.logspace(-5, -2, 16) + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="dbdt" + ) + ] + +# Sources + source_list.append( + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=source_location, a=source_radius, + I=source_current + ) + ) + + # source_list.append( + # em1d.sources.TimeDomainMagneticDipoleSource( + # receiver_list=receiver_list, location=source_location, orientation="z", + # I=source_current + # ) + # ) + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + +############################################### +# Defining a Global Mesh +# ---------------------- +# + + +n_layer = 25 +thicknesses = get_vertical_discretization_time( + times, sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + + + +############################################### +# Defining a Model +# ---------------------- +# + +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh2D.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +model = np.ones(n_param) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +model[poly_inds] = slope_conductivity + +mapping = maps.ExpMap(nP=n_param) + +# MODEL TO SOUNDING MODELS METHOD 1 +# sounding_models = model.reshape(mesh2D.vnC, order='F') +# sounding_models = np.fliplr(sounding_models) +# sounding_models = mkvc(sounding_models.T) + +# MODEL TO SOUNDING MODELS METHOD 2 +sounding_models = model.reshape(mesh_soundings.vnC, order='C') +sounding_models = np.flipud(sounding_models) +sounding_models = mkvc(sounding_models) + +# FROM SOUNDING MODEL TO REGULAR +# temp_model = sounding_models.reshape(mesh2D.vnC, order='C') +# temp_model = np.fliplr(temp_model) +# temp_model = mkvc(temp_model) + +chi = np.zeros_like(sounding_models) + + + +fig = plt.figure(figsize=(9, 3)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod = np.log10(model) +# log_mod = np.log10(temp_model) + +mesh2D.plotImage( + log_mod, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh2D.vectorNy.min(), mesh2D.vectorNy.max()) + +ax1.set_title("Conductivity Model") +ax1.set_xlabel("x (m)") +ax1.set_ylabel("z (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +fig = plt.figure(figsize=(4, 8)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod_sounding = np.log10(sounding_models) +sounding_models = np.log(sounding_models) + +mesh_soundings.plotImage( + log_mod_sounding, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh_soundings.vectorNy.min(), mesh_soundings.vectorNy.max()) + +ax1.set_title("Ordered Sounding Models") +ax1.set_xlabel("hz (m)") +ax1.set_ylabel("Profile Distance (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + + +# Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, chi=chi, + topo=topo, parallel=False, n_cpu=2, verbose=True, Solver=PardisoSolver +) + +#simulation.model = sounding_models +# +#ARGS = simulation.input_args(0) +#print("Number of arguments") +#print(len(ARGS)) +#print("Print arguments") +#for ii in range(0, len(ARGS)): +# print(ARGS[ii]) + +dpred = simulation.dpred(sounding_models) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +d = np.reshape(dpred, (n_sounding, len(times))) + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, len(times)): + ax.semilogy(x, np.abs(d[:, ii]), '-', lw=2) + +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dBdt| (T/s)") + + + + + + +if save_file == True: + + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dtm_stitched_data.obs' + + loc = np.repeat(source_locations, len(times), axis=0) + fvec = np.kron(np.ones(n_sounding), times) + + np.savetxt( + fname, + np.c_[loc, fvec, dpred], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_tdem_fwd_stitched_skytem.py b/tutorials/plot_2_tdem_fwd_stitched_skytem.py new file mode 100644 index 0000000..07b78a6 --- /dev/null +++ b/tutorials/plot_2_tdem_fwd_stitched_skytem.py @@ -0,0 +1,330 @@ +""" +Forward Simulation of Stitched SkyTEM Data +========================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG import maps +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D.utils import plotLayer, get_vertical_discretization_time +from simpegEM1D import skytem_HM_2015, skytem_LM_2015 + +plt.rcParams.update({'font.size': 16}) +save_file = True + + +##################################################################### +# topography +# ------------- +# +# + +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + + + + + +##################################################################### +# Create Survey +# ------------- +# +# + +wave_HM = skytem_HM_2015() +wave_LM = skytem_LM_2015() +time_HM = wave_HM.time_gate_center[0::2] +time_LM = wave_LM.time_gate_center[0::2] + +time_input_currents_HM = wave_HM.current_times[-7:] +input_currents_HM = wave_HM.currents[-7:] +time_input_currents_LM = wave_LM.current_times[-13:] +input_currents_LM = wave_LM.currents[-13:] + + +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +n_sounding = len(x) + +source_locations = np.c_[x, np.zeros(n_sounding), 30.*np.ones(n_sounding)] +source_current = 1. +source_orientation = 'z' +receiver_offset_r = 13.25 +receiver_offset_z = 2. + +receiver_locations = np.c_[x+receiver_offset_r, np.zeros(n_sounding), 30.*np.ones(n_sounding)+receiver_offset_z] +receiver_orientation = "z" # "x", "y" or "z" + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, + times=time_HM, + times_dual_moment=time_LM, + orientation=receiver_orientation, + component="dbdt" + ) + ] + +# Sources + source_list.append( + em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, + location=source_location, + moment_amplitude=source_current, + orientation=source_orientation, + wave_type="general", + moment_type='dual', + time_input_currents=time_input_currents_HM, + input_currents=input_currents_HM, + n_pulse = 1, + base_frequency = 25., + time_input_currents_dual_moment = time_input_currents_LM, + input_currents_dual_moment = input_currents_LM, + base_frequency_dual_moment = 210 + ) + ) + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + +############################################### +# Defining a Global Mesh +# ---------------------- +# + + +n_layer = 25 +thicknesses = get_vertical_discretization_time( + np.r_[time_HM, time_LM], sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + + + +############################################### +# Defining a Model +# ---------------------- +# + +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh2D.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +model = np.ones(n_param) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +model[poly_inds] = slope_conductivity + +mapping = maps.ExpMap(nP=n_param) + +# MODEL TO SOUNDING MODELS METHOD 1 +# sounding_models = model.reshape(mesh2D.vnC, order='F') +# sounding_models = np.fliplr(sounding_models) +# sounding_models = mkvc(sounding_models.T) + +# MODEL TO SOUNDING MODELS METHOD 2 +sounding_models = model.reshape(mesh_soundings.vnC, order='C') +sounding_models = np.flipud(sounding_models) +sounding_models = mkvc(sounding_models) + +# FROM SOUNDING MODEL TO REGULAR +# temp_model = sounding_models.reshape(mesh2D.vnC, order='C') +# temp_model = np.fliplr(temp_model) +# temp_model = mkvc(temp_model) + +chi = np.zeros_like(sounding_models) + + + +fig = plt.figure(figsize=(9, 3)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod = np.log10(model) +# log_mod = np.log10(temp_model) + +mesh2D.plotImage( + log_mod, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh2D.vectorNy.min(), mesh2D.vectorNy.max()) + +ax1.set_title("Conductivity Model") +ax1.set_xlabel("x (m)") +ax1.set_ylabel("z (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +fig = plt.figure(figsize=(4, 8)) +ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) +log_mod_sounding = np.log10(sounding_models) +sounding_models = np.log(sounding_models) + +mesh_soundings.plotImage( + log_mod_sounding, ax=ax1, grid=True, + clim=(np.log10(overburden_conductivity), np.log10(slope_conductivity)), + pcolorOpts={"cmap": "viridis"}, +) +ax1.set_ylim(mesh_soundings.vectorNy.min(), mesh_soundings.vectorNy.max()) + +ax1.set_title("Ordered Sounding Models") +ax1.set_xlabel("hz (m)") +ax1.set_ylabel("Profile Distance (m)") + +ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) +norm = mpl.colors.Normalize( + vmin=np.log10(overburden_conductivity), vmax=np.log10(slope_conductivity) +) +cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" +) +cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + + +# Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, chi=chi, + topo=topo, parallel=False, n_cpu=2, verbose=True, Solver=PardisoSolver +) + +#simulation.model = sounding_models +# +#ARGS = simulation.input_args(0) +#print("Number of arguments") +#print(len(ARGS)) +#print("Print arguments") +#for ii in range(0, len(ARGS)): +# print(ARGS[ii]) + +dpred = simulation.dpred(sounding_models) + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + +n_time = np.r_[time_LM, time_HM].size +d = np.reshape(dpred, (n_sounding, n_time)) + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, n_time): + ax.semilogy(x, np.abs(d[:, ii]), '-', lw=2) + +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dBdt| (T/s)") +plt.show() + + + + + +if save_file == True: + + noise = 0.1*np.abs(dpred)*np.random.rand(len(dpred)) + dpred += noise + fname = os.path.dirname(em1d.__file__) + '/../tutorials/assets/em1dtm_stitched_data_skytem.obs' + + loc = np.repeat(source_locations, n_time, axis=0) + fvec = np.kron(np.ones(n_sounding), np.r_[time_HM, time_LM]) + + np.savetxt( + fname, + np.c_[loc, fvec, dpred], + fmt='%.4e' + ) + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_tdem_inv_stitched.py b/tutorials/plot_2_tdem_inv_stitched.py new file mode 100644 index 0000000..35148db --- /dev/null +++ b/tutorials/plot_2_tdem_inv_stitched.py @@ -0,0 +1,477 @@ +""" +Forward Simulation of Stitched Time-Domain Data +=============================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D import get_2d_mesh, LateralConstraint +from simpegEM1D.utils import plotLayer, get_vertical_discretization_time + +save_file = True + +plt.rcParams.update({'font.size': 16, 'lines.linewidth': 2, 'lines.markersize':8}) + + +############################################# +# Define File Names +# ----------------- +# +# File paths for assets we are loading. To set up the inversion, we require +# topography and field observations. The true model defined on the whole mesh +# is loaded to compare with the inversion result. +# + +data_filename = os.path.dirname(em1d.__file__) + '\\..\\tutorials\\assets\\em1dtm_stitched_data.obs' + + + +##################################################################### +# topography +# ------------- +# +# + +x = np.linspace(50,4950,50) +#x = np.linspace(50,250,3) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + + + + + +############################################# +# Load Data and Plot +# ------------------ +# + +# Load field data +dobs = np.loadtxt(str(data_filename)) + + +source_locations = np.unique(dobs[:, 0:3], axis=0) +times = mkvc(np.unique(dobs[:, 3])) +dobs = mkvc(dobs[:, -1]) + +n_sounding = np.shape(source_locations)[0] + +dobs_plotting = np.reshape(dobs, (n_sounding, len(times))) + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, len(times)): + ax.semilogy(x, np.abs(dobs_plotting[:, ii]), '-', lw=2) + +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dBdt| (T/s)") + + + +###################################################### +# Create Survey +# ------------- +# + + +source_current = 1. +source_radius = 5. + +receiver_locations = np.c_[source_locations[:, 0], source_locations[:, 1:]] +receiver_orientation = "z" # "x", "y" or "z" + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + + receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, times, orientation=receiver_orientation, + component="dbdt" + ) + ] + + # Sources + source_list.append( + em1d.sources.TimeDomainHorizontalLoopSource( + receiver_list=receiver_list, location=source_location, a=source_radius, + I=source_current + ) + ) + + # source_list.append( + # em1d.sources.TimeDomainMagneticDipoleSource( + # receiver_list=receiver_list, location=source_location, orientation="z", + # I=source_current + # ) + # ) + + + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + + +############################################# +# Assign Uncertainties +# -------------------- +# +# + +uncertainties = 0.1*np.abs(dobs)*np.ones(np.shape(dobs)) + + +############################################### +# Define Data +# -------------------- +# +# Here is where we define the data that are inverted. The data are defined by +# the survey, the observation values and the uncertainties. +# + +data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + + +############################################### +# Defining a Global Mesh +# ---------------------- +# + +n_layer = 25 +thicknesses = get_vertical_discretization_time( + times, sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + + +############################################### +# Defining a Model +# ---------------------- +# + +conductivity = np.ones(n_param) * 0.1 + +mapping = maps.ExpMap(nP=n_param) +starting_model = np.log(conductivity) + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + + +# Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, + topo=topo, verbose=True, Solver=PardisoSolver +) + +# simulation = em1d.simulation.StitchedEM1DTMSimulation( +# survey=survey, thicknesses=thicknesses, sigmaMap=mapping, +# topo=topo, parallel=True, n_cpu=4, verbose=True, Solver=PardisoSolver +# ) + + + + + + + + +######################################################################## +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties + + +# Define the regularization (model objective function) +mesh_reg = get_2d_mesh(n_sounding, hz) +reg_map = maps.IdentityMap(mesh_reg) +reg = LateralConstraint( + mesh_reg, mapping=reg_map, + alpha_s = 0.1, + alpha_x = 1., + alpha_y = 1., +) +xy = utils.ndgrid(x, np.r_[0.]) +reg.get_grad_horizontal(xy, hz, dim=2, use_cell_weights=True) + + +# reg_map = maps.IdentityMap(nP=mesh_soundings.nC) +# reg = regularization.Sparse( +# mesh_reg, mapping=reg_map, +# ) + +ps, px, py = 1, 1, 1 +reg.norms = np.c_[ps, px, py, 0] + +reg.mref = starting_model +reg.mrefInSmooth = False + +# Define how the optimization problem is solved. Here we will use an inexact +# Gauss-Newton approach that employs the conjugate gradient solver. +opt = optimization.InexactGaussNewton(maxIter = 40, maxIterCG=20) + +# Define the inverse problem +inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt) + + + + + + + + +####################################################################### +# Define Inversion Directives +# --------------------------- +# +# Here we define any directiveas that are carried out during the inversion. This +# includes the cooling schedule for the trade-off parameter (beta), stopping +# criteria for the inversion and saving inversion results at each iteration. +# + +# Apply and update sensitivity weighting as the model updates +#sensitivity_weights = directives.UpdateSensitivityWeights() + +# Reach target misfit for L2 solution, then use IRLS until model stops changing. +#IRLS = directives.Update_IRLS(max_irls_iterations=40, minGNiter=1, f_min_change=1e-5, chifact_start=2) +#IRLS = directives.Update_IRLS( +# max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, +# beta_tol=1e-2, f_min_change=1e-5, +# chifact_start = 1. +#) + +# Defining a starting value for the trade-off parameter (beta) between the data +# misfit and the regularization. +starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=10) + + +beta_schedule = directives.BetaSchedule(coolingFactor=2, coolingRate=2) + +# Update the preconditionner +update_Jacobi = directives.UpdatePreconditioner() + +# Options for outputting recovered models and predicted data for each beta. +save_iteration = directives.SaveOutputEveryIteration(save_txt=False) + + +update_IRLS = directives.Update_IRLS( + max_irls_iterations=20, minGNiter=1, + fix_Jmatrix=True, + f_min_change = 1e-3, + coolingRate=3 +) + +# Updating the preconditionner if it is model dependent. +update_jacobi = directives.UpdatePreconditioner() + +# Setting a stopping criteria for the inversion. +target_misfit = directives.TargetMisfit(chifact=1) + +# Add sensitivity weights +sensitivity_weights = directives.UpdateSensitivityWeights() + +target = directives.TargetMisfit() + +# The directives are defined as a list. +directives_list = [ + # sensitivity_weights, + starting_beta, + beta_schedule, + save_iteration, + # target_misfit, + update_IRLS, + # update_jacobi, +] + +##################################################################### +# Running the Inversion +# --------------------- +# +# To define the inversion object, we need to define the inversion problem and +# the set of directives. We can then run the inversion. +# + +# Here we combine the inverse problem and the set of directives +inv = inversion.BaseInversion(inv_prob, directives_list) + +# Run the inversion +recovered_model = inv.run(starting_model) + + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +# True model +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +true_model = np.ones(mesh2D.nC) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +true_model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +true_model[poly_inds] = slope_conductivity + +# true_model = true_model.reshape(mesh_soundings.vnC, order='C') +# true_model = np.flipud(true_model) +# true_model = mkvc(true_model) + + +l2_model = inv_prob.l2model +dpred_l2 = simulation.dpred(l2_model) +l2_model = np.exp(l2_model) +# l2_model = l2_model.reshape((simulation.n_sounding, simulation.n_layer),) +# l2_model = mkvc(l2_model) + +dpred = simulation.dpred(recovered_model) +recovered_model = np.exp(recovered_model) +# recovered_model = recovered_model.reshape((simulation.n_sounding, simulation.n_layer)) +# recovered_model = mkvc(recovered_model) + + +mesh_plotting = TensorMesh([hx, np.flipud(hz)], x0='0N') +l2_model = l2_model.reshape(mesh_plotting.vnC, order='C') +l2_model = mkvc(np.fliplr(l2_model)) +recovered_model = recovered_model.reshape(mesh_plotting.vnC, order='C') +recovered_model = mkvc(np.fliplr(recovered_model)) + + +models_list = [true_model, l2_model, recovered_model] + + +for ii, mod in enumerate(models_list): + + fig = plt.figure(figsize=(9, 3)) + ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) + log_mod = np.log10(mod) + + mesh_plotting.plotImage( + log_mod, ax=ax1, grid=False, + clim=(np.log10(true_model.min()), np.log10(true_model.max())), +# clim=(np.log10(0.1), np.log10(1)), + pcolorOpts={"cmap": "viridis"}, + ) + ax1.set_ylim(mesh_plotting.vectorNy.min(), mesh_plotting.vectorNy.max()) + + ax1.set_title("Conductivity Model") + ax1.set_xlabel("x (m)") + ax1.set_ylabel("depth (m)") + + ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) + norm = mpl.colors.Normalize( + vmin=np.log10(true_model.min()), vmax=np.log10(true_model.max()) +# vmin=np.log10(0.1), vmax=np.log10(1) + ) + cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" + ) + cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +data_list = [dobs, dpred_l2, dpred] +color_list = ['k', 'b', 'r'] + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) + +for ii in range(0, len(data_list)): + d = np.reshape(data_list[ii], (n_sounding, len(times))) + ax.semilogy(x, np.abs(d), color_list[ii], lw=1) + +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dBdt| (T/s)") + + + + + + + + + + + + + + + + + + + + + diff --git a/tutorials/plot_2_tdem_inv_stitched_skytem.py b/tutorials/plot_2_tdem_inv_stitched_skytem.py new file mode 100644 index 0000000..5219cb3 --- /dev/null +++ b/tutorials/plot_2_tdem_inv_stitched_skytem.py @@ -0,0 +1,482 @@ +""" +Forward Simulation of Stitched SkyTEM Data +========================================== + + + + + +""" + +##################################################### +# Import Modules +# -------------- +# + +import numpy as np +import os +import matplotlib as mpl +from matplotlib import pyplot as plt +from matplotlib.colors import LogNorm +from discretize import TensorMesh +from pymatsolver import PardisoSolver + +from SimPEG.utils import mkvc +from SimPEG import ( + maps, data, data_misfit, inverse_problem, regularization, optimization, + directives, inversion, utils + ) + +from SimPEG.utils import mkvc +import simpegEM1D as em1d +from simpegEM1D import get_2d_mesh, LateralConstraint +from simpegEM1D.utils import plotLayer, get_vertical_discretization_time +from simpegEM1D import skytem_HM_2015, skytem_LM_2015 + +save_file = True + +plt.rcParams.update({'font.size': 16, 'lines.linewidth': 2, 'lines.markersize':8}) + + +############################################# +# Define File Names +# ----------------- +# +# File paths for assets we are loading. To set up the inversion, we require +# topography and field observations. The true model defined on the whole mesh +# is loaded to compare with the inversion result. +# + +data_filename = './assets/em1dtm_stitched_data_skytem.obs' + + + +##################################################################### +# topography +# ------------- +# +# + +x = np.linspace(50,4950,50) +y = np.zeros_like(x) +z = np.zeros_like(x) +topo = np.c_[x, y, z].astype(float) + +n_sounding = len(x) + +source_locations = np.c_[x, np.zeros(n_sounding), 30.*np.ones(n_sounding)] +source_current = 1. +source_orientation = 'z' +receiver_offset_r = 13.25 +receiver_offset_z = 2. + +receiver_locations = np.c_[x+receiver_offset_r, np.zeros(n_sounding), 30.*np.ones(n_sounding)+receiver_offset_z] +receiver_orientation = "z" # "x", "y" or "z" + + + + + +############################################# +# Load Data and Plot +# ------------------ +# + +# Load field data +dobs = np.loadtxt(str(data_filename)) +dobs = mkvc(dobs[:, -1]) + + +###################################################### +# Create Survey +# ------------- +# + +wave_HM = skytem_HM_2015() +wave_LM = skytem_LM_2015() +time_HM = wave_HM.time_gate_center[0::2] +time_LM = wave_LM.time_gate_center[0::2] + +time_input_currents_HM = wave_HM.current_times[-7:] +input_currents_HM = wave_HM.currents[-7:] +time_input_currents_LM = wave_LM.current_times[-13:] +input_currents_LM = wave_LM.currents[-13:] + + +source_list = [] + +for ii in range(0, n_sounding): + + source_location = mkvc(source_locations[ii, :]) + receiver_location = mkvc(receiver_locations[ii, :]) + receiver_list = [ + em1d.receivers.TimeDomainPointReceiver( + receiver_location, + times=time_HM, + times_dual_moment=time_LM, + orientation=receiver_orientation, + component="dbdt" + ) + ] + +# Sources + source_list.append( + em1d.sources.TimeDomainMagneticDipoleSource( + receiver_list=receiver_list, + location=source_location, + moment_amplitude=source_current, + orientation=source_orientation, + wave_type="general", + moment_type='dual', + time_input_currents=time_input_currents_HM, + input_currents=input_currents_HM, + n_pulse = 1, + base_frequency = 25., + time_input_currents_dual_moment = time_input_currents_LM, + input_currents_dual_moment = input_currents_LM, + base_frequency_dual_moment = 210 + ) + ) + + +# Survey +survey = em1d.survey.EM1DSurveyTD(source_list) + + + +############################################# +# Assign Uncertainties +# -------------------- +# +# + +uncertainties = 0.1*np.abs(dobs)*np.ones(np.shape(dobs)) + + +############################################### +# Define Data +# -------------------- +# +# Here is where we define the data that are inverted. The data are defined by +# the survey, the observation values and the uncertainties. +# + +data_object = data.Data(survey, dobs=dobs, noise_floor=uncertainties) + + + +############################################### +# Defining a Global Mesh +# ---------------------- +# + +n_layer = 25 +thicknesses = get_vertical_discretization_time( + time_HM, sigma_background=0.1, n_layer=n_layer-1 +) + +dx = 100. +hx = np.ones(n_sounding) * dx +hz = np.r_[thicknesses, thicknesses[-1]] +mesh2D = TensorMesh([hx, np.flipud(hz)], x0='0N') +mesh_soundings = TensorMesh([hz, hx], x0='00') + +n_param = n_layer*n_sounding + + +############################################### +# Defining a Model +# ---------------------- +# + +conductivity = np.ones(n_param) * 0.1 + +mapping = maps.ExpMap(nP=n_param) +starting_model = np.log(conductivity) + +####################################################################### +# Define the Forward Simulation and Predic Data +# ---------------------------------------------- +# + + + +Simulate response for static conductivity +simulation = em1d.simulation.StitchedEM1DTMSimulation( + survey=survey, thicknesses=thicknesses, sigmaMap=mapping, + topo=topo, verbose=True, Solver=PardisoSolver +) + +# simulation = em1d.simulation.StitchedEM1DTMSimulation( +# survey=survey, thicknesses=thicknesses, sigmaMap=mapping, +# topo=topo, parallel=True, n_cpu=4, verbose=True, Solver=PardisoSolver +# ) + + +pred = simulation.dpred(starting_model) +fig = plt.figure() +plt.semilogy(-pred, '.', ms=1) +plt.semilogy(-dobs, 'x') +plt.show() + + + +######################################################################## +# Define Inverse Problem +# ---------------------- +# +# The inverse problem is defined by 3 things: +# +# 1) Data Misfit: a measure of how well our recovered model explains the field data +# 2) Regularization: constraints placed on the recovered model and a priori information +# 3) Optimization: the numerical approach used to solve the inverse problem +# +# + +# Define the data misfit. Here the data misfit is the L2 norm of the weighted +# residual between the observed data and the data predicted for a given model. +# The weighting is defined by the reciprocal of the uncertainties. +dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object) +dmis.W = 1./uncertainties + + +# Define the regularization (model objective function) +mesh_reg = get_2d_mesh(n_sounding, hz) +reg_map = maps.IdentityMap(mesh_reg) +reg = LateralConstraint( + mesh_reg, mapping=reg_map, + alpha_s = 0.1, + alpha_x = 1., + alpha_y = 1., +) +xy = utils.ndgrid(x, np.r_[0.]) +reg.get_grad_horizontal(xy, hz, dim=2, use_cell_weights=True) + + +# reg_map = maps.IdentityMap(nP=mesh_soundings.nC) +# reg = regularization.Sparse( +# mesh_reg, mapping=reg_map, +# ) + +ps, px, py = 1, 1, 1 +reg.norms = np.c_[ps, px, py, 0] + +reg.mref = starting_model +reg.mrefInSmooth = False + +# Define how the optimization problem is solved. Here we will use an inexact +# Gauss-Newton approach that employs the conjugate gradient solver. +opt = optimization.InexactGaussNewton(maxIter = 40, maxIterCG=20) + +# Define the inverse problem +inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt) + + + + + + + + +####################################################################### +# Define Inversion Directives +# --------------------------- +# +# Here we define any directiveas that are carried out during the inversion. This +# includes the cooling schedule for the trade-off parameter (beta), stopping +# criteria for the inversion and saving inversion results at each iteration. +# + +# Apply and update sensitivity weighting as the model updates +#sensitivity_weights = directives.UpdateSensitivityWeights() + +# Reach target misfit for L2 solution, then use IRLS until model stops changing. +#IRLS = directives.Update_IRLS(max_irls_iterations=40, minGNiter=1, f_min_change=1e-5, chifact_start=2) +#IRLS = directives.Update_IRLS( +# max_irls_iterations=20, minGNiter=1, fix_Jmatrix=True, coolingRate=2, +# beta_tol=1e-2, f_min_change=1e-5, +# chifact_start = 1. +#) + +# Defining a starting value for the trade-off parameter (beta) between the data +# misfit and the regularization. +starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=10) + + +beta_schedule = directives.BetaSchedule(coolingFactor=2, coolingRate=2) + +# Update the preconditionner +update_Jacobi = directives.UpdatePreconditioner() + +# Options for outputting recovered models and predicted data for each beta. +save_iteration = directives.SaveOutputEveryIteration(save_txt=False) + + +update_IRLS = directives.Update_IRLS( + max_irls_iterations=20, minGNiter=1, + fix_Jmatrix=True, + f_min_change = 1e-3, + coolingRate=3 +) + +# Updating the preconditionner if it is model dependent. +update_jacobi = directives.UpdatePreconditioner() + +# Setting a stopping criteria for the inversion. +target_misfit = directives.TargetMisfit(chifact=1) + +# Add sensitivity weights +sensitivity_weights = directives.UpdateSensitivityWeights() + +target = directives.TargetMisfit() + +# The directives are defined as a list. +directives_list = [ + # sensitivity_weights, + starting_beta, + beta_schedule, + save_iteration, + # target_misfit, + update_IRLS, + # update_jacobi, +] + +##################################################################### +# Running the Inversion +# --------------------- +# +# To define the inversion object, we need to define the inversion problem and +# the set of directives. We can then run the inversion. +# + +# Here we combine the inverse problem and the set of directives +inv = inversion.BaseInversion(inv_prob, directives_list) + +# Run the inversion +recovered_model = inv.run(starting_model) + + + +####################################################################### +# Plotting Results +# ------------------------------------------------- +# +# + + +# True model +from scipy.spatial import Delaunay +def PolygonInd(mesh, pts): + hull = Delaunay(pts) + inds = hull.find_simplex(mesh.gridCC)>=0 + return inds + + +background_conductivity = 0.1 +overburden_conductivity = 0.025 +slope_conductivity = 0.4 + +true_model = np.ones(mesh2D.nC) * background_conductivity + +layer_ind = mesh2D.gridCC[:, -1] > -30. +true_model[layer_ind] = overburden_conductivity + + +x0 = np.r_[0., -30.] +x1 = np.r_[dx*n_sounding, -30.] +x2 = np.r_[dx*n_sounding, -130.] +x3 = np.r_[0., -50.] +pts = np.vstack((x0, x1, x2, x3, x0)) +poly_inds = PolygonInd(mesh2D, pts) +true_model[poly_inds] = slope_conductivity + +# true_model = true_model.reshape(mesh_soundings.vnC, order='C') +# true_model = np.flipud(true_model) +# true_model = mkvc(true_model) + + +l2_model = inv_prob.l2model +dpred_l2 = simulation.dpred(l2_model) +l2_model = np.exp(l2_model) +# l2_model = l2_model.reshape((simulation.n_sounding, simulation.n_layer),) +# l2_model = mkvc(l2_model) + +dpred = simulation.dpred(recovered_model) +recovered_model = np.exp(recovered_model) +# recovered_model = recovered_model.reshape((simulation.n_sounding, simulation.n_layer)) +# recovered_model = mkvc(recovered_model) + + +mesh_plotting = TensorMesh([hx, np.flipud(hz)], x0='0N') +l2_model = l2_model.reshape(mesh_plotting.vnC, order='C') +l2_model = mkvc(np.fliplr(l2_model)) +recovered_model = recovered_model.reshape(mesh_plotting.vnC, order='C') +recovered_model = mkvc(np.fliplr(recovered_model)) + + +models_list = [true_model, l2_model, recovered_model] + + +for ii, mod in enumerate(models_list): + + fig = plt.figure(figsize=(9, 3)) + ax1 = fig.add_axes([0.1, 0.12, 0.73, 0.78]) + log_mod = np.log10(mod) + + mesh_plotting.plotImage( + log_mod, ax=ax1, grid=False, + clim=(np.log10(true_model.min()), np.log10(true_model.max())), +# clim=(np.log10(0.1), np.log10(1)), + pcolorOpts={"cmap": "viridis"}, + ) + ax1.set_ylim(mesh_plotting.vectorNy.min(), mesh_plotting.vectorNy.max()) + + ax1.set_title("Conductivity Model") + ax1.set_xlabel("x (m)") + ax1.set_ylabel("depth (m)") + + ax2 = fig.add_axes([0.85, 0.12, 0.05, 0.78]) + norm = mpl.colors.Normalize( + vmin=np.log10(true_model.min()), vmax=np.log10(true_model.max()) +# vmin=np.log10(0.1), vmax=np.log10(1) + ) + cbar = mpl.colorbar.ColorbarBase( + ax2, norm=norm, cmap=mpl.cm.viridis, orientation="vertical", format="$10^{%.1f}$" + ) + cbar.set_label("Conductivity [S/m]", rotation=270, labelpad=15, size=12) + + + + +data_list = [dobs, dpred_l2, dpred] +color_list = ['k', 'b', 'r'] + +fig, ax = plt.subplots(1,1, figsize = (7, 7)) +n_time = time_HM.size + time_LM.size +for ii in range(0, len(data_list)): + d = np.reshape(data_list[ii], (n_sounding, n_time)) + ax.semilogy(x, np.abs(d), color_list[ii], lw=1) + +ax.set_xlabel("Times (s)") +ax.set_ylabel("|dBdt| (T/s)") +plt.show() + + + + + + + + + + + + + + + + + + + +