From 4d3351e99c953ac78598a0adb2270e5eda4dcb42 Mon Sep 17 00:00:00 2001 From: GudniRos Date: Tue, 30 Jun 2015 08:41:03 -0700 Subject: [PATCH] Inversion problem working. Fixed 1D problem to correct the phase quadrants. --- notebooks/Derivative test MT1D.ipynb | 187 +- notebooks/MT1D inversion test-nr2.ipynb | 1592 +++++++++++++++++ notebooks/MT1D inversion test.ipynb | 681 ++++++- simpegMT/BaseMT.py | 20 +- simpegMT/DataMT.py | 14 +- simpegMT/FieldsMT.py | 16 +- simpegMT/ProblemMT1D/Problems.py | 16 +- simpegMT/ProblemMT3D/Problems.py | 10 +- simpegMT/Sources/backgroundModelSources.py | 4 +- simpegMT/SurveyMT.py | 13 +- ...test_Problem1D_againstAnalyticHalfspace.py | 6 +- .../test_Problem1D_totalDvsPSvsAnalytic.py | 155 ++ simpegMT/Utils/MT1Danalytic.py | 2 +- 13 files changed, 2440 insertions(+), 276 deletions(-) create mode 100644 notebooks/MT1D inversion test-nr2.ipynb create mode 100644 simpegMT/Tests/test_Problem1D_totalDvsPSvsAnalytic.py diff --git a/notebooks/Derivative test MT1D.ipynb b/notebooks/Derivative test MT1D.ipynb index f75403d9..41b0c6d2 100644 --- a/notebooks/Derivative test MT1D.ipynb +++ b/notebooks/Derivative test MT1D.ipynb @@ -51,15 +51,7 @@ "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Project at freq: 1.000e+02\n" - ] - } - ], + "outputs": [], "source": [ "# Setup the problem\n", "sigmaHalf = 1e-2\n", @@ -237,13 +229,13 @@ "==================== checkDerivative ====================\n", "iter h |ft-f0| |ft-f0-h*J0*dx| Order\n", "---------------------------------------------------------\n", - " 0 1.00e-01 1.094e-05 3.087e-08 nan\n", - " 1 1.00e-02 1.097e-06 3.093e-10 1.999\n", - " 2 1.00e-03 1.097e-07 3.093e-12 2.000\n", - " 3 1.00e-04 1.097e-08 3.093e-14 2.000\n", - " 4 1.00e-05 1.097e-09 3.095e-16 2.000\n", + " 0 1.00e-01 1.884e-05 1.227e-07 nan\n", + " 1 1.00e-02 1.873e-06 1.265e-09 1.987\n", + " 2 1.00e-03 1.872e-07 1.269e-11 1.999\n", + " 3 1.00e-04 1.872e-08 1.269e-13 2.000\n", + " 4 1.00e-05 1.872e-09 1.269e-15 2.000\n", "========================= PASS! =========================\n", - "You are awesome.\n", + "That was easy!\n", "\n" ] }, @@ -277,7 +269,7 @@ { "data": { "text/plain": [ - "array([ 0.00127341])" + "array([ 0.00052762])" ] }, "execution_count": 8, @@ -299,7 +291,7 @@ { "data": { "text/plain": [ - "array([[ 0.00173178]])" + "array([[ 0.00124017]])" ] }, "execution_count": 9, @@ -336,17 +328,12 @@ "==================== checkDerivative ====================\n", "iter h |ft-f0| |ft-f0-h*J0*dx| Order\n", "---------------------------------------------------------\n", - "Project at freq: 1.000e+02\n", - "Project at freq: 1.000e+02\n", - " 0 1.00e-01 2.646e-06 2.277e-08 nan\n", - "Project at freq: 1.000e+02\n", - " 1 1.00e-02 2.629e-07 2.246e-10 2.006\n", - "Project at freq: 1.000e+02\n", - " 2 1.00e-03 2.627e-08 2.243e-12 2.001\n", - "Project at freq: 1.000e+02\n", - " 3 1.00e-04 2.627e-09 2.242e-14 2.000\n", + " 0 1.00e-01 4.417e-08 4.873e-09 nan\n", + " 1 1.00e-02 4.132e-09 4.832e-11 2.004\n", + " 2 1.00e-03 4.105e-10 4.828e-13 2.000\n", + " 3 1.00e-04 4.103e-11 4.827e-15 2.000\n", "========================= PASS! =========================\n", - "Yay passed!\n", + "You get a gold star!\n", "\n" ] }, @@ -411,7 +398,7 @@ "output_type": "stream", "text": [ "Adjoint e formulation - projectFieldsDeriv\n", - "-0.000991536643367 -0.000991536643367 2.16840434497e-19 1e-07 True\n" + "-2.26989762698e-05 -2.26989762698e-05 0.0 1e-08 True\n" ] }, { @@ -456,32 +443,13 @@ "metadata": { "collapsed": false }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR: No traceback has been produced, nothing to debug.\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Adjoint test e formulation - getADeriv_m\n", - "(340193.379835-398622.996348j) (340193.379835-398622.996348j) (-2.32830643654e-10-3.49245965481e-10j) 10.0 True\n" + "(-1977540.36505+2093781.70221j) (-1977540.36505+2093781.70221j) (-1.86264514923e-09+2.79396772385e-09j) 100.0 True\n" ] }, { @@ -490,7 +458,7 @@ "True" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -531,7 +499,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": { "collapsed": false }, @@ -541,7 +509,7 @@ "output_type": "stream", "text": [ "Adjoint test e formulation - getRHSDeriv_m\n", - "(-12351.1349263+433.4655562j) (-12351.1349263+433.4655562j) (-9.09494701773e-12-1.22781784739e-11j) 1.0 True\n" + "(13201.2196403+13827.5790776j) (13201.2196403+13827.5790776j) (-5.45696821064e-12+3.63797880709e-12j) 1.0 True\n" ] }, { @@ -550,7 +518,7 @@ "True" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -582,7 +550,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": { "collapsed": false }, @@ -603,7 +571,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": { "collapsed": false }, @@ -634,7 +602,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": { "collapsed": false }, @@ -644,7 +612,7 @@ "output_type": "stream", "text": [ "Adjoint e formulation - Jvec\n", - "-3.61480355369e-05 -3.61480355369e-05 -2.71050543121e-20 1e-08 True\n" + "1.96695386678e-05 1.96695386678e-05 3.38813178902e-21 1e-08 True\n" ] }, { @@ -653,7 +621,7 @@ "True" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -661,99 +629,6 @@ "source": [ "JvecAdjointTest()" ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "collapsed": false, - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR: No traceback has been produced, nothing to debug.\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "collapsed": false, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Project at freq: 1.000e+02\n" - ] - }, - { - "data": { - "text/plain": [ - "array([ 9.80523303e-06, -1.98372645e-03])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "survey.dpred(sigma)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "collapsed": false - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'r' 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[1;32m----> 1\u001b[1;33m \u001b[0mr\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mNameError\u001b[0m: name 'r' is not defined" - ] - } - ], - "source": [ - "r" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "problem.mesh.getEdgeInnerProductDeriv(problem.curModel.sigma)(u0[1::])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] } ], "metadata": { @@ -761,6 +636,18 @@ "display_name": "Python 2", "language": "python", "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" } }, "nbformat": 4, diff --git a/notebooks/MT1D inversion test-nr2.ipynb b/notebooks/MT1D inversion test-nr2.ipynb new file mode 100644 index 00000000..c617d865 --- /dev/null +++ b/notebooks/MT1D inversion test-nr2.ipynb @@ -0,0 +1,1592 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import SimPEG as simpeg\n", + "import simpegMT as simpegmt\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Setup the problem\n", + "\n", + "# Frequency\n", + "nFreq = 33\n", + "freqs = np.logspace(3,-3,nFreq)\n", + "# freqs = np.array([100,10,1,0.1,0.01])\n", + "# Make the mesh\n", + "ct = 10\n", + "air = simpeg.Utils.meshTensor([(ct,15,1.3)])\n", + "core = np.concatenate( ( np.kron(simpeg.Utils.meshTensor([(ct,15,-1.2)]),np.ones((5,))) , simpeg.Utils.meshTensor([(ct,5)]) ) )\n", + "bot = simpeg.Utils.meshTensor([(core[0],10,-1.3)])\n", + "x0 = -np.array([np.sum(np.concatenate((core,bot)))])\n", + "# Change to use no air\n", + "m1d = simpeg.Mesh.TensorMesh([np.concatenate((bot,core,air))], x0=x0)\n", + "\n", + "## Setup model varibles\n", + "active = m1d.vectorCCx<0.\n", + "layer1 = (m1d.vectorCCx<-200.) & (m1d.vectorCCx>=-600.)\n", + "layer2 = (m1d.vectorCCx<-2000.) & (m1d.vectorCCx>=-4000.)\n", + "actMap = simpeg.Maps.ActiveCells(m1d, active, np.log(1e-8), nC=m1d.nCx)\n", + "mappingExpAct = simpeg.Maps.ExpMap(m1d) * actMap\n", + "sig_half = 2e-3\n", + "sig_air = 1e-8\n", + "sig_layer1 = 1\n", + "sig_layer2 = .1\n", + "# Make the true model\n", + "sigma_true = np.ones(m1d.nCx)*sig_air\n", + "sigma_true[active] = sig_half\n", + "sigma_true[layer1] = sig_layer1\n", + "sigma_true[layer2] = sig_layer2\n", + "m_true = np.log(sigma_true[active])\n", + "# Make the background model\n", + "sigma_0 = np.ones(m1d.nCx)*sig_air\n", + "sigma_0[active] = sig_half\n", + "m_0 = np.log(sigma_0[active])\n", + "\n", + "# Receivers \n", + "# 1D impedance at the surface (elevation 0)\n", + "rxList = []\n", + "for rxType in ['z1dr','z1di']:\n", + " rxList.append(simpegmt.SurveyMT.RxMT(simpeg.mkvc(np.array([0.0]),2).T,rxType))\n", + "# Source list\n", + "srcList =[]\n", + "tD = False\n", + "if tD:\n", + " for freq in freqs:\n", + " srcList.append(simpegmt.SurveyMT.srcMT_polxy_1DhomotD(rxList,freq))\n", + "else:\n", + " for freq in freqs:\n", + " srcList.append(simpegmt.SurveyMT.srcMT_polxy_1Dprimary(rxList,freq,sigma_0))\n", + "# Make the survey\n", + "survey = simpegmt.SurveyMT.SurveyMT(srcList)\n", + "survey.mtrue = m_true\n", + "# Set the problem\n", + "problem = simpegmt.ProblemMT1D.eForm_psField(m1d,mapping=mappingExpAct)\n", + "from pymatsolver import MumpsSolver\n", + "problem.solver = MumpsSolver\n", + "problem.pair(survey)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# problem.mapping.sigmaMap._transform(m_0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.002" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sig_half" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Make the observed data \n", + "# Project the data\n", + "d_true = survey.dpred(m_true)\n", + "survey.dtrue = d_true\n", + "# Add noise\n", + "std = 0.05 # 5% std\n", + "noise = std*abs(survey.dtrue)*np.random.randn(*survey.dtrue.shape)\n", + "# Assign the dobs\n", + "survey.dobs = survey.dtrue + noise\n", + "survey.std = survey.dobs*0 + std\n", + "# Assign the data weight\n", + "survey.Wd = 1/(abs(survey.dobs)*std)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Setup the inversion proceedure\n", + "C = simpeg.Utils.Counter()\n", + "\n", + "# Set the optimization\n", + "opt = simpeg.Optimization.InexactGaussNewton(maxIter = 50)\n", + "opt.counter = C\n", + "opt.LSshorten = 0.5\n", + "opt.remember('xc')\n", + "# Data misfit\n", + "dmis = simpeg.DataMisfit.l2_DataMisfit(survey)\n", + "# Regularization\n", + "# regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]])\n", + "# reg = simpeg.Regularization.Tikhonov(regMesh)\n", + "reg = simpeg.Regularization.Tikhonov(m1d,mapping=mappingExpAct)\n", + "reg.alpha_s = 1e-5\n", + "reg.alpha_x = 1.\n", + "reg.alpha_xx = .1\n", + "# Inversion problem\n", + "invProb = simpeg.InvProblem.BaseInvProblem(dmis, reg, opt)\n", + "invProb.counter = C\n", + "# Beta cooling\n", + "beta = simpeg.Directives.BetaSchedule()\n", + "betaest = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)\n", + "saveModel = simpeg.Directives.SaveModelEveryIteration()\n", + "# Create an inversion object\n", + "inv = simpeg.Inversion.BaseInversion(invProb, directiveList=[beta,betaest])#,saveModel]) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "problem.mapping.sigmaMap.maps[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem will set Regularization.mref to m0.\n", + "SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same solver as the problem***\n", + "SimPEG.l2_DataMisfit is creating default weightings for Wd.\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + " 0 2.01e+05 1.38e+06 6.91e-07 1.38e+06 2.03e+05 0 \n", + " 1 2.01e+05 1.66e+05 6.15e-06 1.66e+05 2.43e+04 0 \n", + " 2 2.01e+05 8.65e+04 1.09e-05 8.65e+04 1.51e+04 0 Skip BFGS \n", + " 3 2.51e+04 7.32e+04 1.31e-05 7.32e+04 1.32e+04 0 Skip BFGS \n", + " 4 2.51e+04 3.60e+04 3.07e-05 3.60e+04 7.51e+03 0 Skip BFGS \n", + " 5 2.51e+04 2.97e+04 3.89e-05 2.97e+04 6.45e+03 0 Skip BFGS \n", + " 6 3.14e+03 2.60e+04 4.57e-05 2.60e+04 5.81e+03 0 Skip BFGS \n", + " 7 3.14e+03 1.40e+04 9.70e-05 1.40e+04 3.59e+03 0 Skip BFGS \n", + " 8 3.14e+03 1.13e+04 1.25e-04 1.13e+04 3.04e+03 0 Skip BFGS \n", + " 9 3.92e+02 9.74e+03 1.48e-04 9.74e+03 2.72e+03 0 Skip BFGS \n", + " 10 3.92e+02 5.04e+03 3.06e-04 5.04e+03 1.66e+03 0 Skip BFGS \n", + " 11 3.92e+02 3.98e+03 3.93e-04 3.98e+03 1.39e+03 0 Skip BFGS \n", + " 12 4.90e+01 3.40e+03 4.63e-04 3.40e+03 1.23e+03 0 Skip BFGS \n", + " 13 4.90e+01 1.79e+03 8.93e-04 1.79e+03 7.41e+02 0 Skip BFGS \n", + " 14 4.90e+01 1.42e+03 1.13e-03 1.42e+03 6.04e+02 0 Skip BFGS \n", + " 15 6.13e+00 1.23e+03 1.32e-03 1.23e+03 5.26e+02 0 Skip BFGS \n", + " 16 6.13e+00 7.15e+02 2.19e-03 7.15e+02 3.08e+02 0 Skip BFGS \n", + " 17 6.13e+00 5.94e+02 2.65e-03 5.94e+02 2.48e+02 0 Skip BFGS \n", + " 18 7.66e-01 5.31e+02 2.98e-03 5.31e+02 2.16e+02 0 Skip BFGS \n", + " 19 7.66e-01 3.63e+02 4.30e-03 3.63e+02 1.35e+02 0 Skip BFGS \n", + " 20 7.66e-01 3.01e+02 4.92e-03 3.01e+02 1.15e+02 0 Skip BFGS \n", + " 21 9.58e-02 2.61e+02 5.36e-03 2.61e+02 1.03e+02 0 Skip BFGS \n", + " 22 9.58e-02 1.70e+02 7.17e-03 1.70e+02 7.52e+01 0 Skip BFGS \n", + " 23 9.58e-02 1.12e+02 8.27e-03 1.12e+02 5.46e+01 0 Skip BFGS \n", + " 24 1.20e-02 7.86e+01 9.19e-03 7.86e+01 4.19e+01 0 Skip BFGS \n", + " 25 1.20e-02 4.42e+01 1.18e-02 4.42e+01 3.46e+01 0 Skip BFGS \n", + " 26 1.20e-02 2.82e+01 1.32e-02 2.82e+01 1.50e+01 0 Skip BFGS \n", + " 27 1.50e-03 2.39e+01 1.40e-02 2.39e+01 1.10e+01 0 Skip BFGS \n", + " 28 1.50e-03 1.94e+01 1.62e-02 1.94e+01 1.02e+01 0 Skip BFGS \n", + " 29 1.50e-03 1.82e+01 1.76e-02 1.82e+01 2.73e+00 0 Skip BFGS \n", + " 30 1.87e-04 1.80e+01 1.87e-02 1.80e+01 8.26e-01 0 Skip BFGS \n", + " 31 1.87e-04 1.79e+01 1.95e-02 1.79e+01 1.04e+00 0 Skip BFGS \n", + " 32 1.87e-04 1.79e+01 1.97e-02 1.79e+01 7.23e-01 0 \n", + " 33 2.34e-05 1.77e+01 2.30e-02 1.77e+01 2.97e+00 0 Skip BFGS \n", + " 34 2.34e-05 1.77e+01 2.85e-02 1.77e+01 1.93e+00 0 Skip BFGS \n", + " 35 2.34e-05 1.76e+01 2.77e-02 1.76e+01 4.66e-01 0 \n", + " 36 2.92e-06 1.76e+01 2.87e-02 1.76e+01 4.19e-01 0 \n", + " 37 2.92e-06 1.76e+01 3.20e-02 1.76e+01 1.03e+00 0 \n", + " 38 2.92e-06 1.76e+01 3.92e-02 1.76e+01 1.95e+00 0 \n", + " 39 3.65e-07 1.76e+01 4.02e-02 1.76e+01 4.95e-01 0 \n", + " 40 3.65e-07 1.76e+01 3.91e-02 1.76e+01 3.65e-01 0 \n", + " 41 3.65e-07 1.76e+01 3.91e-02 1.76e+01 3.16e-01 0 \n", + " 42 4.57e-08 1.76e+01 3.93e-02 1.76e+01 3.42e-01 0 \n", + " 43 4.57e-08 1.75e+01 4.67e-02 1.75e+01 1.26e+00 0 Skip BFGS \n", + " 44 4.57e-08 1.75e+01 5.23e-02 1.75e+01 1.70e+00 1 \n", + " 45 5.71e-09 1.75e+01 5.63e-02 1.75e+01 9.87e-01 0 \n", + " 46 5.71e-09 1.75e+01 6.77e-02 1.75e+01 1.55e+00 1 Skip BFGS \n", + " 47 5.71e-09 1.75e+01 6.29e-02 1.75e+01 9.07e-01 0 \n", + " 48 7.14e-10 1.75e+01 6.29e-02 1.75e+01 8.89e-01 0 Skip BFGS \n", + " 49 7.14e-10 1.75e+01 6.56e-02 1.75e+01 6.85e-01 0 \n", + " 50 7.14e-10 1.75e+01 6.72e-02 1.75e+01 6.46e-01 0 \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 8.4462e-04 <= tolF*(1+|f0|) = 1.3818e+05\n", + "1 : |xc-x_last| = 1.0965e-01 <= tolX*(1+|x0|) = 5.9957e+00\n", + "0 : |proj(x-g)-x| = 6.4640e-01 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 6.4640e-01 <= 1e3*eps = 1.0000e-02\n", + "1 : maxIter = 50 <= iter = 50\n", + "------------------------- DONE! -------------------------\n" + ] + } + ], + "source": [ + "# Runn the inversion\n", + "mopt = inv.run(m_0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Setup the inversion proceedure\n", + "C = simpeg.Utils.Counter()\n", + "\n", + "# Set the optimization\n", + "optc = simpeg.Optimization.InexactGaussNewton(maxIter = 20)\n", + "optc.counter = C\n", + "optc.LSshorten = 0.5\n", + "optc.remember('xc')\n", + "# Data misfit\n", + "dmisc = simpeg.DataMisfit.l2_DataMisfit(survey)\n", + "# Regularization\n", + "# regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]])\n", + "# reg = simpeg.Regularization.Tikhonov(regMesh)\n", + "regc = simpeg.Regularization.Tikhonov(m1d,mapping=mappingExpAct)\n", + "regc.alpha_s = 1e-5\n", + "regc.alpha_x = 1.\n", + "# Inversion problem\n", + "invProbc = simpeg.InvProblem.BaseInvProblem(dmisc, regc, optc)\n", + "invProbc.counter = C\n", + "# Beta cooling\n", + "betac = simpeg.Directives.BetaSchedule()\n", + "betaestc = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)\n", + "saveModel = simpeg.Directives.SaveModelEveryIteration()\n", + "# Create an inversion object\n", + "invc = simpeg.Inversion.BaseInversion(invProbc, directiveList=[betac,betaestc])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem will set Regularization.mref to m0.\n", + "SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same solver as the problem***\n", + "SimPEG.l2_DataMisfit is creating default weightings for Wd.\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + " 0 1.22e+03 1.75e+01 6.95e-02 1.02e+02 1.27e+02 0 \n", + " 1 1.22e+03 2.83e+01 2.63e-02 6.03e+01 6.19e+01 0 \n", + " 2 1.22e+03 2.04e+01 2.86e-02 5.52e+01 6.08e+01 0 \n", + " 3 1.52e+02 1.84e+01 2.72e-02 2.25e+01 8.98e+00 0 \n", + " 4 1.52e+02 1.78e+01 2.46e-02 2.16e+01 3.60e+00 0 \n", + " 5 1.52e+02 1.77e+01 2.44e-02 2.14e+01 2.75e+00 0 \n", + " 6 1.90e+01 1.77e+01 2.39e-02 1.82e+01 2.01e+00 0 \n", + " 7 1.90e+01 1.76e+01 2.46e-02 1.81e+01 9.52e-01 0 \n", + " 8 1.90e+01 1.76e+01 2.45e-02 1.81e+01 6.50e-01 0 \n", + " 9 2.38e+00 1.76e+01 2.44e-02 1.77e+01 7.01e-01 0 \n", + " 10 2.38e+00 1.76e+01 2.44e-02 1.77e+01 1.05e+00 0 Skip BFGS \n", + " 11 2.38e+00 1.76e+01 2.45e-02 1.77e+01 6.53e-01 0 \n", + " 12 2.97e-01 1.76e+01 2.45e-02 1.76e+01 7.44e-01 0 \n", + " 13 2.97e-01 1.76e+01 2.46e-02 1.76e+01 9.88e-01 0 \n", + " 14 2.97e-01 1.76e+01 2.60e-02 1.76e+01 6.11e-01 0 \n", + " 15 3.71e-02 1.76e+01 2.60e-02 1.76e+01 7.53e-01 0 \n", + " 16 3.71e-02 1.76e+01 2.87e-02 1.76e+01 1.45e+00 1 \n", + " 17 3.71e-02 1.76e+01 2.90e-02 1.76e+01 1.29e+00 0 \n", + " 18 4.64e-03 1.76e+01 2.91e-02 1.76e+01 1.02e+00 0 \n", + " 19 4.64e-03 1.76e+01 2.90e-02 1.76e+01 1.35e+00 0 \n", + " 20 4.64e-03 1.76e+01 3.08e-02 1.76e+01 1.38e+00 0 Skip BFGS \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 2.1982e-03 <= tolF*(1+|f0|) = 1.0299e+01\n", + "1 : |xc-x_last| = 3.4790e-01 <= tolX*(1+|x0|) = 4.5116e+00\n", + "0 : |proj(x-g)-x| = 1.3805e+00 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 1.3805e+00 <= 1e3*eps = 1.0000e-02\n", + "1 : maxIter = 20 <= iter = 20\n", + "------------------------- DONE! -------------------------\n" + ] + } + ], + "source": [ + "mopt2 = invc.run(mopt)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "moptc=mopt2" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Setup the inversion proceedure\n", + "C = simpeg.Utils.Counter()\n", + "\n", + "# Set the optimization\n", + "optc1 = simpeg.Optimization.InexactGaussNewton(maxIter = 20)\n", + "optc1.counter = C\n", + "optc1.LSshorten = 0.1\n", + "optc1.remember('xc')\n", + "# Data misfit\n", + "dmisc1 = simpeg.DataMisfit.l2_DataMisfit(survey)\n", + "# Regularization\n", + "# regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]])\n", + "# reg = simpeg.Regularization.Tikhonov(regMesh)\n", + "regc1 = simpeg.Regularization.Tikhonov(m1d,mapping=mappingExpAct)\n", + "regc1.alpha_s = 1e-5\n", + "regc1.alpha_x = 1.\n", + "regc1.mref = reg.mref\n", + "# Inversion problem\n", + "invProbc1 = simpeg.InvProblem.BaseInvProblem(dmisc1, regc1, optc1)\n", + "invProbc1.counter = C\n", + "# Beta cooling\n", + "betac1 = simpeg.Directives.BetaSchedule()\n", + "betaestc1 = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)\n", + "betaestc1.beta0 = 3.60e-03\n", + "saveModel = simpeg.Directives.SaveModelEveryIteration()\n", + "# Create an inversion object\n", + "invc1 = simpeg.Inversion.BaseInversion(invProbc1, directiveList=[betac1,betaestc1])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same solver as the problem***\n", + "SimPEG.l2_DataMisfit is creating default weightings for Wd.\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + " 0 1.30e-02 1.76e+01 2.85e-02 1.76e+01 1.38e+00 0 \n", + " 1 1.30e-02 1.75e+01 2.85e-02 1.75e+01 1.17e+00 1 \n", + " 2 1.30e-02 1.75e+01 2.85e-02 1.75e+01 9.35e-01 1 Skip BFGS \n", + " 3 1.62e-03 1.75e+01 2.85e-02 1.75e+01 7.47e-01 1 Skip BFGS \n", + " 4 1.62e-03 1.75e+01 2.85e-02 1.75e+01 1.00e+00 2 Skip BFGS \n", + " 5 1.62e-03 1.75e+01 2.85e-02 1.75e+01 1.00e+00 3 Skip BFGS \n", + " 6 2.03e-04 1.75e+01 2.85e-02 1.75e+01 1.01e+00 3 Skip BFGS \n", + " 7 2.03e-04 1.75e+01 2.85e-02 1.75e+01 1.01e+00 3 Skip BFGS \n", + " 8 2.03e-04 1.75e+01 2.85e-02 1.75e+01 1.02e+00 3 Skip BFGS \n", + " 9 2.53e-05 1.75e+01 2.85e-02 1.75e+01 1.02e+00 3 Skip BFGS \n", + " 10 2.53e-05 1.75e+01 2.85e-02 1.75e+01 1.03e+00 3 Skip BFGS \n", + " 11 2.53e-05 1.75e+01 2.85e-02 1.75e+01 1.04e+00 3 Skip BFGS \n", + " 12 3.16e-06 1.75e+01 2.85e-02 1.75e+01 1.05e+00 3 Skip BFGS \n", + " 13 3.16e-06 1.75e+01 2.85e-02 1.75e+01 1.06e+00 3 Skip BFGS \n", + " 14 3.16e-06 1.75e+01 2.85e-02 1.75e+01 1.07e+00 3 Skip BFGS \n", + " 15 3.96e-07 1.75e+01 2.85e-02 1.75e+01 1.08e+00 3 Skip BFGS \n", + " 16 3.96e-07 1.75e+01 2.85e-02 1.75e+01 1.10e+00 3 Skip BFGS \n", + " 17 3.96e-07 1.75e+01 2.85e-02 1.75e+01 1.11e+00 3 Skip BFGS \n", + " 18 4.94e-08 1.75e+01 2.85e-02 1.75e+01 1.13e+00 3 Skip BFGS \n", + " 19 4.94e-08 1.75e+01 2.85e-02 1.75e+01 1.14e+00 3 Skip BFGS \n", + " 20 4.94e-08 1.75e+01 2.85e-02 1.75e+01 1.16e+00 3 Skip BFGS \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 2.2454e-04 <= tolF*(1+|f0|) = 1.8553e+00\n", + "1 : |xc-x_last| = 1.9180e-01 <= tolX*(1+|x0|) = 4.4390e+00\n", + "0 : |proj(x-g)-x| = 1.1563e+00 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 1.1563e+00 <= 1e3*eps = 1.0000e-02\n", + "1 : maxIter = 20 <= iter = 20\n", + "------------------------- DONE! -------------------------\n" + ] + } + ], + "source": [ + "moptc1 = invc1.run(mopt2)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counters:\n", + " InexactGaussNewton.doEndIteration : 50\n", + " InexactGaussNewton.doStartIteration : 51\n", + " InexactGaussNewton.scaleSearchDirection : 50\n", + "\n", + "Times: mean sum\n", + " BaseInvProblem.evalFunction : 3.24e+00, 3.33e+02, 103x\n", + " InexactGaussNewton.findSearchDirection : 2.07e+01, 1.04e+03, 50x\n", + " InexactGaussNewton.minimize : 1.37e+03, 1.37e+03, 1x\n", + " InexactGaussNewton.modifySearchDirection: 1.93e+00, 9.63e+01, 50x\n", + " InexactGaussNewton.projection : 4.69e-05, 9.75e-03, 208x\n" + ] + } + ], + "source": [ + "opt.counter.summary()\n", + "xc = opt.recall('xc')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "# # plt.figure(1)\n", + "# # for i in range(problem.G.shape[0]):\n", + "# # plt.plot(problem.G[i,:])\n", + "# meshPts = np.concatenate((mesh.gridN[0:1],np.kron(mesh.gridN[1::],np.ones(2))[:-1]))\n", + "# modelPts = np.kron(1./model,np.ones(2,))\n", + "# axM.semilogx(modelPts,meshPts,color=col)\n", + "# plt.figure(2)\n", + "# plt.plot(m1d.vectorCCx[active], np.log10(mappingExpAct*survey.mtrue)[active], 'b-')\n", + "# plt.plot(m1d.vectorCCx[active], np.log10(mappingExpAct*mopt)[active], 'r-')\n", + "# plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def plotMT1DModelData(problem,models,symList=None):\n", + " # Make the analytic solution\n", + " # \tdef makeAnalyticSolution(mesh,model,elev,freqs):\n", + " # \t\tdata1D = []\n", + " # \t\tfor freq in freqs:\n", + " # \t\t\tanaEd, anaEu, anaHd, anaHu = simpegmt.Utils.MT1Danalytic.getEHfields(mesh,model,freq,elev)\n", + " # \t\t\tanaE = anaEd+anaEu\n", + " # \t\t\tanaH = anaHd+anaHu\n", + " # \t\t\t# Scale the solution\n", + " # \t\t\t# anaE = (anaEtemp/anaEtemp[-1])#.conj()\n", + " # \t\t\t# anaH = (anaHtemp/anaEtemp[-1])#.conj()\n", + " # \t\t\tanaZ = anaE/anaH\n", + " # \t\t\t# Add to the list\n", + " # \t\t\tdata1D.append((freq,0,0,elev,anaZ[0]))\n", + " # \t\tdataRec = np.array(data1D,dtype=[('freq',float),('x',float),('y',float),('z',float),('zxx',complex)])\n", + " # \t\treturn dataRec\n", + " def appResPhs(freq,z):\n", + " fr = simpeg.mkvc(freq,2)*np.ones(z.shape)\n", + " app_res = ((1./(8e-7*np.pi**2))/fr)*np.abs(z)**2\n", + " app_phs = np.arctan2(z.imag,z.real)*(180/np.pi)\n", + " return app_res, app_phs\n", + " \n", + " # Setup the figure\n", + " fontSize = 15\n", + "\n", + " fig = plt.figure(figsize=[9,7])\n", + " axM = fig.add_axes([0.075,.1,.25,.875])\n", + " axM.set_xlabel('Resistivity [Ohm*m]',fontsize=fontSize)\n", + " axM.set_xlim(1e-1,1e5)\n", + " axM.set_ylim(-10000,5000)\n", + " axM.set_ylabel('Depth [km]',fontsize=fontSize)\n", + " axR = fig.add_axes([0.42,.575,.5,.4])\n", + " axR.set_xscale('log')\n", + " axR.set_yscale('log')\n", + " axR.invert_xaxis()\n", + " # axR.set_xlabel('Frequency [Hz]')\n", + " axR.set_ylabel('Apparent resistivity [Ohm m]',fontsize=fontSize)\n", + "\n", + " axP = fig.add_axes([0.42,.1,.5,.4])\n", + " axP.set_xscale('log')\n", + " axP.invert_xaxis()\n", + " axP.set_ylim(0,90)\n", + " axP.set_xlabel('Frequency [Hz]',fontsize=fontSize)\n", + " axP.set_ylabel('Apparent phase [deg]',fontsize=fontSize)\n", + "\n", + " # if not symList:\n", + " # \tsymList = ['x']*len(models)\n", + " sys.path.append('/home/gudni/Dropbox/code/python/MTview')\n", + " import plotDataTypes as pDt\n", + " # Loop through the models.\n", + " modelList = [problem.survey.mtrue]\n", + " modelList.extend(models)\n", + " if False:\n", + " modelList = [problem.mapping.sigmaMap*mod for mod in modelList]\n", + " for nr, model in enumerate(modelList):\n", + " # Calculate the data\n", + " if nr==0:\n", + " data1D = problem.dataPair(problem.survey,problem.survey.dobs).toRecArray('Complex')\n", + " else:\n", + " data1D = problem.dataPair(problem.survey,problem.survey.dpred(model)).toRecArray('Complex')\n", + " # Plot the data and the model \n", + " colRat = nr/((len(modelList)-2)*1.)\n", + " if colRat > 1.:\n", + " col = 'k'\n", + " else:\n", + " col = plt.cm.seismic(1-colRat)\n", + " # The model - make the pts to plot\n", + " meshPts = np.concatenate((problem.mesh.gridN[0:1],np.kron(problem.mesh.gridN[1::],np.ones(2))[:-1]))\n", + " modelPts = np.kron(1./(problem.mapping.sigmaMap*model),np.ones(2,))\n", + " axM.semilogx(modelPts,meshPts,color=col)\n", + "\n", + " ## Data\n", + " # Appres\n", + " pDt.plotIsoStaImpedance(axR,np.array([0,0]),data1D,'zyx','res',pColor=col)\n", + " # Appphs\n", + " pDt.plotIsoStaImpedance(axP,np.array([0,0]),data1D,'zyx','phs',pColor=col)\n", + " try:\n", + " allData = np.concatenate((allData,mkvc(data1D['zyx'],2)),1)\n", + " except:\n", + " allData = simpeg.mkvc(data1D['zyx'],2)\n", + " freq = data1D['freq']\n", + " res, phs = appResPhs(freq,allData)\n", + "\n", + " stdCol = 'gray'\n", + " axRtw = axR.twinx()\n", + " axRtw.set_ylabel('Std of log10',color=stdCol)\n", + " [(t.set_color(stdCol), t.set_rotation(-45)) for t in axRtw.get_yticklabels()]\n", + " axPtw = axP.twinx()\n", + " axPtw.set_ylabel('Std ',color=stdCol)\n", + " [t.set_color(stdCol) for t in axPtw.get_yticklabels()]\n", + " axRtw.plot(freq, np.std(np.log10(res),1),'--',color=stdCol)\n", + " axPtw.plot(freq, np.std(phs,1),'--',color=stdCol)\n", + "\n", + " # Fix labels and ticks\n", + "\n", + " yMtick = [l/1000 for l in axM.get_yticks().tolist()]\n", + " axM.set_yticklabels(yMtick)\n", + " [ l.set_rotation(90) for l in axM.get_yticklabels()]\n", + " [ l.set_rotation(90) for l in axR.get_yticklabels()]\n", + " [(t.set_color(stdCol), t.set_rotation(-45)) for t in axRtw.get_yticklabels()]\n", + " [t.set_color(stdCol) for t in axPtw.get_yticklabels()]\n", + " for ax in [axM,axR,axP]:\n", + " ax.xaxis.set_tick_params(labelsize=fontSize)\n", + " ax.yaxis.set_tick_params(labelsize=fontSize)\n", + " return fig\n", + "# plotMT1DModelData(problem,[mopt])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": [ + "iVBORw0KGgoAAAANSUhEUgAAAogAAAIBCAYAAADK9k6qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", + "AAALEgAACxIB0t1+/AAAIABJREFUeJzs3XecXFX5+PHPM7MtjRQIhE6QmoCUJLRQIgHpSJMo8JWI\n", + "6Ff5YkMsPxVOzhdFKeIXuygC0gSld4QQCFWKUgKEEhJMAgFMIZDsZnfm+f1x7pLZ2Zmd2Zk7ZXef\n", + "9+s1L3bunD33DJl795lTniOqijHGGGOMMZ0StW6AMcYYY4ypLxYgGmOMMcaYLixANMYYY4wxXViA\n", + "aIwxxhhjurAA0RhjjDHGdGEBojHGGGOM6cICRGOMMcYY04UFiMYYY4wxpgsLEI3pZ0RkpIj8RETO\n", + "EJFmEfmdiDwvIpeJyKhat88YY0z9swDRmP7nMqAJ2BaYCawAPgO8Afyihu0yxpgBzXvf5L1vqnU7\n", + "iiG21Z4x/YuIPKeqHxeRBPA2MEZV09Frz6rqTrVtoTHGDCze+xZgH+BbwPvAdc65G2rbqp5ZD6Ix\n", + "/U8aIAoKn+oMDo0xxlSf934kcCrwNeA6wkjOud77bWvasAIaat0AYwYyERlc4q+u1vzd/ytEZJiq\n", + "rlTVQzPOtQHQVuL5jDHG9FI0nHwCsBNwvnNudnR8IVDXc8ItQDSmtj4o4XcUmAQ8k/NF1f3y/F4b\n", + "MK2E8xljjCnNZOAI4Fzn3GzvfRI4GlgMPFXTlhVgcxCNqSERSQM/AuYV+SsJ4I/ARFXNGSAaY4yp\n", + "Pe99A3AVMNM5d0n0fDJwOLAQ+BXRlCDnXN0FY9aDaEzt3a6q/yimoIg0EALEXhORYcB+hNXNI6PD\n", + "y4CXgQdVtZTeTGOMMbkp0AqsiZ5PA3aOnl/unEtlFvbetzjnWqvbxPysB9GYGhKRLYDFqrqmQNHs\n", + "31mkqu1Flk8AHjgDGASsIgSGEALFwdGxiwDXw9xGY4wxveC93xW4EniXMKw8G7jWObc8o8yhwI7A\n", + "OOAa59w9tWhrNgsQjennRMQTUit44DpVfTPr9U0J32wdcJGquuq30hhj+ifv/RhgODDfOdeW9doF\n", + "wFDgP8BzwC+BI5xzRY0qVZKluTGmDolIg4gMzn6UWN2pwLdU9YLs4BBAVf+tqhcSgshTy2m3McaY\n", + "rpxzbzvn5gJHee/36DzuvT8fWBf4HXCec+564E+EjQ5qzgJEY+qEiIwQkd+KyNuEFccfZD1Wllj1\n", + "COC1Isq9ztq5icYYY+L1ECEgxHu/PzCMkBNxjnNupfd+F8KuVx/lrvXeSy0aCn14kYqI2Ni4qQuq\n", + "GtcF/CdgCvAHQrBW9LzEAh4HvisiT+RbiCIiQ4HvAo8VU6Fdf8YYs1Yxfwecc28Bd0RPP05YwPKa\n", + "c67De78DcAHwf865R733Dc65DsKX9qWVandP+nQPoqpKvgfgezqW6+dc/+182LnsXHnOFaepwOmq\n", + "+l1VvURVL89+lFjvV4EdgAUico2InC0iX4seZ4nINcCCqMzpxVZazP+3Yp/nO1bMa6WUK/T79r7s\n", + "fdn7svfVi/dVNO+9eO8bgW2AfzvnPvDeTyTMPbwLuNx7vxlws/f+V8DfvPeH9OYccenTAWIBswoc\n", + "y/Vzrv/mqsfOZecq9ly9sYiwmjhWqvoiMB64ENgE+J/o5wsJAeHGhG+u41T1pWLrFZEZwPKMQ7Py\n", + "/FzM83zHinmtlHK9qSffz8U8z3esmNdKKdebevL9XMzzfMeKea2Ucr2pJ9/PxTzPd6yY10op15t6\n", + "8v1czPN8x4p5rZRyvakn38/FPM93rJjXSilXNuecOufagV8DZ3rvf03Yfu9GQl7EnQnDzq8Svtxf\n", + "APzJez+5Wm3sJNpHVzGLiPY2ci/jXDNUdYady86V41yxfQ5F5EhgBnC0qi6Io85Kqeb1V03V/OxU\n", + "k72vvsXeV99S6v3Qe78FYQg54Zx72nu/FWGe4gLgScLuK29776cAq51zT8TX6sL67BzEKptl57Jz\n", + "VZqq3ioihwCvicgbhN45ISRblVBEd6vU+UVkEDBac6x0zlN+BjBLVWdVqk01MKvWDaiQWbVuQIXM\n", + "qnUDKmRWrRtQIbNq3YB64pybD8yHj3ZduZSQB/FM7/0XgT9676cBD9eifRYgFqGafwDtXH3rXHES\n", + "kZ8B/0345phrkUqlu/sPIwx1JIsp3B97AvrqZ6cQe199i72vAWkIYTXzmdHz54A9nXMf1qpBNsRs\n", + "TBliHmJeDpyvqufGUV8J5z8OuF5VC85NtuvPGGOCOO6H3vt1CT2sPwaeBg4l7KxyBmF4OZ3/tyvD\n", + "AkRjyhBzgPgWcLKq3htHfRn1PkBxvY/rA9urasEexCjNjaf/DTEbY0yvxPV3IEp181vCCFIDcJFz\n", + "7ply6y2VBYjGlCHmAPF7wETg0xrjhSkiKWAu8GKBohsDuxUbINr1Z4wx8d4Po57ED4GWzP2aa8Hm\n", + "IBpTP9YFdgfmisgsuqaQAUBVv1NCvXOAl1R1Wk+FOoeYS6jfGGNMDJxz/wHw3rcVKltp1oNoTBli\n", + "7kGcT8aK5eyXCauYx5ZQ7++BQ1R1swLlbA6iMcb0Un+9H1qAaEwZ+sLnUES2Ikx2vq2noesozc0G\n", + "qjq/iDptDqIxxtA3/g6UwgJEY8owUD+HA/V9G2NMtv56P+zPW+0ZY4wxxpgSWIBojDHGGGO6sADR\n", + "GFMSEZkhIlNq3Q5jjDHxszmIxpRhoH4OB+r7NsaYbP31fmg9iMYYY4wxpgtLlG1MHRGR3YBjgI2A\n", + "lsyXCHkQj69Jw4wxxgwoVQ8QRWQqcAiwHTCSkBB4GfAycJeqzqx2m4ypByLyDeAiYAkwD2iPXsqX\n", + "PNsYY4ypiKrNQRSRUcDNwN7AG8BLrN1KbCQhYBwLzAaOVtWlBerrl2P+pm+JeSeVhcDfgG/GuRdz\n", + "JViibGOMCfprPFLNAPEqYBJwkqo+mafMROBq4ElVPalAff3yH8T0LTEHiO8Bn1HV++Kor5Ls+jPG\n", + "mKC/3g+rGSAuB6ar6s0Fyh0FXKGqwwuU65f/IKZviTlAvAhoUdXT4qivkuz6M8aYoL/eD6s5BzFN\n", + "mEdViERljRlovgtcIiL3ATNZOwXjI6r6m6q3Ko8jDjhgOcAbCxa898Krr25V6/YYY0y98943ATjn\n", + "1tS6LYVUswfxMmBf4GRVfThPmcnAn4EHVfWUAvX1y4jd9C0x9yB+EvgrMCxfGVWti9RUIqLD11kX\n", + "gDVrWtOrVn+QrHGTjDGmJor5O+C9bwH2Ab4FvA9c55y7oRrtK1U1A8ThwPXAgcDbhFXLnT0kIwiL\n", + "VMYA9wLTVHVFgfosQDQ1F3OA+AqwAPga8Lqq1u03zGiRCgDJZAsdHavtWjTGDEiF/g5470cCJwIH\n", + "ATcCrwKXAkc65+ZWp5W9V7Uh5ijgO0hE9qRrmhuAdwmrl+9S1cer1SZj6sxGwGmq+lKtG2KMMaZ8\n", + "0ZDyCcBOwPnOudnR8YXAqFq2rZCq50FU1ceAx6p9XmP6gPsJN5G6X8XcleJFmlwd93gaY0yNTAaO\n", + "AM51zs323ieBo4HFwFM1bVkBthezMWWIeYh5f+D3hHm495N7kcqLcZyrXJlDzIlEM2en254FTnaq\n", + "z9awWcYYU3X5/g547xuAq4CZzrlLoueTgcOBhcCviBblOufqLhiru632ROSPQKLQIpWo7IyMp5aw\n", + "11SciEwBplSo+s6eQx89silQd4tB0uk2Htr1oIZ9n7nn717k15fAliNg8+xyy2D+YtXpNWiiMcbU\n", + "ggKtQOfoyjRg5+j55c65VGZh732Lc661uk3Mr+56EEXkNSCpqmMLlLMeRFNzMfcgTilUpl6+BIUe\n", + "xIYVAMlkQzs0rLf5Ztv/56RFzz8zc03rngfA0OzfuR4enKM6peqNNcaYCurp74D3flfgSsJai8WE\n", + "9RbXOueWZ5Q5FNgRGAdc45y7p/KtLqzuAsRiWYBo6sFA/Rxmv+999vnszs8++/ATQGLnwbJo6pJ/\n", + "d+tBtADRGNMfFbGKeQwwHJjvnGvLeu0Cwhfq/wDPAb8EjnDO/aOCTS5KXQSIIjIIuBi4QFVfLfJ3\n", + "BuQfZlNfKvU5FJEk0Jx9XFVXxX2uUuR633vteVzTosULXnvzzac2TSaaSGTnxRdSazpa625aizHG\n", + "lKPYvwPe+2nAAufc49Hz84H1CPHPPOfcSu/9T4A7nHM580VXU9Vu1iIyuIeXRwCnAjeIyCKonz+E\n", + "xlRLlCv0XOAYYH267zxUl3MQOz362N/WAJslEk2aSq8hlfV6MtlSt203xphilTEX/SFgVwDv/f6E\n", + "TRF+AcxxznV473cBPgPcEk9Ly1PNRNlpwh+4YnpbVFV7/GNiPYimHsQ8B/Fawuq2PwIvsXZi80dU\n", + "9fI4zlWunt53Q8MgTaW6z7O2hNrGmP6olL8D3vtvEBbzneWc+8B7vwPwf8CtzrlfRGWS2QtZqqma\n", + "wz2rgJXAhYSx9kyDCcu9zwPqNqu4MRV2EHCGqv6h1g0pRpRFIFf2gDxfBBUvMsapvl3xxhljTB3y\n", + "3gsh9toGeC0KDicB5xOGln+RUXy0934QsJ5z7slqt7WaPYgbAxcQ/gh64NeqmopeGwEsBaao6kNF\n", + "1mc9iKbmYu5BXAicqqp3x1FfJRXoQexIpVq7jQAkEs16drrtNeAAp/pmxRtpjDFVUGIP4njg78BN\n", + "hN3lPGETkQRhW74OYDxhCt44YF/n3Lw4211IolonUtVFqnoCIYP4F4DnReTgap3fmD7gZ8BpIlK1\n", + "67Ka0uk2eXinqa3AbC+yda3bY4wxteKcmwPsRZhSdKxz7grgNOCnwLOE4PE3wBLgymoHh1CjVczR\n", + "Cs0vA/9LiJjPif5rPYimTyn3cygiFxCGZCEMyx5PmHv4ALl3UvlOkfUeA2wC3KOqczOOn66qvyq1\n", + "vRn15H3fjY2D3lcl16K0DtVE83ZjP/7esa8/sSaJHuxUny+3LcYYU0txxSPe+08SciYeDvyb0KvY\n", + "5pz7WvR6Veck1jTNjYisC/wY+DzQiAWIpo+JIUCcz9oAEdbO3cu+MIWweKvHBPJRnecBuxNyah0F\n", + "/FxVfx699k9V3aXU9maco6T3feCBJ0955JF77hsyaFh6fNu7qRUfrnhxTZib/BHbccUY05fEEY90\n", + "Bn/e++MIi1XmAI8751zm6zE0t2j1kgdxPLA1MFtVsxew5PsdCxBNzdXj51BEXgB2UdX26EvY34Cn\n", + "VfXMWgeIAAcf/IVR//rX428sWfLyOslEY/d5LpYv0RjTh8TYg9gIbAhcCuwE7O+ce6FWq5nrYq6T\n", + "qs5R1ZuLDQ6NMT1KqGo7QHRNHQxsISJ/og6u+bvvvnTpdttuOwISpNJttGc90ojlSzTGDEQNwHcJ\n", + "cxA/BawGqFWqm7roQSxFPfbcmIEnrs+hiGxEWLy1L7AxYYh5ESGx6qWq+lYv6rof+LaqPpNxLAn8\n", + "HjhFVcsOEuN435Yv0RjTH8QZj3jvxzjn6iIVmAWIxpQhjs+hiHwWuARoAZ4HOlPAbE5Ic9AKfElV\n", + "/1JkfZsC7Zoj36CITFbVR8ppb1SPBYjGGENl4hHvfcI5l46zzt6yANGYMsSwSGUyMIswT/AHqjov\n", + "6/WxhIVcnwb2U9VHy2hubCoaICaa6Ui12rVtjOkT+ms8YgGiMWWIIUC8A0ip6pEFyt0CNKjqYWWc\n", + "axhhCHs7YGR0eBnwMvCgqn7Qi7riCBDTqTyB4MEHTf/GXXdfdnE59RtjTDX013jEAkRjyhBDgLgU\n", + "mK6qtxYodyRwuaqOKuEcCUI+rTOAQYRtL5dFL48kbHW5CrgIcFrETSGO6y9PvkQR1URKYY89Drv+\n", + "0UdvmFbOOYwxptL6azxS8xWNxgxwLcCKIsqtjMqWwgHfBGYAW6jqUFXdNHoMJcx1nJFRpira21ev\n", + "09GxuiHrkfxhuu3CaR/b8ZUnnrjr+O232++VKfsd0+9uvMYYU++sB9GYMsTQg/gscLOqugLlZgBH\n", + "q+pOJZxjEfC/qvr7AuW+ROhB3LiIOit2/XmRJuDhhVvs+MxVb7/1xdbW5YlkMplam0O8sw2sam9f\n", + "vU4l2mCMMcXqr/GI9SAaU1uXAWeKyCfzFRCRA4Ezo7KlGAG8VkS511k7N7FmnOoa4DObzH/+2C+u\n", + "N+oQSJNKtSVTqdYujzzb+RljjImB9SAaU4YYehAbgJuBQ4GZ0c8Lopc3JyRLnQrcARylqr1OmBrl\n", + "RUwBx+RbiCIiQ4EbgaSqTi2iTiXMa+w0S1Vn9bZtPfEi04AfnZNsHptKtXVLnp1MtqQ6OlbbjivG\n", + "mJrqr/GIBYjGlCGmPIhJ4KvA1wlBYab5wMXAL1W1pJxYIjIOuA9oBu4hrFpeHr08HNgeOAhoA6aq\n", + "6ktF1FmV68+LXPKjZMupudLeWIBojKkH/TUesQDRmDLE/TmMklx3zgFcpKr/jqnekcCXgUOAbeme\n", + "5uYu4Hequjx3Dd3q6+xBjL3nMJMXGfyjZMuHHbkTaluAaIypuf4aj1iAaEwZBurnsJrvO3++xATH\n", + "f/r0Ha+7/uIXqtEOY4zJpb/+HbBFKsbUkIh8TUQ2KOF3RlegLYNEZLO46y1XAk03JprJfDQkmhFJ\n", + "ctPNVzx3+OFf/Hyt22iMMf2N9SAaU4YYFqmkgT1U9R9Flk8C7cBEVX2m1PPmqfs44DpV7bYgJEfZ\n", + "qgwxA4wXmXU87Jd9/Hp4MLHDAU1z5jy85777fOqyWQ/+5ZRKtsMYY3Lpr/GIzd8xpvbOjXZUKUal\n", + "e/2Lvsmp6owKtqOgUbDrAS/cd94Gux786gMP3/L5ZLJluoAgWfkS0fb2jtamGjXTGGP6JAsQjamt\n", + "h4AksH4vfudBoDf7Jj8AFDNUsH6R5erCh/AGsP4+z9y9z7brb/7ub955c3Su5ieTLY3Vb50xxnTn\n", + "vW8CcM6tqXVbCrEhZmPK0Bc+hyKSAuYCLxYoujGwW18aYp6jOsWLCDDunETzC6l0W7ffTyZb6OhY\n", + "Xdf/RsaYvquYvwPe+xZgH+BbwPvAdc65G6rRvlJZgGhMGfrC51BEngNeUtVpBcodB1yvqgWHsav5\n", + "vjcSuXwkbJF9fBnMX6w6vfN5Q8MgTeVOh2MBojGmYgrdD733I4ETCflmbwReBS4FjnTOza1OK3vP\n", + "hpiN6f8eI+Q/7JMyg8DSKF5kqMuzi4wxxlRKNKR8ArATcL5zbnZ0fCEwqpZtK8QCRGP6vwuAOyT6\n", + "mttDuTuALYutVERmUIUh5nKlUh2kkw3/8iKfc6qP1ro9xpgBZTJwBHCuc2629z4JHA0sBp6qacsK\n", + "sCFmY8owUD+H9fi+Gxta1ijSdUGKKql0B8PX2Sj1peSapUOWLfkjMMOp1v0EcWNM35Dvfui9bwCu\n", + "AmY65y6Jnk8GDgcWAr8C0gDOuboLxqwH0RjTL+RLZfOJKScOen3ey/N+/tZrY6ZvM+Hwl155+r9v\n", + "EpnXDh9mlsue02iMMWVSoBXo/EI6Ddg5en65cy6VWdh73+Kc6z6RukasB9GYMsT5ORSRGwkTl+9S\n", + "1XQcdVZKX7z+dt754Puee27W1N23m7Dy4JceHZb9eueq6Bo0zRjTh/V0P/Te7wpcCbxLGFaeDVzr\n", + "nFueUeZQYEdgHHCNc+6eyre6MAsQjSlDzAHiLEIahCWEG8qfVLUuV7hVM81NnPbZZ9rZDz98vYcG\n", + "GhLJrlnBhdSajlYbVTHG9EoRq5jHAMOB+c65tqzXLgCGAv8BngN+CRzhnCtqd61KsgDRmDLE/TkU\n", + "kS2B6cDngM2Ax4HLgL+o6sq4zlOuvnz9JZMtmrZ8icaYmBR7P/TeTwMWOOcej56fD6wHXAzMc86t\n", + "9N7/BLjDOfdwRRtdhEpv22WM6QVVnaeqZwNjgQOB14GfA2+JyJ9F5BM1bWA/IJLvPt43vywbY6pL\n", + "RKaIyIzORy9+9SFgXQDv/f7AMOAXwJwoONwF+AzRnEXv/eB4W9471oNoTBkq+TkUkSHA8cDpwC7A\n", + "IsJuJ88D01X1n5U4b5Ft67PXX/6E2s2clWprcarduxeNMSaPUu6H3vtvAJsDZznnPvDejyf0JN7i\n", + "nPul9/5jwA+A651zd8ff6sKsB9GYOhN9O70ceBu4CHgCmKSqmxImMr9HmKNoSpPzW3EqlUKRv3qR\n", + "nKuhjTGmXN578d43AtsA/46CwwmEuYf3AJdHRf8D3Af83Ht/WC3aaj2IxpQh5kUqjjD3cCxhKOJS\n", + "4G+qujqr3F7A7GL2TK6UvrpIBaChYVBHKtWa4/+dMHrUlunPp1feO3j5O0c41Y7qt84Y09eU2IM4\n", + "Hvg7cDNhC76LgCuccx9Erzc45zq89/sBpwL/7ZxbFXPTe2QBojFliDlAXEz49vgnVX2th3KjgCNV\n", + "9fI4zluKvnz9NTYOel+VXHN7Vo1e72OppUsXjTh5s80f3/j1Z/d2qqkc5Ywx5iOl3g+991sAIwGc\n", + "czmnDHnvzwG2dc4d34t6twc+RZiSBCEp963OuZd60z4LEI0pQ8wBYqLe8x926q/Xn8i2suP4TR5/\n", + "4cVHdjts3G7zJs6ZvbXrI/8mxpjaKPd+GG2/tyXwMcL+zClgK2A80AT8X7Grmr333wU+C/yFEBgC\n", + "bEpI0n2dc+4nxbbLcn4ZUz/aRWRPVe2W/0pEJgJP1HJYeSBQnavA7lMmH3vhnY/f9a07E02pc5It\n", + "kLXyWdD2fDu3GGNMLw0GbgTGAH8ibL+3hrBX85+B93tR16nAOOdce+ZB7/3PgBcBCxCN6YN6+gba\n", + "CNicuCqZ9cgNZx6x7/Gzbp/9t9tyrWlJJlsac/yaMcb0WpTi5rOEvZmfds5dX0Z1KcLQ8vys4xtF\n", + "rxXNhpiNKUO5n0MR2ZyQ6kCAB4DTCN/yMrUQkmdPUNVtSz1XnAbK9deQbNGUJdU2xvQgrvthtHDl\n", + "RuB7zrmbSqzjYEKg+Rrw7+jwpsDWwOnOubuKrcsCRGPKEEOAOAM4u4iiq4Evquo1pZ4rTn15FXNv\n", + "5M+ZaAGiMSaIMx7x3m9FmI94v3OupEVy0ZzG3Qg9iUrIofuUc65Xo1AWIBpThhgCxPWB9aOnzwEn\n", + "EhJhZ1oDvKmq3SOVGhko11/eADHRTEeqtd+/f2NMYXHfD7334pyLPTjz3g/tTKNTDJuDaEwNqeo7\n", + "wDvw0T7Mi1V1TW1bZQpJpddw9FFf2f2mm3/7RK3bYozpXyoRHEZeBDYrtnDVA0QRmQocAmxHyP+j\n", + "wDLgZeAuVZ1Z7TYZUysiMhhYraEr/x2gQUTyXpeqWtVEqQOdoO3dFqSooprmttuvfHzq1Pf9/fdf\n", + "PaM2rTPGmK6899/q4eVhvamralvticgoEXmIkDn86OjwG4SVNgngGOA+EXkwSgRszEDwATAp4+ee\n", + "Hitr0cCBrL2jtamjY7V0eaRa5Wxt/++Dtxzf+sADN7hddj74UdJpG242xtSDHxM634ZmPYbRy5iv\n", + "mj2IvwA2AHZX1SdzFYhyvV0dlT2pim0zplZOAeZl/Gz6AKd6iRd5e+ONt7nqshef2DPR0JJKJBLp\n", + "7ExFIqxqb1+9To2aaYwZeP4J3Oyceyr7Be/9F3pTUTUDxMOB6fmCQwBVfUpEvgtcUb1mGVM7mdvl\n", + "1XLrPNN7TvVWL3LQGUOG33pee2q9VKq9WxLzZLJlaC3aZowZsD4P/CfPa5PyHM+paquYRWQp8AVV\n", + "7TG3j4gcTdiLdmSBcgNiFaWpbzFvtXclcC1wj9b5HsB2/a3lRbY9J9H8suVLNGZg6q/3w2oGiJcB\n", + "+wInq2rOPQVFZDJhW5kHVbXH4bb++g9i+paYA8QngQnAUuAmwl6aM7UOc1HZ9ddVQ0OLplIWIBoz\n", + "ENXj/dB7fxthEXBnu5SwZd+TwO+dcwXTplVtkQrwDUJm74dEZLGIzBSRG6PHTBFZDMwGXgW+WcV2\n", + "GVMXVHUSYYP2nxGGAv4OvCUivxKRfWrauBxEZIaITKl1O+pDnr8N9RfbG2MGhjcIixsvAf5AWOS4\n", + "Etgmel5Q1eYgquoK4CAR2ZOuaW4A3iUEh3ep6uPVapMx9UZV5xE2U/+JiGwLTAOOB04TkUWqumlN\n", + "G5hBVWfUug31LpVuY//9Tzxn5syrz6p1W4wxA8pezrmJGc9v9d4/5Zyb6L2fU0wFVc+DqKqPAY9V\n", + "+7zG9DWqOjeamvEh8C3CtkmmDiXQVCLR3G2RShqYNeuGH+6445LD1h21zoRZD95oXYrGmGoY4r3f\n", + "3Dm3AMB7vzkwJHqtqM0Y+vROKtE+tp369Z6wpj5EQ6pTKnyODYFPE3oP9wCWEzZw/0slz2tKt16q\n", + "7aqRsEX2cYXUlI232ulPr/5zlyXD1vugsXGQqtKSXc7S4RhjYvYtYLb3vjON2pbAad77IRSZKabu\n", + "9mIWkT8CCVukYvqCmBepnEYYTt6bMHfkFuA64O+q2h7TOS5R1S/FUI9df0XyIsNXDx3xy2uHbHjS\n", + "m0teyvn/LJls0Y6O1dWcE26MiUm93g+99y3AttHTucUsTMlUjwHia0BSVccWKFeX/yBmYIk5QPwQ\n", + "uI3QU3i3qvbqYi7yHP+OYx6jXX+950U+4aVxZq5Y31Y7G9N39eZ+6L1vAnDOFTXMW6roPF8hZI8B\n", + "mAX8zjlXdGdD3QWIxbI/UKYexBwgDlHVD2OoJ93Dy6qq3ebKlXAOu/5KYOlwjOl/irkfRr15+xCG\n", + "ft8HrnPO3VCpNnnvLyVMI7yCkGbhv4AO59ypxdZRd3MQRaQJGKOqb9a6LcZUUxzBYWQxsKuqvpN5\n", + "UEQEsOuqpiwGNGag8d6PBE4EDiJMG3oVuNR7/4Jzbm6FTjvJOffxjOf3e++f600FVZ3zIiKni8g8\n", + "EWkVkWdF5HM5iu1KyN9jTL8nIu+KyC4ZP/f0eKdQfZHbCLmuuogSbt8TY/NNTNLpFFP2O8aiR2P6\n", + "mWio9wRgJ+B859xlzrmHgYXAqAqeusN7v1VGOz4GdPSmgqr1IIrIZ4BfELYS+xewJ3CZiHwKODFr\n", + "vpXdKM1A8WvgnYyfy6aqX+nhtaKHF0z8cqXDSaOk0u28+OKLKw8//Eu73n77Ja/Uqn3GmNhNBo4A\n", + "znXOzfbeJ4GjCSM9T1XwvN8GZnrvOzvctiDs01y0am619xTwgKp+O+PYVOAaQo/h4ar6nojsATyq\n", + "qj32btoxpV2MAAAgAElEQVQcKFMPBurncKC+73JtJHJ5djqcJhi2TsuQcW+M2jL11jvzh+w9+fCz\n", + "Hph1zY9q1ERjTC/lux967xuAq4CZzrlLoueTgcMJPYi/IqRLxTkXezCWsYpZCauYu0+A7kE15yBu\n", + "C5yZeUBV7xeR3YG7gMdE5OAqtseYuiIiM4HTVPXlHK9tA/xOVfcvo/5hwH6Ea7FzF6NlwMuE/c8/\n", + "KLVuU5zFqtNzHfciu7L4+Tsf+PgBcx986MZzkslmLyKaPZhi+RKN6VMUaGVtYuppwM7R88udc6nM\n", + "wt77lt6mosnmvT+WtXswZ+7FvJX3HufcjcXWVc0exMXA11T1bzleGwXcDnwM+BFwsfUgmr4g5lXM\n", + "aWAPVf1HjtcmAY+XsgJZRBKAB84ABgGrCIEhhEBxcHTsIsBpETcFu/7i50V2Au6ev8Pkv17+wqNf\n", + "Dff2rpLJllRHx+q6W1xozEDW0/3Qe78rcCVhS+HFhG2Fr3XOLc8ocyiwIzAOuMY5V/Jcce/95eS6\n", + "eUScc0UPM1czQLwDWKaqJ+V5fTDwV8I+zQVTcdgfKFMPqhEgikgz8HXg66ra6+32RMQTUit44Lrs\n", + "DAEisinhm60DLlJVV0Sddv1VgBcZD9x7TqJlTCrd2u1LsgWIxtSfQvdD7/0YYDgwP3uY13t/ATAU\n", + "+A/wHPBL4AjnXLeOgmqr5irmK4Ato97CblR1FfAp4I9YKg4zQIiIE5F0Ru7CxzufZxxfDfyUMJel\n", + "FKcC31LVC3Klj1LVf6vqhYQg0hax1JBTnQNMFck7gmK7rRjTxzjn3o7S2Rzlvd+j87j3/nxgXeB3\n", + "wHnOueuBPwFNtWlpV1X7Jqqq1wPXFyjTAZS9DZgxfchdhG+OEFb5/wxYkFVmDfCSqs4u8RwjgNeK\n", + "KPc6a+cmFuS9zzX84J1zM3KUnUHoobTyhcrPmMEPo+OzZs1i1qxZH5XTdFrqvv1W3sr38/IiMgWY\n", + "kuP1Qh4ipPLDe78/MIxw35/jnOuIhqM/A9xRQt2xs51UjClDzEPM04HbVfW9OOrLqPd+IAUck28h\n", + "iogMBW4kbHM5tYg67fqroIaGQZpK5Z6rvvnmE9/aZedJO99082+KzYtpjKmgUu6H3vtvAJsDZznn\n", + "PvDe7wD8H/A359zvvPfNhAWFrc65olNfee8/7Zz7q/d+S+fcvN60KZvNZTGmflwNdJl7KyIHAdsD\n", + "D6nqMyXW+1XgPmCBiNxDWLXcOUF6eFT/QUAbUDA4NJWXK18iACLpDz9YMeKOO699+xOfWOEfeOBq\n", + "X4PmGWNK5L0XQuy1DfBaFBxOBC4gfEm/23t/EHAuYVRnb+/9V5xztxR5iu8T1nPcAOxSTlutB9GY\n", + "MsTcg3gjsFxVT4mef43wjbKNEDgeq6q3lVj3SODLhEVgudLc3EVIo7M8dw3d6lPCopdZqjqrlDaZ\n", + "/MaLzDo+pCTq4u+w9ECR9EPj9l35wItPjIU0CRGQrHQ4aHt7R2tdzGMypr8rsQdxPPB34CbCffl8\n", + "wtDyfoQv6k86537jvZ9MWKT4BefcyiLqvY+winkSYcV0JnXOHVlsG23CszH1ozMnaOe+yd8mpJ4Z\n", + "TFi89f1SK1bVZar6E1XdV1U3UNWm6LGBqu6nqj8tNjjMqHOGBYfVtQyeR3XPfec8eOM31l13uWoH\n", + "qXQbqVRrl4cijbVuqzEmP+fcHGAvwr39eOfc7wi9igcC9zjnfhMVnUQI7AoGh5FDgbOA94ALCfPa\n", + "Mx9Fsx5EY8oQcw9iK3CAqj4sIh8nbEm5jaq+JiL7AzerasWSJIvIIGB0rpXOOcpaD2IF5dpxBWAZ\n", + "zO9Mtu1FBp2TaF6VSnffHCGZbKGjY7XdH42pgjj+DnjvG4EngcuccxdHxyYAxwKPOOfu8N4nnHPp\n", + "nurJqG+0c+5d7/1QAOdcrzdCsDmIxtSPJcBY4GHCnMAFqtq5+ngQ0ZZMFXQYcB1Z8yDzUdUZFW3N\n", + "AJZvx5VMTnX1OQ2DqtAaY0wVbEaYk9gZHE4kDD0PAV4AKDY4jIzx3t9LSKOD9/5d4GTn3AvFVmAB\n", + "ojH146/AeRJ21JgO/DrjtZ2BV6vQBut16gdSqTUcecjnT7j1rsuuqXVbjDFF+QDYzXv/OWAjQmDX\n", + "CPzWOZed+qwYlwBnOOceAPDeT4mO7VVsBTYH0Zj68f8ICVO3BX5LWMXWaSKhd6/XROQBEZlZ6AHM\n", + "oIctmnLU25kPzNSdBLffc83V47aevHD6yd8ZXevWGGN65pxbAhwB7E+Yi3gXcKFz7uUSqxzcGRxG\n", + "9c8i9EYWzeYgGlOGvvA5FJEUMBd4sUDRjYHditnvuS+874GgsaFlTa4FKYK2n7Dljr+58933vr78\n", + "g6WorkmTo0PAVjsbU74474fe++bs7fhKrOdm4GnCPtACnAhMcM4dXWwdNsRsTP83h7ATy7SeConI\n", + "cRTY7cjUl0LBnRc59/Gt93j87lcfH5vr9WSyxVY7G1NHOoND770458rpwTuFsJDwxuj57OhY0awH\n", + "0ZgylPs5FJF3gU+q6j+jn3uiqrp+Cef4PXCIqm5WoNxxwPWqefcBzixr118f0pBsUVvtbExl9Nf7\n", + "ofUgGlNbvwbeyfi5J6V+m7sAuEOiu1gP5e4Atiy2UhGZgaW56Rskz98uVbzIDsBLTjVVTHodY8zA\n", + "YD2IxpRhoH4OB+r77qvy7+0sfHGbXd7b+JVnmoCn7oKtDgnpNrq4Hh6cozql4g01pg/qr/dDW8Vs\n", + "TB0Tke1F5CgR2ajWbTH9j5Dkj6/OWe/STXbi3Z32vofSe6mNMf2M9SAaU4aYd1K5BEir6pej59OA\n", + "qwlf5D4gzCN8JI5zlct2UulbelrtvOdex0yYN+/F+xYvfnl9kfBh6/aBFlJrOlptSpIxOdRTPOK9\n", + "/2XGU6Xr5azOua8VW5f1IBpTPw6i6+bq5wDXEtLP3AP8by0alY/txdx3tHe0NnV0rJbsR3tHa9ND\n", + "D13z/MKF/9pgrz2P/EI6vYaOdBvtWY80UtTuOsaYmns6ejQDuwKvEDZZ2BnoVUor60E0pgwx9yCu\n", + "Jqxoni0i2wAvAzup6vMi8kngOlUdGce5ymXXX/+Ub7VzQ7KZH6baTnaqf65Bs4ypa/V4P/TePwHs\n", + "7Zxrj543Ag8753Yvtg7rQTSmfiwFxkQ/TwWWqOrz0XOhyD2SjSlZmDrQjSoK/K8XOctLviXRxpg6\n", + "MgJYJ+P5sOhY0WxOiTH14y7Ai8j6wHfomrR6PDC/Fo0yA0qaHF9EUuk2uW/3I17f/4nbjkrAFl7k\n", + "y061vQbtq3uWKsjUiZ8Cz3jvHyB0MOxH2E61aDbEbEwZYh5iHgFcBEwC/gWcrqorotceBh5V1e/E\n", + "ca5y2SKV/qmhYVBHKtXaLUAUadLGxiG0NA9NHT9m9NwXXn1m5AcwLw2pzHL9OQjqaaFP5o42TQ0t\n", + "HWiO3n5b6NNv1Ws84r3fENidsFjlH865t3rz+xYgGlOGgfo5HKjvu79rbBz0viqDs4+LsGrvycds\n", + "8PaSxQ/PnfvYrpAmKYkBtdo5Xy7JzN1ovEjDOcmW9kLlwHoa+5N6vB967+93zk0tdKwn/fJCNqYv\n", + "E5FxwARgU+AyVX1LRLYizElcWdvWmf6svX31OgWKTPjkgdP3/vt9V83uyDHCnEy29Ll5suUGaqlU\n", + "O1tuNL4tgSQTG45Lpt6am6ek4kWuBp4Cnnov2XzSe7l7GvcGCp7X9D3e+6RzLlW4ZFnnGAQMBkZ7\n", + "70dlvLQOISNG0SxANKZOiMhQ4DLgWKCdcH3eDbwFnAu8CZxZswYaA9z798sfbmi4jlSqon/nqqan\n", + "QM2L/OLVbSacMieVmJZKdV/dHYolGDFyg8UpEh1pkQ7eemW7XOVSqTYu3XD8EWOHDZ28/dJFreml\n", + "7ybz7I/d54Js0zPv/WbOuTedc6kqBIn/DXwd2IiQ7qbTSuBXvanIhpiNKUMFEmUfCvwX8AjQCkxU\n", + "1WdEZDrwbVUdH8e5ymXX38CWd7g10cxZ6bbDgLudarr6Leu9/NsQJmluHsaaNW1sMmbr1kVvv9yS\n", + "1jXdS2UNHeerL5FoYvvt9335rbcWjF22bGGz6uqc7Ukmmzkr1bYX8A+nmgIbjq53he6H3vvbgVec\n", + "c2dEz6vRk/g159wvyqnDAkRjyhBzgPge8A1VvUpEGoA1rA0Q9wduVdWhcZyrXHb9DWz5gyo4YJs9\n", + "V+71ymOLE3Ax8Offw6/rObjpKUDcb7/PXLzRhlv8v2uu/dHqYuYgRvWlU6nWbtdGMtmiHR2rEwAz\n", + "3NXJc370hY50jh7EhDTxA13zQhLWB+4EbvsrfPPTsHd2Wdsjuz4UESA2ArcALzrnzoyONTnnun/j\n", + "KJP3fhKwsHNBivf+ZMKo1HxghnNuabF1WYBoTBliDhA/BI5V1btzBIifAv6sqsPjOFe57Pob2PIF\n", + "QQlporFpmDY2NKeP22D0C1vMe3aTu2DVIWE+bRe1Dm68yCbAjHMSzV/IM9TbJfArdhVzTwt9Mud4\n", + "9hRkJ5OD2XTj7d7ZdZ1BT45/4ZHG85JNn8x5ufXjRUF9SU/3Q+99g3OuIwoSbwVecM59O+P1iUAL\n", + "0O6ce6Lctnjv/wlMdc4t9d7vC1wHnA7sAmznnDuu2LosUbYx9eMp4OQ8rx0LPFrFthQkIjNEZEqt\n", + "22GqT4QPksmWVPYjkUysPOiTxw4au+W4Z6944+WdLt9sQvqZZPMmP040k/14NdncrUesGrzISC9y\n", + "Xkdj87O3b7vXkbmCw1x62q6wS7n21et0dKxuyH7kWACUs3cmmWzRqft/5ruJhuY1t778wmHnJod8\n", + "ck0q1W37Q9sCsW+IgsNktKPJkcBe3vvvA3jvfwucTbjvX+29PzSGUyYyegmnAb93zt3gnPshsHWv\n", + "KoqhMcaYePwQOEZE7gdOjY4dKiJXAccDrmYty8H2Yh64egqCbrn1923PPff3CUce8fl9W9e0trSn\n", + "2qQWwc1GIpePF5nV+dhB5KHdRF6/D956csd9jztPm0a98tai4YlEc75htIoOr+ULskX44J57Lz3/\n", + "9dcf3fQH3/914hNTPv1duicU+qiJPmQ4MHUsY3FKu3NuMvBYNC9xIjDdOfdFwv39lKinsRzJjDoO\n", + "AB7IeK1Xvc3WNW1MnYj2YN6fkAH/l9FhDzwOTFXVf9Ssccb00s23/HY2sE4y0ay5FndUOP7KuTo5\n", + "jZJKd9D48nNjd51w4JVPPNF+ckPDkhUiLTmHhCvZviJSCjHDn6hw4vkNDX85L5Xq6PZ6OpXi/fU3\n", + "fcqL3AOc96Nk8+PFDIOb6ouCRHHOKWFEaKRzblJGEQWe7tw7uQzXAg96798DVgGzAbz3WwPLe1OR\n", + "BYjG1AERaQaOA55U1X1EZDAwEliuqh/WtnXGlE4Siaz9VqLjgBc5BbjMVWAyfBpJptLd5/gJjUze\n", + "65jhD8y6tDOnaMFArQ4oOboRFeWid5YMHzF802N332jTI3Xu04253nMy2VJur5SJgXNOvffjCPkI\n", + "j+08Hu148j3gghjO8WPv/UxgDHCvc64zm4AAX+1NXbZIxZgyxPU5FBEBVgMHqeqD5bessuz6M8XK\n", + "t6AFEpw4dsdFW7/x7AvAF53qv+M6pxeRc5It6WJWHfcF+bZATCZbUrvtdvzmq1e99/t5b7x4wPvv\n", + "z2/O9fu2i0tl9eZ+GC1K+bZzblr0fEPC/PJrnXPfr2Aze816EI2pA6qqIvI8sA1Q9wGiMb2Qhu6J\n", + "qEWSXLvg1Y2HD99izJEjhr7U1NDSkmteYm+HR2cMHrzBK+P3eiw15/Eym10/RFiVTOYeBn/00SsW\n", + "AYdDWOCSK3UOqniR+wiJk58ZDdsfA7tlF7s+9pabHP4DfNx7/z3gPeB/gGuccz+Atauea9nATtaD\n", + "aEwZYk5zMxm4AvgmcJeq1sVNIhe7/kyxekr7cuwxX9r6xZdevHvOnEd3TqdbCbFkV93SzeSvr3XC\n", + "9nsuevaVf23TkUrR0bEK6H4J9cUexGL1lDpn67ETV0wes+6zY5+8f+mPNXGUpc2JT2/vh977HYBv\n", + "EwL2Jc6566LjXYJD7/10QkfePOfczHhbXZgFiMaUIeYA8V3CHpqDCHOOltF1Jr+q6vpxnKtcdv2Z\n", + "OH1m2tc3uP7637ytuQK6RDMnnHDqoD9f+atWyD/cCrDu8C10h823vn056x39wpyb2gslrO5vetrF\n", + "ZZONd35j0eKXtxBJS0dHKwMteI5TlN5rSsYh19v7ofc+kTE/MDNfYgKYRJiTPhX4EzADONY5V9XR\n", + "JQsQjSlDzAHijAJFVFV9HOcql11/Jm499X6BkEwOpqVlndSHHy5J5uppTCSaOTvdNtypvg/FJ6zu\n", + "Twol8xaZmNhxx42+8fzzd/4s18qhZLKFs1KtzU5zLjs3eZRzP/TejwR2dc7dHz2fRMhfqMBPooTX\n", + "ZwKNwHmARiuhK866ko2pE6o6o9Zt6I0ooJ1luRBNJSWTLZzZkLxyxcgNjnh3yCi9cd57I3Nt8ywi\n", + "dAaHUFwamf6m0FxN1afSwEUNDYN+lkp1DxBTqXYW7DZ1yUUTJk0/4+knbxmIQXYNrAMcCNwfPT+e\n", + "sOL4HOfcCu/9FsAngD8659Le+yQ58wLEr+o9iCIyFTgE2I6QxqNzKO1lwryrosbZrQfD1IOB+jkc\n", + "qO/bVE6hvY69SALY9Zxk85OpVOGt8Ux++VeWN9DUNELb29+XzTbaJvXm4rlJ1e5p+frzMH0p4rof\n", + "eu+nAWcB+0Y9h6OBgwnb5F0IrAC+AjxZjeHmqv0Di8goEXkI+DtwdHT4DcIG0gngGOA+EXlQREZV\n", + "q13GGGNqT9D2ZLKF7IcQIhSnmnaqT+XfVcT0QvcuWCCZbEi1tb2b2Gb9iUeuQ/MS1bwdVV3+EbJ3\n", + "rel8bCRyecztHghuioLDsYTOtH2Bp5xziwmdau8Cf/DeH1LphlStBzHaLmwScJKqPpmnzETgakKy\n", + "4JMK1Gc9GKbm6vFzKCJDge8QErFuGh1eCNwAnK+qK/P9bi/OUXfv2wwMTQ0tHWj3tDm2Ard4xQ4d\n", + "558XmuSow0548KgjD/jxyaeedH9T0+A1A/nfJMYexO2Ah4DLCfHS04Tg8C/R68loR5bJwEXAcc65\n", + "2PKHZqtmgLgcmK6qNxcodxRwhaoOL1DO/kCZmqvHz6GI3EKYsnEp0Hnz2Az4ArCdqh4Zwznq7n2b\n", + "gWG8yKzjYb/s49fDg3NUp9SgSf1W/gCxgaGD1ueD1e8wfJ31WfH+OwzkVdFx3g+999sAnwTmEYLD\n", + "d3KU2QX4BvBl59zqOM6bSzUj+zTFjQ0Iebq/jTFF2V5VP5V1bC7wHRF5pRYNMiYuy2B+roTOy8J0\n", + "JVMFyWQDK1ctkkGy84Yjhww6e8X7S76cq5wA5zQ1nZJub7/Tqb5daJV1xRveBzjnXvHevxptyzfU\n", + "ez8U2BAYSpiOtx+wHiEibyTswFUR1exBvIwwln6yqj6cp8xk4M/Ag6p6SoH6rAfD1FzMaW7SwB6q\n", + "+o8cr00EnlDVnPnfsso+A3xfVe/OOn4I8GNV3TWGttr1Z0w/V+xwfk8pikYM34StNtlCd9xgvff/\n", + "/ODdw4vZ/rCvbQUY9/3Qey+E3YfuAHYFZgJbEtZtfEjYbWumc+7NuM6ZSzUDxOGEnXwOBN4mDIEt\n", + "j14eQVjVPAa4F5imqisK1Gd/oEzNVTFA3JOQUibnXqtZZXcAfke4wS6MDm9C6GH5iqo+H0Nb7foz\n", + "pp8rNlDLn6C7mXXX3flCWH3kyvffGdva9na33kP4KP/iYcBbwFs/TjYv7EtzGit1P/TejwOuBC50\n", + "zl2b43WpZE7EWqS52ZOuaW4AlrI2zU1RG2jaHyhTD8r9HIrI5sDmhNGYB4DTgBezirUA04EJqrpt\n", + "L+regBAYCrBQVd8utZ056rbrzxgD5E+bk50OpyHZoqlce0UjbL/NpNQ2Y8Z0jB/SkD7/3jsHdRTR\n", + "0zhxwoTLt9xyyy2yy82bN2/+U08/Pb3U99Nblbwfeu/HE4LE/3PO/Tk61mUXlkqxnVSMKUMMAeIM\n", + "4Owiiq4Gvqiq15R6rjjZ9WeM6VTuqmiRJtZbb/wjra0rxq1atXR4KrU8Zwq+hmQLF2/3sXGnvfDC\n", + "SwCDBw9b3dTY3JJdbk17W+uqVSsHlfJeShnervT90Hu/PaGTwDvnVlXqPNksQDSmDDEEiOsDnfsr\n", + "PwecCGQPAa8B3lTVfPuQFXuuYYQJztuytve+M0n9g6r6QS/qsuvPGNMrhZKhf1Qub08jDB++MWNG\n", + "b6ibbLTxigcevmtEOt19V8BcibyLDWJLWSVfjfth517NlTxHtroLEEXkj0CimEUqQOa+tLblV8yi\n", + "/8emgBjnIG4BLNaY90GVsAOFB84ABgGrCIEhhEBxcHTsIsKm8wX/3S1ANMb0VrGrmHua09iU/NjZ\n", + "o4dw7JpU27ZLVs5rCZuxZdUnjZx22rfv3XXncU8efsQBD68/evSrDU1D5qZSrd3mNSaTLamOjtUf\n", + "zWssJc9mf70f1mOA+BqQVNWxBcr1y3+QvmjkyM+mly//UOBuoPu2TDW0TFUruitPJT6HItIMbEyY\n", + "e9iFqmbPTyymPg98ixAkXqeqb2a9vilhc3gHXKSqrog67fozxlRE0XMaG1o017aLkKSpab017WtW\n", + "NimtNDYOob39A3IFkw0NLbryncV73nrqqaPn3nbbBJ9OzMi9lWMzHR1r25TZI5lKtSb74/2w7gLE\n", + "YtkfqPriRdTF8e+RTi8dtd5JI5ctKzjauUz11h6DPxFZytqh1F4r5vMV8yrmjYFLCIu48jSpcJqb\n", + "HPUuAv5XVX9foNyXCD2IGxdRp11/xpiKKHdOYzLZzFmpthUKT7zD4OcfYeSHz/PO2ZqnAyORaGbQ\n", + "oHUYMXw9Fi1+Bei+xWBDQwtXHX7wnc3Dhl034UtfunXslAOXZgax/fF+WHfLxc3A1cuAbmSMQ+AV\n", + "72ks0h8IOa++CbxEmHsYhxHAa0WUe50yAmpjjIlDZhDYk3Q6reTYgCOdVgW2EdhjA1bteQyr9nsx\n", + "2UxHjq2lk4lmNkxvdsTCD5ObtLXpeJDTc52ro6OVE26989CmpiGHDrnzIVKpWGcC1aVapLmJZaK8\n", + "9WD0nkhTGtrr+P9ZI3BwTwUK9hpWW8w9iCuAL6nqdXHUl1Hv/YSvxMfku76i/ZtvJEzvmFpEnTYH\n", + "2BhTU43SsDqZYypOClrbtaPLKuaiF8jkGd5OJJo1nR63F7RtO4LVE5ez8PTMKVX9MR6pZqLsWCfK\n", + "VzNA9CJLv/PuuyOHrL8xMa8fqCqRJj58ZxHnjx5dieqXufrohauqmAPE14BvquptcdSXUe844D6g\n", + "GbiHrknqhwPbAwcBbcBUVX2piDrtC5oxpqZ6k5KmF7vCdBSzmCU74OyP98NqBoixTpSv+B+odHpp\n", + "omHQyMyAUKSJdMdqSCT63QfBlCbmAPEEQqLswwrtJFRC3SOBLxPmN+bqvb8L+J2qLs9dQ7f6OnsQ\n", + "refQGFP3ik1fU+r8RwsQyzlRzBPlqxUgAiEoDJaRSAy4XjKTX8wB4l+B3YFhwJOs7eWDMM9GVfX4\n", + "OM5VLutBNMb0JXHv75zZI9mebuuXAWI1F6n0rYnyicSodLoNkaZ0omGQZASJxlTKaMLnX4Am1ibQ\n", + "7pyIXdFvcyIyCBid3btvjDF9XSlBYE/WS7Vd1RlwvpijZ7I/qGYPYqwT5avWg5FOa6JhUNbcw0ZV\n", + "XZNzKyAzsPSnnjQROY4w/aNgKh0bYjbGmKDYvwPe+6RzLsda6vpUzSDnq8AOwAIRuUZEzhaRr0WP\n", + "s0TkGmBBVCbnMvOaSCTE6RpUVTSVWqapFBKoiGgi0ayk052PpbVurukfos/YRiLddx2o9KmLLaiq\n", + "Myw4NMaYnnnvNwNwzqW8973OZVsrVU1zE+dE+SqvYu6WBHptypiM3sR0Wm0By8AS9+dQRA4jLNTa\n", + "GUgCk1T1GRH5AyEN1FUl1PkAxQ1Prw9sX2wPYn/pOTXGmHIUuh96728HXnHOnRE97xM9iVUdJlXV\n", + "Zar6E1XdV1U3UNWm6LGBqu6nqj8tdhVlrYg0paPeQ9FUCk21ykc9iGvT9hjTayLyOeAWQpLsL9K1\n", + "N+9V4AslVr0vMAZYWuCxspftnSEiU0pskzHGDBRHA9t57y+Ej3oSmwr8Ts3ZVnuZwhDxSIDu8w47\n", + "z9vUuarZVjSbuFcxzwVuUtXviUgDYSeViVEP4mHAZaq6fs+15Kz3OeAlVZ1WoNxxwPWqWvCLo/Ug\n", + "GmNM0NP90Hvf4Jzr8N43ArcCLzjnvp3x+kRCsu9259wT1WlxcWyhRafO+YOJhJBIiHbOO1SVGfDR\n", + "z+l0m0RlLDg0cdscuDfPa61AUdtP5fAYsGeJv2uMMaZEUXCYdM61A0cCe3nvvw/gvf8tcDZwMnC1\n", + "9/7QGja1GwsQuxrZOVws0kQYSm5K17pRZsBYSNiLOZcJFJcmKpcLgNNFpFCP3x3AlsVWakPMxhhT\n", + "WOfiFOdcu3NuMvBYNC9xIjDdOfdFwtzzU6KexrpgAWKnRGJUZ+8hiYSkO1Z/tGJ5BpBj1bKtWDZx\n", + "+yPgROQkwnaUAAkROQD4DvCHUipV1ddU9dZC21eq6mpVnd+Lem0VszHGFCEKEju/pB8LjHTOTXLO\n", + "dcYSCjwd9TTWhWomyu5boiHkdLoNL/LR3MQZmkaSSaLnmjEnsZvVS5dWat/jejQg92KO2fnApsAV\n", + "QGfP9aOE1cy/U9WLa9UwY4wx5XHOqfd+HLAxIUgEwHu/IfA9wmhP3bAAsQiZgU/2BtEiTWlJJnMM\n", + "3TWqplqXu1Sqp11h+s1CFx8SJ5syqGoa+B8R+TkwFViPsLp4pqrOrWnjjDHGxGEwsMY59zZ8FBw+\n", + "ClzrnLuypi3LYgFimfLtqBIFjj1uGSjSNDLdsbpQYNVvgkiTX7TN3QrgeFW9mdLnG1ZNNPvCdlIx\n", + "xpji/Qf4uPf+e8B7wP8A1zjnfgBrVz3XsoGdLM1NDa1Ntt1jmbxD2BlqHkTmSiY+EMSc5mYh8GVV\n", + "vQJX/4kAACAASURBVD2O+iqpP1x/xhgTh97eD733OwDfBp4GljjnrouOdwkOvffTCR1585xzM+Nt\n", + "dWEWINa5IoLIZZpKwdpdabq9Xo3g0QLEWOo6C9gHOFxzJeGsIwPl+jPGmGxR9oYpGYdcb++H3vuE\n", + "cy6d8bwzX2ICmAQcR5hq9CdgBnCsc+7BMpveKxYg9mEiRy6Fu0dCrkVP0RaAGcm/M8QeNFqAGEtd\n", + "FwInEFaz3Q8sIWuLPFX9ThznKpddf8YYE5RzP/TejwR2dc7dHz2fBEwj3Pt/4pxb6r0/E2gEfuqc\n", + "q1rQZnMQ+zDVW/MGeZ1bAnY9mhE0hq0BM9V8mNpwHNBG2GJvn6zXhHDDqIsA0RhjTCzWAQ4kdAoA\n", + "HE+435/jnFvhvd8C+ARwSTWDQ7AexAElz3D1MlUdlaOnsVcBo/UgDizRlw+PLVIxxgxwcf0d8N5P\n", + "A84C9o16DkcDBxM2ULgYWABI5tB0JVkP4gCSveK6c4g6q6dxbcC4tpfRehdNN6o6o9ZtMMaYfuam\n", + "KDjcEtibMNfxbufc/Oh19d6vAwxyzi2pZEOsB9F8JMecxuzexbyBovUgxlafEG4KWxM2cO9CVX8T\n", + "17nKYdefMcYEMfYgbgc8BFxOWKjyFDALuA/YDPgM8C5wGHAAsJ9z7h/lnjcf60E0H8mc0yhypMJt\n", + "Yci5MyjsPm/RxEhENgBmAtv3UKwuAkRjjDHxcs697L3fm7VzEp8FPkZIh3MZYYetu4HTgduAf1Wy\n", + "PRYgmnyWQWPm8PMyTaWWRUGiDTlXxs8IybI3Bf4N7EFYyXwi8Dng8No1zRhjTKU5514BXul87r3f\n", + "ijCi9Dfn3ALv/VXA68DnnHNrstPlxCnnLiDGqN46SnWNwBHLwoOwB3UiEbrRw7Czidd+wIXA250H\n", + "VHWBqp4LXI31HhpjzIARBX8PA58CZnrvHwGSwGedc63e+4ouWPn/7N13nFTl9fjxz5mZLVRZRLGL\n", + "CoIoFsTesMWOsUYTW4yJ0RiT2GK/XLHGnyaW2L5q1KhRrMEWFSP2CmosgKCioGLbRcqybeb8/nju\n", + "wjA7s3tnd9rOnvfrNa+de+8zd547uzN75innsQDRtGt5t/MBgBtrIdEoZE7MbTpvAPC9qsaBhcCq\n", + "ScdeBbYvSq0yEJHxQcJYY4wxeeJ53n+Ar4HtcOlu6oPgMK/DvjJ2MYvIlaQk6Q3pGlX9svNVMqVG\n", + "ddJAkXHLBuG2za9ocuQzYK3g/kfAUUDrsnv7AyXVamuzmI0xJn9aWwd9378HWIDLldsUHMv7/+H2\n", + "xiCejuvqagx5LsGNnboPsACx/NSJjKttLzm36bIncYOT7wUmAJOC9ZlbcDPY/lzEuhljjCmOs4Hv\n", + "PM9rKOSTZkxzIyIJYDtVfSPUiURiuMh2jKpOy10VMz6fpdkoMNeKOElEpLampqamtrZ22etvaW7y\n", + "cu6tgIOAXsAzqvpUPp6nM+z9Z4wxTqE+DwvRrZysvRbEu3D5dsKKB4/5oUs1MiVPVQdaN3P+qepb\n", + "wFvFrocxxpjiK/RSexkDRFU9LpsTqWuKzOoxxpi2RGQvXJLU1XEDk99U1WeKWytjjDE9ieVBNFmr\n", + "qalJDBgwwFoQc0xE1gAeBcYA3wa3wcAqIjIV+KlNADPGGFMIoQNEEVkTl+tkDdIvAXZWDutlStiC\n", + "BQvExp/lxS3AasCOqvpq604R2QE3+esW3BJLxhhjTF6FChBF5Ajc+EJw4xKbkg/j0uFYgFjG3DrN\n", + "1AUTVIpdnXK1G/Cr5OAQQFVfEZE/A7cWp1rGGGN6mrAtiJcADwK/VdWFeayPKV01wQxmrf3++2LX\n", + "pVx9CyzNcGwp2U0ayzsRGQ9MUdUpRa6KMcaYHAsbIA4CbrPgsGcTkdpg7OGCYtelTF0K+CLytqrO\n", + "a90pImsDfnC8ZFiibGOMKV9hA8RHgbHAc/mriilVrnv5PzpgwIABdT/8sIBIxJJl58eewMrAJyIy\n", + "jeWTVEbjWg93F5HdCYZ1qOrhRaupMcaYshZ2LeZTgFEicquI/FxE9k295bOSpuhqoFnqfvhBLDjM\n", + "q1WAWcBruBWMVgIacOswzwqOJ9+yJiK35KSmxhhjsuL7frTYdchGxpVUVigkMho3BnFIhiKqqgW9\n", + "cFvJoTBExtWKPF0zYEAfar//vi5TgGgrqXQPIjJXVdfOwXm61XUbY0y+dPR56Pv+Op7nfRHcj3qe\n", + "Fy9c7TovbAvibcBCXIqNEcD6KbcN8lI7UwpqVJuora211sNuQkQSmW64NFXGGGMK5wbf968G8Dwv\n", + "3l1aEsMGiMOBs1X1KVX9WFXnpN6yeVIR6SciW4rIHsFtSxHpl3XtTd64lsNxKvI0lhS7cERkUxH5\n", + "l4h8IiL1IjJbRO4Vkc2yOM1XwGqqGkm+AdHgmDHGmMI5CBjh+/7/g2VBYmWR69ShsAHim0AuuqX2\n", + "FJGXgDrcGrPPBLe3cDn2XhSRPbr6PCYnalQniWoTdXV1Yf9OTBeIyE+BqcDmwAPABcBDuEkqb4nI\n", + "QSFP9RiwYerOYDnMp3NTW2OMMR3xfT/meV4zcCCwse/7VwJ4ntcUHB/j+/6Ovu9vU8x6phN2DOIW\n", + "wJ3AlbiZzG3SnKhqfQfnOBz4F/Af4H5gOi5QBKjBdV3/DNgHOFJVJ3ZwPhsDlSet4w5VmxgwYICG\n", + "CRBtDGJOzjUTeB84TJPemCISASYCo1R1eCfPvZ2qvpaLegbns/efMcYQagxiNGg1rACmAE94nnep\n", + "7/s3AmsC3wC7Aqd6nvdkQSodQtgAMdFBkQ4nqYjIh8ATHS3JJyJ/AfZX1ZEdlLN/UHkiMk7hMbJ5\n", + "fS1AzMm56oGDVLVNK5+I7A08oqq9Onnud1R1i67WMel89v4zxhjCfR4mT07xfX9X4HRcGrO9PM+r\n", + "9X3/F7iu6CODFseiC5sH8fgcPNf6wBMhyj0JnJqD5zNZCvId1kCzjTssjqnAxqTvBt44OG6MMaab\n", + "CVoQxfM8BQ4BajzP2yqpiAJTSyU4hJABoqre0d5xEakIcZrZuOj4hQ7KHYjL+WYKrwaa0XgcIhEb\n", + "d1h4fwLuF5FK4BFcouxVgYOBXwFHiEjv1sIdDetIcX0uK1quRGRsOS4daNfVvdh1lSfP89T3/ZG4\n", + "buVDWvf7vr86cDZuGF/JCBUgisjFqnp+hmO9cAPpO0qWfT7woIhsghtPNYPlYxlXAjYCDsOt2HJo\n", + "mHqZ3EhuOaypqYHlY0NNYb0Z/LyU9MvqvZl0X3GzkkNR1du6UK+eZCxujFC5GYtdV3cyFruuctUb\n", + "aPI8bz4sCw5fBf7led4/i1qzFGFbif4gIuel7gxS0/wH1/3VLlX9N24QZhy4DvdH8m5weyHYFwfG\n", + "BmVN4biWQ1WxfIdFdXwWt19le/IgvdT+InK6iFwc3E4Xkf1EpG9nKiwiYzu6H2Y7074wxzpTLpvz\n", + "2HXZdYU51ply2ZzHrqv0ryukH4BNfd8/2/f9E3DD6u71PO9ccLOeC1iXdoUNEMcB54rIaa07RGQg\n", + "8F9c4t2dwpxEVV9W1b2A/sAmweN2Cu73V9W9VfWVLOpvusDNVq5UeMzGHJYAVb2jvRtwT8p2KCIS\n", + "EZEJwHxgEuADxwY3H5cWZ76IXCQi2U48GRvifpjtTPvCHOtMuWzOk+l+mO1M+8Ic60y5bM6T6X6Y\n", + "7Uz7whzrTLlszpPpfpjtTPvCHOtMuWzOk+l+mO1M+8Ic60y5bM6T6X6Y7Uz7whzrTLku8zzvM1xv\n", + "6Ua41sTLPc87D5alxGlpLev7/nG+75/g+/5uhapfslCzmAFEZC/gUeC04OczwaE9VXV+fqrXbn1s\n", + "FmUXdWa2ciY2izlv548AuwFH4mY4Z926KyI+bsacD9yvql+kHF8bl2LKA65WVS/EOe0LhTHGBLL9\n", + "P+D7fsTzvETSdszzvBbf9yPAVrihdrsDtwPjgUM8z+toDkdOhQ4QAURkHG784A+4FRn2UtXanFbI\n", + "/bOS1H9iacpZgNhFFiB2Xb7+DkVkO1xQeBguFcIPwERV/V0nzvUlcJGq3txBud8Anqqu2YkqG2OM\n", + "yZLv+zXAaM/zngu2t8J9YVfgsiAFzhlABa61sWBfzjP2dYtIukknLcC9uC7nq4BtW3ukVDVXyR0/\n", + "A4QsBuCb7Fg6m9IkIpvigsIjgHWBRqAK12p/vaq2tPPw9gzAZRHoyCe4pPXGGGMKoz+wJ24REoDD\n", + "cTHQBM/zfvR9fwhu/sb/FTI4hPZnMT/ewWPvTbqf1YzKDhyPe3FM/iyblFLsivR0IrIBLig8Ejcm\n", + "5UdcvtDTgdeBecC0LgSHBOf5s4i8oaqLM9SjL/BnIGerrRhjjGmf53mf41Lc4Pt+62pyOwfB4Sq4\n", + "eRqfAC+3Psb3/YpC5EtsL0BcP99Pno6q3hW2rIiMT9qcUg75lXyRWvLUijOeGK4RGGoGDMDP7Tiy\n", + "HpEaJ5jtNjaHp5wFLMV94ToDmKyqzcFzDcjRc/wemAx8LiJPkz7F1F64Fsvdc/ScxhhjsvdI0K28\n", + "Hi443BW3TPFS3/d/DmwKVPm+/4zneU/lsyJZjUEsJeU6BjGfY/lERIMk2GX3uhVLV/8OReQzXHfy\n", + "bOBh4GFVfTM4NgCoxaV+erGL9awBfov7djqc5V9C6nAB41PATaraZp31TjzXC7jAMwJ8CvxSVbv1\n", + "F4hgbPQdwOpAArds6J+LWqkcEZEbgQOANVS1bBLkBzl37wL6AtOBX2RqQe9uyvh3Vpbvs7Cfib7v\n", + "jwBexL0GWwHv4XpzX8PN//gAmAl8D1wLHO953n/zVe+Mf1gi0j+YQRlaR48RkT4icoyI/FlEDhKR\n", + "Nt3SIrK+iNyezfOa9kUiVSoi6hbo6Bktfd2Fqq4H7IDLJ3oc8LqIzBWR68hhS6Wq1qnqZaq6s6oO\n", + "VtXK4DZYVXdR1ctzERwG9lfVzVV1U1zXSLvrr3cTzcCZwRrxWwDbiMjBRa5TrtwDjC52JfLgJuBc\n", + "Vd0Q9yWoHP4OW5Xr76xc32ehPhM9z5sB7Ah8DlwBnAO8AdwPrIWbrPis53mTgBOBHX3fr8xXpTO2\n", + "IIpIAti2tTWjwxOJxIAmYIyqTktzvDVb+LpAPS7/z8fA0ar6VlK5bYFXO/pWZC2I4ZXra1UKcvna\n", + "Bl+YdsWNRzwY940TXPfzNcnvk3wQtyrSKh1lEMjifBHgRmCmql6di3OWChG5FpitqtcWuy65IiKJ\n", + "cmmNEpHBwFRVXSvY3hB4RFU7XNShOymn31k65fY+y/Yz0ff9KG6S4pq4xUXWwM3T+EnQDd3b87xs\n", + "llzNSkcZu3cQkUEhz9XRJJXLgAZguKrOCmZsXgO8ICLHquoDIZ/HmLKkqnHcWMHJInISrjv4SNwa\n", + "5j8XkY9VdUQeq7Af7ptqlyeciciTwBjcGMtTu3q+UiIiKwM/xc08NKVpLdwEr1ZzgbWLVBfTCeX2\n", + "PuvMZ6LneXHf9/sD//Y873kA3/e3xmW3IJ/BIXS8kspVuP7vMLeOlsfbDRivqrMAVPV/uAHx1wH3\n", + "Ja/SYrpuebfysq5l042oapOq/ltVjwBWBY7CtbjnhYgMBX4DREQkLiLPZyg3UkSeE5ElIvKliPjp\n", + "hpWo6r7AariZd9fkq94dEZGhInKziPwvF9clIlXAg8BfVXVmvuufSa6vq1Tk8LpKosekXH9PkN9r\n", + "K9b7LJ/X1JnPRN/3+wKbA+sE28cAP8nmmroiH7OYv8ywfyBuqa9lVDWBS7/xOXCtiKyFG4hpuki1\n", + "ydLYlAlVXYLrZr63o7LpBB9yHc1GGwSMCMrNTFde3ESXybiB0uOAobgvkRHggjT1TojIXcB9nal3\n", + "jozEtcS+hvu86/R1BUMA7sF1Xf417zVvX86uq8Tk6rrm4VoRW63Dii2KhZKT6xGRXwGnBA85WVVL\n", + "IR1VPq7tJOAtivc+y+vvK9vPRM/zFvu+fzbwsO/7O+MmJh3ped7XqSux5IWqFuSGezHPauf4Ibh0\n", + "H+8A8RDn00LVvZC38Tm6rnJ9fUrt1h1eZyAOfIT7Rt7e7bWg7IPAf9Oc5xzcIOm+SfvOBJYA/YLt\n", + "AcDgpOMXAv8o4rVL0v1OX1ew71bg9mL/PnN9Xa3nAxLldF24lpp9gvt/ASZ05+tJd+5i/s7ydW3F\n", + "fJ/l45py8Zk4fvz4NcePH7/x+PHj1wm2JZvHd/r1KOALfxWu7z3STpmxuPxsHf7R0w3+MXfmNr4r\n", + "1xWP14pUKqAilWX5+pTarTv8HQL/w63B3FG5Q3GpJTJ9ML4I3Juyb53gMfsH2+sBb+LSM7wH3A0M\n", + "LPZrENStM9e1X7C9Q7D9Hu5L7DvAKcW+pi5c1/5J+27FjdGLBz9vKfY15ei6RgHTcEMzJrUXbHWH\n", + "60k5XlK/s1xdWym9z3J4TTn9TBw/fnzGGCrXt44mqeTSVcDzQD/cahFtqOoUcWvQbl3AepWTGuta\n", + "Nmm8hus26arhuK6VZVT1CxGpD449rqqf0f3ev+1d1whcLrZX6HjMdqnp8PcV7DuhCHXrirDX9T7d\n", + "IxVMqOtJOd5dfmdZXVs3eZ9le005/UzMe7dykoL9IlT1K1V9XFVXCA5FJCoi/xWRYUG56ap6Z6Hq\n", + "VRYSidpIpEolGgUqumfmc5NPVwKniEhHXxyeoP2xxzUsX4ElWR3dew1nu67updyuq9yuJ1k5Xls5\n", + "XlNahWxBzERwXcv9ilyP7sxaDk1Gqjobt1JLR+WWAnM6jiONMcaUu1JvyjXGlI46lifvTlZD916h\n", + "x66reym36yq360lWjtdWjteUVugWRBFZE9gfl9G7OvW4qpbTMkalL5GoBWoisV6oNmFdy6YAZgAb\n", + "Je8Qt3Zq7+BYd2XX1b2U23WV2/UkK8drK8drSitUgCgiB+Hy9kSAb3FL6i07jMsV1KkAUVVbRGQ3\n", + "8pgEuEzVEImIy6dsXcumIJ4CzhSRvqq6ONj3M9zSmS8Ur1pdZtfVvZTbdZXb9SQrx2srx2tKK2wL\n", + "4qXA08Bxqlqb60qo6pRcn9MYE564dZj3CzbXBPqJyKHB9hPB+MSbcEtEPSwiVwAbAB5wddIHZUmx\n", + "67LrKqZyu55k5Xht5XhNXRIyH9BiYI9C5d4JWSctdh3ycRvf0XXF47Uaj2trvkOoKHpy2558K5e/\n", + "Q2AILo9XApdbLZ50f52kchsBz+G+LX8J+CQlly21m12XXZddj11bT76mrtwkuNh2icizwKOq+vcO\n", + "CxeIiKiWYdeqL6Jee9eVSCiRiJTr9Xc39nswxhhTjjJ2MYtI76TNPwH3isgS4BnS5ABS1frcV88Y\n", + "Y4wxxhRae2MQ0/Wl356hrALRrlfHtMvNXC6rafTGGGOMKT3tBYjHF6wWJqwaIhHrzjTGGGNMXmUM\n", + "EFX1jgLWwxhjjDHGlIhQK6mIyKcislmGY6NE5NPcVsu0R6QyYYmxjTHGGJMvYfMgDgGqMhzrDayd\n", + "k9qYkJrFZs4aY4wxJl/am8W8Em69wdZAZHURWSelWDUug/iX+ameMcYYY4wptPZaEP8EXJi0/Ug7\n", + "Zc/ITXWMMcYYY0yxtRcg3gu8HdyfhAsCU9dLbgJmqurneaibMcYYY4wpgvZmMX9MEBCKyG7AVFVd\n", + "VKiKGWNyR0R+ClwEbAh8BVynqn9NU+5c4CRgZeAt4FRVfa+QdTXGGFN8oSapqOoUABEZDmwFrA58\n", + "DbytqjPyVjtjTJeJyA7Aw8CtwGnAtsAVIpJQ1WuSyp0DnI/rLZgBnA5MFpFNVPWbwtfcGGNMsYRd\n", + "i7k/7p/LIbhJK4uBvrgVVB4GfqWqC/NYz3R1Kss1cNtdi9mtpIJEqwcAqDaFSlNk8qc7/B2KyNNA\n", + "tarukrTv/wG/BFZT1WYRqQa+Aa5U1YuDMr2BOcDNqnpB4WtujDHdk+/7ewN/w60yd6vneVekKXMt\n", + "sA9QDxzned47wf4BuJhrY1ycdbznea8Xqu6twgYYNwB7AkcDfVW1Py5APCbYf2N+qmdWEIkMBGpc\n", + "YNhc0kGJKSmbAc+m7HsWqMG1JgJsD/QDJrYWCNZXfwz3AWaMMSYE3/ejwPXA3sBI4Ejf9zdKKbMv\n", + "MNTzvGHAb1gxjroGeNLzvI2ATYHpBal4irB5EA8ETlPVe1t3BP887glaGdqMZTLGlIxq3ISyZK3b\n", + "GwEvASOAODArpdwMXCorY4wx4WwNzPY8bw6A7/v34eKo5EBvHHAngOd5b/i+P8D3/cFAA7CT53nH\n", + "BsdagB8LWPdlwgaIS3AD29P5CtflbAqjznU1V6hIZcK6mU0Is3Fjh5NtHfwcGPysARZr2zEndUBv\n", + "EYmpakse62iMMeViTWBu0vY8YJsQZdbCfVH/zvf9f+B6f6YCf/A8rz5/1U0vbHDxd+CMoLVwGRHp\n", + "A5yJdTEXjnUzm+zdBBwkIieISI2I7IXLcwqQKGK9jDGmHIVdCjf1f7jiGu5GAzd4njca10B3dg7r\n", + "FlrYFsT+wDDgCxF5FvgWGIwbf7gUeEtE/tJaWFXPynVFjTGddjvum+iNwC0s/8C5DpgflKkD+kow\n", + "6ybpsTVAfWrroYjYWuDGGBNImaz4JSsuQbw2roWQdsqsFewTYJ7neW8F+x+kSAFi2BbEw4BmXFfy\n", + "dri+822BRUALcGhQ5vDgpzGmRKhqQlV/DwwCRuG+3L0RHG6dGTcDN9tuaMrDR5BhgHTwgeirqrR3\n", + "P8x2pn1hjnWmXEePt+uy67LrsuvK4rpSvQ0M831/iO/7lbhx3JNSykzCTfTF9/1tgQWe533jed58\n", + "YK7v+xsG5fYAPkz3GZxvoQJEVR2iqusFP1Pvt2637lsv35U21JFIqEglIpXWRWhCUdUfVfVDdRPM\n", + "TgZeUZcQH+BVYCHuSx6wLM3NAcBT7Zx2Soj7YbYz7QtzrDPlsjlPpvthtjPtC3OsM+WyOU+m+2G2\n", + "M+0Lc6wz5bI5T6b7YbYz7QtzrDPlsjlPpvthtjPtC3OsM+WyOU+m+2G2M+0Lc6wz5UIJJpacAjwN\n", + "fATc73nedN/3T/R9/8SgzJPAp77vzwZuxn0mt/o9cI/v++/hZjFfmsv6hSUaIg9iKeoO+ec6o908\n", + "iKkSCZVoNLVp2xRQd/g7FJFtgJ2Ad3HDRY7EDQ/ZUVU/SCp3NnABblzxTFxS7a2AjVX1u5Rzlvx1\n", + "d4aIjFfV8cWuR67ZdXUvdl3dS7l+HoaeASsim4nIRBH5VESaRGR0sP9SEbE8acaUrmZcy+AjwD9w\n", + "aW92SA4OAVT1cuAS4Bxc/sO+wJ6pwWGZm1LsCuTJlGJXIE+mFLsCeTKl2BXIkynFroAJL1QLYhAA\n", + "TsJ1Q/0X8IAxqjpNRDxgG1XdN681bVunsozYrQWxeynXv8OO9NTrNsaYVOX6eRi2BfEy4A51S3Vd\n", + "knLsXWCLnNbKhFUnUkkkUtU9xwkYY4wxpiSFDRBHAPdnOLaQ5cl2TSFFIgMTiUZRTV0kwxhjjDGm\n", + "88IGiN8BG2Q4NhL4IjfVMcYYY4wxxRY2QPwXcJGI7EhShnARGQ78GbgnD3UzxhhjjDFFEDZAvBB4\n", + "C3iR5WsH/hv4APgfRcrRYxwbh2iMMcaYXAq11J6qNgD7i8juuKzeg4BaYLKqPpvH+pkQEolGsaXP\n", + "jDHGGJMrYddiBkBVnwOe6+qTikg/YEPcOq/g1oH9WFUXdfXcxhhjjDGmazoMEEUkglt1YRvcGq4A\n", + "3wCv4VoQQ7dcicieuO7q7WjbvZ0QkVeBi1R1cthzGqe1mznRsrSOSMRmlRuTwRoid9TAkNT9dTDn\n", + "K9XjCl8jY4wpPe0GiMFqKfcBQ4EW4HtcYDcweOwsETlCVd/p6IlE5HDcZJf/AMcD03Eth+BaEkfg\n", + "FrR+WkSOVNWJnbqiHiqpm7mmw8LG9GA1MORw2CV1v33gGGPMchlXUhGRwcD7wNfAWcALwVhERKQa\n", + "2BW4AteqOEpVv233iUQ+BJ5Q1bM6KPcXYH9VHdlBubLMXJ7VSiopREQ1HodIpOxel1LVXf4OReQX\n", + "wBm4L3s/4oaKnK2qX6eUOxc4CVgZNzHtVFV9L835Su66K2LVTYpUpO4XtLm5paGydbsyVt2CEm1z\n", + "AiHe1NKQ1bAbY4wpxc/DXGjvw/D3wFJgZ1X9MflAECg+JSKvAe8FZS/o4LnWB54IUacngVNDlDPG\n", + "hCAiBwP/BK4HTgPWAC4GnhCRLVuHiYjIOcD5uEByBnA6MFlENlHVb4pSeaCiotdCVXqn7hehvrl5\n", + "af/WbUUq4vGGNo+PRqsrfJEDgPWA9RPRqmg80ZiuXJugMexzG2NMuWkvQPwJcGNqcJhMVReIyI3A\n", + "wXQcIM4GDgJe6KDcgcCsDsoYY8I7Apiqqsu+eInIQlyqqg2BmUGvwNnApap6Q1DmdWAOcAodv7+z\n", + "FnYsoCq94/GGNsFbJFLVe889f/mLxsaGTZoaGzdIJOJpnyceb+a+dbd8IBqJNkViseb4rDfTV0gV\n", + "Pxq7mET8H57qJ8GuvvF4Q5uWgWi0um/IyzTGmG6pvQBxKDA1xDmm4pJld+R84EER2QQ33GcGsCA4\n", + "thKwEXAYMBY4NMT5TBsV1Ky8stb98EOtTVQxKRambLd+8WsNfrYH+pE0FE9V60XkMWAf8hAgfh+t\n", + "Our79F29OwLHAeyzzx+qM3XdJBKN0SlTHry7oqJXorqqT0I1fYAIQryy6vOmeLwi0dwcA0373ogn\n", + "GhlP7LyKigHn/bX/OtqnT//GeLwlU7fRCvutpdEYU27aCxBXYvk/kfYsAjr8AFTVf4vIrrh/NNcB\n", + "qWOFmoHngbGq+kqI5zVt7M2CBY8JNlHFrOgW4HERORrXargarov5OVWdEZQZAcRp23o/Azd5LOcS\n", + "SDSeaNslLFIZHTp0xznffjt3jUWLvq5wHw1tRaPVen7L4r/Rsvgoln734YRo9dj0XcwxPv74leGt\n", + "27FYr0Q8Hm/bKhip0uEjdh42oG+vPasW/3hwU+PSLb+C6nTPHY83s/VWB0wZPHi1x4ePGPZ/1tJo\n", + "jCk37QWIYQdcatiyqvoysJeIVOHWdk7Og/iJqrYdGGRMDyEiV5K0lGUWrlHVLzMdVNXJInICwyIi\n", + "LAAAIABJREFUcBtwZ7D7VVZsqa8BFqdJW1UH9BaRmKq2dKJuafkivYimjb1QbaaiuX7QDusO+Wi9\n", + "xX0m3jL3s0vSBX6gAtQD23uqsyfEeoV97RKQruVSEh9++MwnwCfATQCxWLXG4+kuW/j8sxnbvfve\n", + "i7s8/sSSK90p0yq7gevGmJ6hoxl7T4tIR/8Usp71FwSCH2X7OGPK3OnAfCDsFyUB1salosoYIIrI\n", + "fsD/AVcDT+FaEMcDj4jIHqqaMbrpjPbGFp4INwPH1Q9c/fB47XdpHx+NVnHEF++cihvmshnRqgzP\n", + "JHiq5y/f0uZotDrtLOYVtoX6aLQ6bXdwuudIX8cYJ/8w+0pggyWVvYdf1dyyRUKb2pRLJOL86lfn\n", + "b3TbbRdPh/AzrY0xptjaS3MzPovzqKr6OamQyNpBvb7ooFxZTivvWpqbcbXwWI3G4y6/pI1DzLtc\n", + "/h2KSALYTlXfCFk+BjQBY1R1Wjvl3gfeVdWjk/ZtiOs+PkRVHxGRk4FrgMrkVkQRORPwVLVvyjkV\n", + "SH7PT1HVKZA5jYyIcuwGm333n0WN/ebNn1HtGiTbxqbRaDUtLUuXvabFTEsT9rljsV6avpVTgCj9\n", + "+g5OrLP20M+nz3x9vUT6GdQrXLMxpvso13gk44erqo4vYD2SfUbrp6rJiuqkgSKiRCIDSSRsbebu\n", + "5y4gfbNaevHgMT90UG59lnctA6CqH4vI0uAYuGAximu1Sx6HOAKX1L6NTJ8RmcYWgnDb7PdXGTJk\n", + "01k773zgcS+//NjL6cbtkdLNPize+HKGxNYvp3v+XBoUb7w7U2tomMdHo1X8rk/fcz8evPaJM2u/\n", + "WzddcGiMMaWoFJPCHo+N2zE9kGa5zFvQ0hfmMXOA0ck7RGQjoBfLA51XcTOdDwcuCcr0Bg4gGI/X\n", + "VSIxtthih75vvz15CUBFRa/F4bt6iyPs0nsRNB6JVKX5Uqvxa3787jLgMl9EJkSqEulyMBJ+xVJj\n", + "jCmIkgsQVfWusGVTusGXdXEZky8iMhaXiqk7+TtwnYh8hVvqcjBuTfTPcInpUdUGEbkcuEBE6oCZ\n", + "uKTa4LIOhOKLrEsk/ZjBSCRKa3AIEDb9Sx3MSbcMXthWvEII09LoqeqEWK+0j48nGlljjU0XbLLx\n", + "Flc98+ydEyxtjjGm2DKOQSw0EVkD+F41zUjv9OXLss+/K2MQIel1SSTUltzLv3z9HYqIR+YZzQlc\n", + "a997qtpR4vnW8/0GOBmXPeBH4CXgHFWdk1Ku00vt+SIHNNSsevvldT8Mcr3fK7JxdpnHKkYjVQwf\n", + "svk3Mz//YHBlZZ9EQ0OdqDanS5sTb2lZWnJf7I3pyco1HimJAFFEVsKl0xirqi+GfExZ/kJ8kVq6\n", + "kMdwPBVU00ztd24o219WWSVXVetInafpExCXszwGiN/jcvC1tiItBlonitTjxgtW4Za63LvQS+El\n", + "X7cvUgFcOnPE9r+dOOv9vvH4EjJMPtGWlqWRQtaz1GSaxRxBW86LN77TItH6KVvsuejlac/sn+E1\n", + "tADRmBJTrvFIwQLEDnK8VeOW87ofmAugqmd1cL6y/IV0lcg4hccodCtiV1s+u6s8BohbA3cD5wGP\n", + "BV3A1cA4XJLr44Oi9wEvqOovcl2HDuqnqiq+yDqNvfo99NCgEZvO/vL9ytGjd73r3XefP8i6R7Pn\n", + "i0QJljWcEK1eOcO60isE2WGXKzTG5E+5xiOF/CZ6Oq5brA43CSU5WGz9wBuLywGnQLsBojFl7nrg\n", + "ClV9oHWHqjYAE0WkH3Ctqo4WkQkEk0oKLRbrpRqpIrF0CQMXf7d0990P2vqZZ+59Czi2GPXp7jy3\n", + "VuA1vsijsGLXf6t4vEV22P6IUa+8et/7ADUwJMMMb2NMEfm+vzfwN1xvz62e512Rpsy1uKVM64Hj\n", + "PM97J+lYFHgbmOd53gGFqfWKCtndcw0uMLwLGKmq67XegM2CMkeo6pBgnzE92Sjg6wzH5gMjg/sz\n", + "cWsoF1w83kAi0YhIhN///pg+QXBoushT/TxzIgfltdcf/d9m64xuOKOyzwefENn5MqKk3j4muk1B\n", + "K22MWSYI7q4H9sZ9Vh/p+/5GKWX2BYZ6njcM+A1wY8pp/oBbUKRo4wALFiCq6p+A7YAdgZkikq5L\n", + "rPgDIo0pDbOAPwbLUi4TdDP/ERcYglsVpaDjD1NFIjHG+769d3MogsYrIlW0uUVjiV/sNu6ibxrr\n", + "+WtLYuNGItJInNRbXDIuP2OMyb+tgdme583xPK8ZNxTowJQy4wjy03qe9wYwwPf9wQC+768F7Avc\n", + "ShHT/hV0sLOqfgTsLiKHAleJyO9wUfLHhaxHmaujC5NcTMk4FZeCZq6IPItLoL0qsCdu4sp+Qbkt\n", + "gIeKUkOTN+0kB3/pn5MneoB32KEnX/jgQzenXcEqYhkMjCmmNQnmUwTmAamt+unKrIn7wv9X4Eyg\n", + "qGO2izKjUFUfxK3QMBmYAtxWjHqUI9VJPW4mcTkKcnoOw33DXBPYC1gd+AcwrDXnp6r+OWidNz3M\n", + "Aw/ecFE0ass3G1OCwvaopH6RE9/39we+DcYjFvWLXtHSJajqUuBCEfkHcDkuXceS9h9lTM+hql/i\n", + "vkWaHiaL5OBKmn8imkhwgUSHTdD4rNRjxpiuCbFgwpfA2knba+NaCNsrs1aw7xBgXDBGsRro7/v+\n", + "XZ7nHdPFametFPJpfY7rOvuZqlpXszFJRGQksCXug+R2VZ0vIsOAb1R1YTHrFo1WAyBoczHrUY6y\n", + "SFGTIM269Qlt4po+a8x8ZuM9Ln7jw8kX5rRyxvRwQQ/OlNbtYGGDZG8Dw3zfHwJ8BfwMODKlzCRc\n", + "Wqv7fN/fFljged584Nzghu/7uwBnFCM4hCJ1MaeI4Mba9O2ooAmrQkUqE0AdiURtsWtjsicifUXk\n", + "AeAD3EDlCcAaweFLcEvlFVVLy1JpaVkqzS0N1s9ZJJWVseaV+q9M6q26um/D6A03nv/2jNcuqBmw\n", + "/pJYrNfSWKxXS+qtoqJXUb9kGFOOPM9rwQV/T+NmIt/ved503/dP9H3/xKDMk8Cnvu/PBm7GrXSV\n", + "TtEmABZ9JRURiQFNwBhVnZbF48oyMWWuFHrJPUuUnfPz3oKbxXY08ArQQPAeEZHjgDNVdeOQ55oC\n", + "7Jzh8Haq+kZQLtQye0FZe/+VgDFbbnnH+uuvPyR1/6effjrngGnTfplYfe17nx6w7rg3pr/cJnE5\n", + "tF2ZxRJvG5O9cv08LIUuZmNMWwcDf1TV54MvUcm+ANbN4lwnsWKuRAEuAjbHBYKIyDnA+cAZwAxc\n", + "YvvJIrJJoZfxM+G9PXXqce0d90WO3ufruQ+9Hak6IJ5o7PAfmCXeNsa0KnqAqKotIrIblurGmGS9\n", + "gO8zHOsHxMOeSFWnJ2+LSCWwFfAvVU0EuRXPBi5V1RuCMq/jJkScAlyQde1NSfBUW3yRI5H0EwBV\n", + "E8uGGfkiA6pd67ExxpTEGERUdYqqLi52PYwpIW+Tecm6Q4BXu3DuvYEBwL+C7e1xQeeyhiJVrQce\n", + "wy0DZboxT7U+U7aMRKJJVq5Zr+XnQ7f8Gpjby82kbCNSAo0JxpjCsje9MaXpfFwX73NA63rM+4rI\n", + "acChZB5TGMYRwFxVfTnYHoFrkUxNiTIDN/vOlKlopIqhq6/9zcSP31mjus8a8YaG2sgbqm2Ts4nu\n", + "4Iv81FN9tCgVNcYUXEm0IJp8qFAR0ZqVV1abydz9qOpLwG5AJXBdsNsH1gN2V9U3O3NeEemNW+Ip\n", + "eVhZDbBY285YqwN6pxkDabqZTEv3RYT4Gx+9uOb++/+iz/Dhm0+OxxukJdFIc8ot7v5V/MUXmeiL\n", + "DC729Rhj8s8++MuUalNEZJwuWPCYYEvvdUuq+gqwUxDU1QALVLWryeQPwC3V96+OCpry0c7SfS8D\n", + "PProTfXA3rFodSLDZBYFNgM84H+biHysacbB2mxnY8qHBYjGlLhgPGB9jk53BDArJaVUHdBXglwN\n", + "SftrgHpVbcnRc5tSJ5I28bZqAs+tfnW2LzKxBl7YI03uWpvtbEz5sADRmBIRLDsZJjGpAKqqx2d5\n", + "/pVwk04uTzk0AxcUDGXFcYgjgOlkICLjkzantK4PbUpPFkv3pZVINMlqq41cuu8+4359u+rdD4hM\n", + "o2vjYI0xJc4CRGNKxyhWDBDXAVYBvg1ug4Pt73FLVGbrINyYxtTu5VeBhcDhuFVaWscqHgDclOlk\n", + "qjq+E3UwRdDVbt9IpCpeVdVn3h13/vWfL7/y0lVzYtWDLkmk+S4j7NiV5zHGlA4LEI0pEao6pvW+\n", + "iIwD/gocpKqvJu3fAbgTt/Reto4A3lXVmSnP2yAilwMXiEgdMBM4LTh8HabHEKE+Gq1us+qKCPWf\n", + "f/7WsC0233/neV/OfrS5pSHtBMdotLpN97QxpnuyANGY0nQ5cEFycAhu4oqIXAhcgVvsPRQRGYSb\n", + "FX1+uuOqermIRIBzWL7U3p6q+l0n62+6oebmpf3bO/7Ou4+/CAyMRqo0oU1pShR36VZjTO5YgGhM\n", + "aVqPzBNT6oPjoanq97ju5fbKXApcms15Tc8kkYgST5d9u+yWozWmx7I8iOWtDiqQaJSBAwdaPsTu\n", + "ZRrgicgayTtFZE1gPDC1GJUyJpBIt1NU8UWOLHRljDG5ZwFiGVOdNFC1SeAA6urqwPIhdicnAqsC\n", + "c0TkVRF5VEReAz4L9v+2qLUzJo2WRAtaUXmtLzKi2HUxxnSNBYjGlCBV/QCXduaPwMdANS4dzR+B\n", + "DVT1/SJWz/RwwWSWePItEqmKg3LTgPVWivfp/5DvZsIbY7opG4NoTIlSl5j4huBmTMnINJll8832\n", + "Hjjn8xnzrovVbHTyqv3uwKVOMsZ0Q9aCaIwxJifefe8/tWuvtd7Aysrqhdcsjh922ogtLyp2nYwx\n", + "nWMBojElQkRqRWR0FuWjwWM2zWe9jMnG+x883zBo0EoDV64Z/O3fP5tzwa92PujkYtfJGJM962I2\n", + "pnQMADYUkYaQ5WPBY+x9bErKhx+9kRCR1TYaMmbe7S/9++93RKv/LrJiChxBm5tbGtpNvWSMKR77\n", + "x2JMabm32BUwJhdUVYE1I1KhiURjm+PRaHVF4WtljAnLAkRjSsdunXzcxzmthTE5FIlGicdbil0N\n", + "Y0yWLEA0pkSo6pRi18GY3LPVVYzpjmySSs+wbEUVEdFIpMpWVelhRCQmImeLyCwRaRCRuSJydZpy\n", + "5wbH6kXkBRHZrBj1NcYYU1zWgtgDqE4amLwtIoqtqtLT3AHsilumbwawDrBRcgEROQc4HzgjKHM6\n", + "MFlENlHVbwpZWWOMMcVlAaIxZU5E9sYlLN5UVWdkKFMNnA1cqqo3BPteB+YApwAXFKa2ptwI2pw8\n", + "ISUebwKECGoDE03Z8n1/b+BvQBS41fO8K9KUuRbYB6gHjvM87x3f99cG7sItqarALZ7nXVu4mi9n\n", + "XczGlL/jgecyBYeB7YF+wMTWHapaDzyG+wAzplOaWxoqW1qWSuttv/2O3VkkxlHrjKj1RVYpdv2M\n", + "yTXf96PA9cDewEjgSN/3N0opsy8w1PO8YcBvgBuDQ83AnzzP2xjYFvhd6mMLxQJEY8rf1sAsEble\n", + "RH4UkSUi8pCIrJ5UZgQQB2alPHZGcMyYnHj88dtfGjVqp1fvn//NKnEi//FF0i7bZ0w3tjUw2/O8\n", + "OZ7nNQP3AQemlBkH3Anged4bwADf9wd7njff87x3g/2LgenAGoWr+nIWIBpTokRkMxGZKCKfikhT\n", + "6yorInKpiGTTqrc6cBywKfAz4JfAlsAjSWVqgMVB7rpkdUBvEbHhKCZnVhnUaxdEE89uuP1awCRf\n", + "pFex61TK1hC5Y2ORKam3NUTuKHbdTFprAnOTtucF+zoqs1ZyAd/3hwBbAG/kvIYh2Ie+MSUoCAAn\n", + "Aa/ivmV6SYcbgd8DT4U9XfDzQFWtC87/NfCCiIy19Dqm0CY/N6llr58cddqzkx+8ZsvB67+/yjef\n", + "3ueLHOKpjUtMpwaGHA67pO6fmK5wCGuI3FEDQ1L318Gcr1SP6+RpzXKpX7QzSc0Btexxvu/3BR4E\n", + "/hC0JBacBYjGlKbLgDtU9ddB611ygPgu8NsszlULfNIaHAZeAZqAjYEpuJbCviIiKa2INUC9pvnH\n", + "LSLjkzanWKBpsvH0M3dfu/76M/98/6LF254CLz4BMyaKzEstZ0FL7uU64OxpRGQsMLadIl8Caydt\n", + "r41rIWyvzFrBPnzfrwAeAu72PO/RLla30yxANKY0jcClm0lnITAww7F0pgPVafYLy7+xzsDNthvK\n", + "iuMQRwSPb0NVx2dRB2PaGLPlmG0ffuSfXzy99UHfVr35yA77wQapZXpy0OKLRIEd+qV5XUzxBF+G\n", + "p7Rui4iXUuRtYFjQRfwVbmjPkSllJuEyRNzn+/62wALP877xfV+A24CPPM/7Wz7qH5YFiMaUpu9w\n", + "/xQmpzk2Evgii3M9DvgisrKq/hDs2xmowLVGguvKXohLh3MJgIj0Bg4Absq69saEMPGBG+fuuMP8\n", + "e19/47ljN67s/QZN9dsUu06Fkqmb90f44tfwL+Bg3ESGrxRCdb2LxGaDDGp7RL9XbRnaujUrWrXj\n", + "Jek6QYUdQ1bftMPzvBbf908BnsZ98b7N87zpvu+fGBy/2fO8J33f39f3/dnAEtzYcIAdgKOA//m+\n", + "/06w7xzP8/5T4MtA2o5J7x6CnjBbw6kTREQ1HodIJGevny+iXg/8feTr71BE/gIcCxwCvIZLfTAG\n", + "90HyLHB72BY8EekHfIDrvrgU6A9cAXykqnsllTsbl+/wTGAmcBqwFbCxqn6Xck57/5mcWWXQ0Pp+\n", + "vQfIsXOntmnpnggvfKg6tgjVyquNRaak6+b9L7Ts5iYlPAw86ql+mqls6msTiVQ1qTZVpJYTqWxO\n", + "JBorW7djsV4ajze0qVM0Wk1Ly1JZ/rhwAWdPV66fh0VpQQz+YW3I8tU86oCPVXVRMepjTAm6ENdS\n", + "+CIwP9j3b2A13LfSS8OeSFUXichuwLW4dAtNwKPAn1LKXS4iEeAcYGXgLWDP1ODQmFzbZZfdD3n4\n", + "kTuf/HK1oaw5f3axq1NUdfCWp7pjyr45yV3tNbBpCyyuc4nsl4lEIpF4PN1ZNSayweWgVRXE+yfC\n", + "NUgiEl0nQ8DZO9QJTLdW0BZEEdkT949vO9qm2EngurkuUtV03Wqp5yrLiL0QRCoT0Cwp+0gkGjv9\n", + "eloLYt7OvzuwBzAIN9nkOVV9Jl/PF5a9/0yuRaNViUSiWWKRyhWndgrxppaGshsOFbZVEKCiotdC\n", + "VVYIygSNRmBpU/wnfWDW7r166W+XLp11iPtXmirC4FU30GisglgsJl988QHpy0EsNqgxFutdBxVz\n", + "Ghq+2Cb1fwVANFodb2lZmvXvpFxnT5fr52HB3nQicjhuXMV/cCs7TMe1HIJrSRyBG8j5tIgcqao9\n", + "eWxyXqk2tcl/GazPbEqMqj4HPFfsehiTbxLMmWpJNK6wPxqt7vH5elXpHY83RNseifaKyH/jSFxW\n", + "W21kYs6cKKptA79otDI+/+sZg64cPPisprolO3rRyu3TnS8Wrea00/707qefzBkyb9680a+/8Vna\n", + "oCeRSIjIlv1Vpy6E9AEsgAj1zc1LlyVCt9nT3Ushv5V5wFWqelaG428B/wzGXo3H/mZMDyYiI4GV\n", + "VPW1YLs3bnzgRsB/VbUoa3MakzciCdyA/lTpm7q6uUo3FrhLRCJccvRR3/9mwnmHDFxrzddjlX2W\n", + "xuPN6V5D/Gh0J+BoYAzR6i8znbP3X8674gHVRwBisV4t6QJJ1eYI/O/HyspVG2Kx/rNaWuJ9M7Q0\n", + "Wld0N1bIAHF94IkQ5Z4ETs1zXYwpdTfgchW+Fmz/BTfL7WXgChGpVtW/FKtyxpjO80X69IUNJsGH\n", + "DfB98rHUcYUim1RCS9pW1EgkGm+86+a3rrvr5p96qi9VVsaaKytWbhPQNTU1thDnNmCcp/rNxRW9\n", + "6tMFb4I2Ajf6Iq97ql9nqn8sVhV//dXXzrv73n8fNvXtaSNfevnTUN2rc+k94h9pMm7V0mDLeZag\n", + "QgaIs4GDgBc6KHcgbdeDNaan2Ri4CkBEKnHf/P+kqreIyB+BE3FBozGm+7lsD3jMUz2qvUKDBm31\n", + "u4qKr//W3BxvLwA7Bpjmi7w4cvTo+9dff/0hKxxNJKJL33lnEz5bfIGn+jpAcrdvKt8lwP+HL7Jv\n", + "Za++6QPO5sbmLbfa/Iott9r8Csjc0hiPN0b79hn6/pJ6uRv63RyN6KqL0rQHRyO6qi/Sz7OJqiWl\n", + "kAHi+cCDIrIJrvt4BrAgOLYSruvsMFx28kMLWC9jSlEf4Mfg/rZAX1xmfYB3SDPQ2xhT+nyRXXE5\n", + "DkdlKlNZucnw3r0bpyxa9OVq++93xPQnnvzXhunHIIKn+oMv8jNg0gHTpm3jTZ36WdJzCW7s/yzg\n", + "lpBVvBjXU/G7kRtt2DbgBD799NM5YU4UiVTqppsO3+D9D6ZdtnjxnMvjiQSwtG1BqRJgui9yGvCA\n", + "113z75WZQs9i3hE3jmosLklvsmbgeWCCqr4S4lxlOWuoWLr6etos5pyf9yPgTlW9QkSuBnZW1THB\n", + "sUOAG1V11Vw/bxb1s/efyankiQ6JRCKi2iyxSKVGheaGloaqYtcvF3yX4u1/wO8ujlXf13Zih5JI\n", + "qILEhg8fU3/uOacdcfQxBz8WZhJIEFwdAezoqTYl7fs5sJOnmiYyy1jPobjhLWM91Q87Kp+pBbF1\n", + "tvO9++57RuOg1S444Z57+icSTW0eH4lU6YWJxp1xQ2u+uYjodoqkWf1J6xPa0qmxm/mcQV2un4dF\n", + "SZQtIlW4VSKS8yB+oqqNmR/V5hxl+QspFgsQOyePAeKvgBtx/0y2AH6pqncFx64FRqrqHrl+3izq\n", + "Z+8/kzenn3ZB7Lrrr23abtTOd+827fG9gXU81baZnbsZX+RmIOqpnpApqALhT3+86Karrzr3FCKR\n", + "tFkNM5xbnoLPBSILYXYVDOgHI+tg6vcwM9sgyHefQb8HtvE6+N/cXgB7fkvD+bhlQ38yIVr9QaaW\n", + "0Fhs5aZevVb+cOiiH2e/R+1hCZrblBGp1ESisVOz2rNJK5Stcv08tJVUDGABYmfl8+9QRHYGtgbe\n", + "CdLdtO73gTdVNcykr7yw95/Jt9Gj93r9009mbf6nhZ9NAe71gi9I3ZUvshdwM7Cpp7qwo1a3zjzH\n", + "KJGXD3VLta2gM0FQEHDOAWQRfJp8LEyrW9C9fT5ujOSenuqcTNcci1UnTj7prFdffuXVMR99NK2q\n", + "oaE27WdL6kov2bAAMXsll3xURNbGBa7ZrDVrTNlR1RdxK6mk7k9dGN6YsjNq1PCD3333hS/fH7nL\n", + "rFEfvXAy0G0DRF9kAPB/wC891YX5ep5EyDWbw/BU9UGReYfC9sDaycdSc9Cl677tBxvEoM+eMNJT\n", + "nQ8QiZCIx9umMhIhfs21/k7uIhJDY5V9ZqVbCjCRiLODrL7JK/r1BwAVseomRdqu9II2N7c0VAZB\n", + "6gjgwIGuJ8ZkoeQCROAzQEifD8uYHkVE1sItS9lmPI6qPhnyHMcBt6c59FtVvSWp3LnASSxfZu9U\n", + "VX2vE9U2psvuvPPar15/7e3PX6mt/cUoWOSLbOmpTi12vTrpGtys5WU9Ad2h9y5Bmn7eNDIlwH4Q\n", + "XmkNDgGqqyu+6NOnus3azvF4fHmqn0gk41qLqi28yvfv96kenFi5cqV58YRWpOv9jkarK3yR/4fL\n", + "ilINTFriWkM3DXM9xinFAPF4oOyaao3JRrBe+QPAT9oplu1YnF1ZcQrhstmOInIOrjvoDFyGgdOB\n", + "ySKyiap+k+XzGJMTW4ze4piJE299Yf5qQ+9bbf7sk4ATil2nbPki43Ddvpu37hu86nYrJxJN3bYR\n", + "ZCBs6Ys8CnwOfNELVklXLrVFc+HChUO78rzRaBXPPPbEr/955wNnvP2/94fOnZ4pI54C1OMm7Uzz\n", + "VHWiyJSuPHdPVHIBomYxzkRcvqZWU1R1Ss4rZEwSERmLm4Wfb5cB6wA7AS/hcoguAH4B7IabmZit\n", + "t1S1PnWniFQDZwOXquoNwb7Xcd+4T8FlHjCm4O677+8vvvTSiz8+W9Vvn6OZPcAXOdNTrev4kcWT\n", + "3N0agdhA2GohfPQNXO/BcesN2W3Qkvov5kGUaDTWZhKKCG3eo6VmMXyM6/JfB1inCnKaUaGyIhav\n", + "7JM24Xd8t312u3W3fXa7FaAi1ktb0nRFx+PNXFOz6Yi6uqbnYBge8HG0avsJKW1PgiJpxmwap+QC\n", + "xGyo6vhi18H0LMGXkCmt2yKSr/GA++ICszeC7a9U9S3ghSDtzZm4vKHZyNQyvz3Qj6ShRapaLyKP\n", + "AftgAaIpoi1Hb3X+40/cd119Vd+HejcuPhb4W7Hr1J4M3a2bT4Qf111nl1V+qP1kXv/+NYkb/n7d\n", + "gGOOPfjHtCfppDqYk26N2tTVWbqqCRZ5qg+3bk8UGU2aLubOGjlyw7vD5F/M1EkvEqVPn8TBP/74\n", + "2WEwV1daaYPvW+KJWLoe81i0KuaLrOPZvIc2ChYgivsD6pWc41BE9sG1XGyM+12/A/hh8iAaU+YG\n", + "A1+oaouILAEGJh17kuVJs7PxiYisDHwCXJ00/nAEEKftCkYzgJ914nmMyZlJj91+fc2A566evMbQ\n", + "YeOm/3dTX+RaT7Xbrc+ciFZV/FA7e17//jXxi/wLVzvm2INzPlmlq/n8UhUq4Ez19tSpx3Xl8ZFI\n", + "lLmfv1exaNGSEddc+4/fvvDiqwdOnjwn7RdkVUkAT/kiO3qqdWFyTvYUhWxBvBGYhFtfFhE5HrgV\n", + "lxz7b7jWjd1xLSSHquqjBaybMaVmLrBacH82cADwdLC9NZBNTrivcOML38RN/joSuElEeqvq33D5\n", + "SBdr21HzdUBvEYmpas5mRxqTrS1Gb3vHyy8/e8J+8H7UDbGYXOw6ZaNeYsytHrjdSv1rGs497+zB\n", + "J/z68G6xpFzYgLNYgaSgzdFoddpZzEQi2m+lftPPv+DUP5zPqX+Ixf6dfjnAREPkiqoryPJrAAAg\n", + "AElEQVTBwwf3Xmne9StvcVsiob0TicZ06YfaBI3lrpAB4kbAhUnb5wI3qOopSfsmiMhNgA9YgGh6\n", + "ssm4L0wPAFcDdwat8E3AzgTrNIehqs8AzyTtejoYd3ieiFyTuyobkx+JePOJkQgnvDZy18U7fvT8\n", + "yZRwgDgrWrXjJUlftRRoSTTBku/kIn/Cqr/73VGLi1a5PMl1y2VYzS0NlV09RzRanTj4kMOnfPzB\n", + "BzstnPfZ7xOJcOt1ZGppLCeFDBATrDhkYF3cP79UDwG/LEiNzDIilYhIuiEddao6MM1+k19ngfvw\n", + "UdV/ishi3JjDauB3uIS7XfEQcDjufVgH9JUg22tSmRqg3loPTbFNeeFh3XrrfV98Y/qH2+8Ii32R\n", + "tT3VucWuVzoJiMbTBBnRSJTTTv9V2QWHZUDvvufaPXyRXhKJTJ4Qrd6uJd7Qpjs6Hm+IDhiwQW3v\n", + "3jUzm5t5IpHQvolEY1lnXOnUkjWd9DJwVNL2R8BWacqNAb4sSI3MMolEo6jq8ls8juvVXLYcoikg\n", + "Va1X1e+Tth9R1Z+r6sGqeqN2fQyWJv2cget6Tk1BMQKYnukEIjI+6Ta2i/Uxpl0bjxx28JL6bytm\n", + "rD/mA+A3xa5PZhlihvRfwE2BiFAfjVbHU2+ts8Y91aWaSIxT0q+IEolUsdVWW3/Zt29sVGPj1xPK\n", + "PTiEAi61JyKjgFeBfwPX4Qbd34XLLv88y8cg/hE4W1X/2sH5ynJpm5KRSKhEfwo8RpjX2Zbay+tz\n", + "RIGq1P3pUtZkcc77gN1UddWgu3k+cKWqXhIc740bP3STql6Y5vH2/jMFN3KjnWfV/vDD6id999Ei\n", + "YF1PtanYdUrmi6x0cbRqQUs8bfLmTi+hZwonFuul6VZxiUaruCDeuClQE62srBkfjzyaXK4cPw8L\n", + "9seqqu+LyE7ATcBrSYfODm7gurrOUlUbF2V6NBFZCbgUOBiXYyz1w0cJudqQiDyIe899iHvP/wzX\n", + "vfx7AFVtEJHLgQtEpA6YCZwWPPy6rl2JMbkzatQmRz7w4G1vTR64RmJp7VfvTBT5rvVYmPWBC+BM\n", + "EMUWe+i2Img8Eqlquxyg63S5D6iLNzXVEW3znb3sFPTbjKq+C2wrIiOBbXCzNAWoxXVlvaYl9o3Q\n", + "mCK5CdgfN9N/Om5ySmfNBH6NW09VcIHi0ap6T2sBVb1cRCLAOSxfam9PVf0uzfmMKYr7J97w9utr\n", + "vdRSJxX9Dqv9amTysXSzaAvJF1kdOCme6HYZeEySYfHGl9MtGzgRXvBUx7ZuT4j1KvshA0Vp7lbV\n", + "j3BjEFu7zyYDv7Hg0Jhl9gJOU9X/6+qJVPU84LwQ5S7FtVoaU7KW1H275Iv6H1b6kUFEWR6M1dIw\n", + "oojVArhw/pobPqdffnyYSKVGIpEVIsXusEKKCS+5pbE55MznQvJ9P7n3J7VVWz3PO7Wjc5TCeAjB\n", + "Rev9il0RY0pIPS4XojEmyYKGRf1AmEc9blK/E41o2vWAC8EXGdYUrTzsztofa4YP3+nTGTNe3KBY\n", + "dTGFMSjeeHfrkoof5XAVmRyaGvzcHhgJ3I+Ltw7D9SJ1qBQCRGNMW1cBJ4vIMzmYsWxM+RCNQAvu\n", + "ltQoJ9WFzMqR6uK7Vx3eq7phSfPQocOGF7EepovCJv1OHu+aLkWc7/t74xYBiQK3ep53RZoy1+KW\n", + "M60HjvM8752wj+2I53l3BOc6CdjR87zmYPtGXFaZDlmAaEyJEJErWZ5+RoDNgJki8jywILW8qp5V\n", + "wOoZY9LwRca8OGybA7/6bHrVQT89ZuOJD1xneUO7sVxMdPJ9PwpcD+yBS9v3lu/7kzzPm55UZl9g\n", + "qOd5w3zf3wa32ty2YR6bpQFAf+CHYLtfsK9DRQ8Qg7VmdwM+LnZdjCmyw1gxmbwCFcCeKeUkOGYB\n", + "oumJMs0SLsqkgU+HjfnX87Pfrdpzj5+dMvGB6z4qRh1MydkamO153hwA3/fvAw5kxbyy44A7ATzP\n", + "e8P3/QG+768GrBfisdm4HJjm+35rOsFd+P/t3XmcHEX9//HXezcBEsIRQMMVCQIxHD9EuUEgAuEm\n", + "KEIwiAIeCAiIIkK4Og1fMSgqXigYIaAgICJX5EiABJAzgKBAOBOOhJtwJiHZ3c/vj+phe2dndmd2\n", + "Z3pmZz/Px6MfM91dXcfMdm1Nd3UVTCzlwJo3EAHMbEat8+BcrZnZiFrnwbk+oI3CQzxl3hXjyA23\n", + "Ouay52evv8Xnd516y62X/D7r9F3dWouOfchfJozc0l2YtYA1Szi2ZFEUXRzH8c1JHAacHEXRK6Uc\n", + "WxcNROecc64UTU20tbZ2biA2NWXbQPz6Xt8YdOO8134zYq2RCx6YdeM+Wabt6l6pV7OrPl5mHMe3\n", + "RVG0C3BtgW1d8gaic3VK0jDCzEJbAWsA84EHgF+b2Wu1zBtAHMeFKsE4iqKJBcJOBCIP7+F7G/7U\n", + "U0/+ePv999//0R133NW8ePGiASsuO2BBNfMzcOCg98zC/Og77viFpp12+oKO33o9gKGpc6Hmn4+H\n", + "r374ZGrR0QX258wjjDubM5xwJbCrMGsnYQaWcGy34jgeBAwGPhHH8SqpXSsSrlR2K7Op9irNp/qq\n", + "Mp9qryTV+juUtD1wE7AUmAa8QZhRZQzhh91eZlbSk2jV4OefqxcHHnB488233Lxkk0+O+GiP5+9b\n", + "PqrSP7UBAwa1tbYu7vQ339y8nLW0LKrlE9SuxvLrwziOBxAmKNiF9h/24ws8pHJMFEV7xXG8DXBe\n", + "FEXblHJsKeI4Ph74PuGW9fzUrveBC6Mo+l235fIGoivIG4glqWID8RHCk8v7mNmHqe1DgBuBlczs\n", + "c5VOt4z8+fnn6saeexxy1C23Xn3+Iet/7uRLn7637CFBSlF8jt7laGlZ5OdCP1aoPozjeE/ah6r5\n", + "cxRFP43j+LsAURRdkIT5HbAH8CFweBRFDxc7tqd5i+P4uCiKftOTY72B6ArzBmJJqthAXAQcaGY3\n", + "Fti3D3C1mS3X+chs+Pnn6s1n1t387Xff/2ClV998qqQ5ysvlDURXTD3Wh3Ecbwm8nHsgJY7jQ4Gv\n", + "EMZznBhF0dvdxeGXxZ2rT08S5iovZA16OOSBpLUkfSCpTdLgvH2nSHpJ0kJJMyV9tidpOFcLm49c\n", + "b/O33pnXtPPm+/6zKgn00Ysprt+6EPgIII7jHQnD3VwCvJfs65Y3EJ2rT8cAp0j6qqRlASQtK2k8\n", + "MCHZ3xM/J/RB6fDfTtIE4DTgp8A+wAfA9ORBGefq3uW3XDVn1402f/iux+760th9j6/o3+348T/Y\n", + "u7UO59t1rgtNqauEBwEXRFH0jyiKTgM2KCmCqmXNOdcb1wHDgMuBRZLeAxYBlyXbr5X0RrK8XkqE\n", + "knYEdgfOJTW8gqTlgJOBs83sfDO7nfZBu3vaEHUuc5/97507D11hZWY/MWtWpeI85Gs/2vkf/5hy\n", + "Y5OWYWDTsp2WJqy1Umk5V0HNcRwPTN7vCtyR2lfSCDY+zI1z9amcQXe7vfclqRn4LRATbjGkbUeY\n", + "funjKUjNbKGkGwjzhJ5eRl6cq5lJZu++M2LDay6cM2v/3cZ8+7Bbp02e0pv4Djt0wrZXXz1l+gaf\n", + "/NTSZeY99r8l1unc6TRHr3N14m/AzDiO3yTM9XwXQBzHG1Bg6tZCvIHoXB0ys4kVjvJIwvhavwe+\n", + "nrdvFNAKPJO3fTbh1oRzfcYaL8w+fstPb77fffdP/9Ponfa/ZMbMa3rUefDb3zpts6uuuujf66y6\n", + "etv+8x479iyzCyqdV+eqJYqin8RxfDuhL/utURTlBpIXcGwpcXgD0bkGJ2lV4Ezga2bWKnV62G4o\n", + "8IF1HtJgATBY0gAza8kgq871WmT20tKBy171aNPg8QsX2k2EYUTKcsR3olFXXHHRw6uvuIqNe+Xx\n", + "cWeZXVOFrDpXVVEU3Vtg29OlHu8NRFfMgqFDhwxdsGAgkrr6Bb7AzFbpYr+rvZ8A95rZzbXOiHNZ\n", + "GNiyZJI166sPzrp29wEDBnX4cSOxcOnSRSvm1ldccY1nm5tXWC23btam9957ZcUBzQM4+I3Xdz0r\n", + "9Ml1rt/xBqIrrKlplbffvpzwjESirc1oapI01syuF9Bd49HVmKSNgcOBHSWtnGzODW+zcvL9LQCG\n", + "KBnMK3X4UGBhsauHkiamVmeY2YyKZt65HorMHvu/AYMAaG1d3GFcxObm5ToM77R48QfrLl26JPXA\n", + "5nuEu3BN9n9tLd44dP2WNxCda2wbEPoedrrVQJjfczKhM3MzsD4d+yGOoovxFqvQT9K5irHw8Fan\n", + "/hRtbW1NO3/x639fbtCg1wcPHvxaa+vSpjCqU144a66rgY+dy5o3EJ1rbHfReVL5PYGTktfngRcJ\n", + "l03GEW5HkwyivS/wx6wy6lyFFWzgmbVo1kN37NvS8tGAlpYlTW0+vqFzBXkD0bk6JKkN2MbMHiiw\n", + "bwvgfjPrdkoxM3sLuDPv+E8nb+8ys4XJtknA6ZIWECaK/2ES5rc9L4VzNVWwgdjcvAwnvD/vUmB7\n", + "YPhZzcuu0NrqjUTn8nkD0bm+ZyDQ26eKO/QdNbNJkpoIs7SsCjwIjDGzN3qZjnN1xgD+S7g6/hho\n", + "aW3z41x9UueRLfqGepwcu+EVeUjFzBRLFvXD76OSf4eS1gHWIVz5uAM4GngiL9hywGHA5mb2mUqk\n", + "2xN+/rl6t8yA5VowOl9lF61LWhZ/fHFkQPPA1ta2lk6zijU3DWhraV3a7VV65xq1PvQriM7Vj8OB\n", + "M1Lr5xcJtwj4TvWz41zftUHrR3ePg53yt18Fd6fXm9ta5gyE1fLDtbW1vFnN/DlX77yB6Fz9OB+4\n", + "Onn/GPA1wq2wtCXAi2a2OMuMOdeoPjJbv9Z5cK4eeQPRuTphZq8Dr8PHD5LMN7Mltc2Vc33TAph7\n", + "VZHtWefFub7IG4jO1SEzmwsgaVlgLULfw/ww+f0TnXOJ+WaH1ToPzvVl3kB0rg5JWgu4kDBWYSEG\n", + "BTrgO+eccxXgDUTn6tOfgM8DPyDMZuK3mp1zzmXGG4jO1aftgSPM7MpaZ8Q551z/02nsJ+dcXXgD\n", + "WFjrTDjnnOufvIHoXH06AzhJ0kq1zohzzrn+x28xO1efvgx8Cpgr6UHgndQ+AWZm40qJSNIBhLmV\n", + "RwLLAy8AfwF+ZmZLU+FOAY6ifaq948zs0QqUxTnnXB/jDUTn6tMngOcIjcFlgE8m2y3ZVs4cmasA\n", + "04FzCA3NrYGJwOrAsQCSJgCnAT8CZgMnANMlbWJmr/WyLM455/oYbyA6V4fMbHQF47owb9NMSSsC\n", + "3wOOlbQccDJwtpmdDyDpPsKAwscAp1cqL84515/FcbwKcCWwDqGOHRdF0TsFwu0BnEcYzmxyFEXn\n", + "JNt/DuxDGNniOeDwKIrerUZea9IHUdIKkjaXtGuybC5phVrkxbl6p2BNSQMrGO3bQC6+7YAVgI8n\n", + "njCzhcANFB+H0TnnXPlOBqZFUTQSuC1Z7yCO42bgd8AewEbA+DiON0x23wpsHEXRZ4GngQnVymim\n", + "VxAljSF0vt+Wzo3TNkn3AGea2fQs8+VcPZK0NxABmxF+RW4JPCzpT8BMM/trmfE1A8sSxlc8Fvhj\n", + "smsU0Ao8k3fIbOCgHhfAOedcvrHATsn7S4AZdG4kbgU8G0XRXIA4jq8A9gOejKJoWirc/cBXqpXR\n", + "zK4gShoH3Ay8B3yT0A9qZLJsDRye7LslCetcvyXpG8B1hEGyv0Pod5jzDPCtHkT7IfABcCfwb+DH\n", + "yfahwAdmlt+vcQEwWJJ3RXHOucoYFkVRrl/3a8CwAmHWAl5Krb+cbMv3TeBflc1euywr/gj4hZn9\n", + "uMj+B4G/SPoZoQN9oXnWnesvTgXONbOTkwbaxal9jxMeJinXNsBgwg+yM4A/AN/tbUadc861i+N4\n", + "GuEhwHynpleiKLI4jgs9cNjtQ4hxHJ8KLImi6PKe5bJ7WTYQPw1MLSHcv4DjqpwX5+rdOoS+JoUs\n", + "BlYsN0Iz+0/y9h5JbwKXJD/IFgBDJCnvKuJQYKGZtRSKT9LE1OoMM5tRbp6cc66vkTQaGF1sfxRF\n", + "Y4rti+P4tTiOV4+i6NU4jtcAXi8QbB4wPLU+nHAVMRfHYcBewC5lZbxMWTYQnyWM7Tazm3D70bkv\n", + "lHP9zcuEvoK3F9i3OeF86o1Hktd1CLexm4H16XjujUr2FWRmE3uZB+ec63OSH8MzcuuSojIOvx44\n", + "lDDs2KHAtQXCzAI2iON4BDCf0Bd8PHz8dPOJwE5RFC0uO/NlyPIp5tOA70maLukISTtK2jRZdki2\n", + "TSMMq3Fahvlyrh5NBiJJhwCDkm1NknYl9B38Uy/j3z55nQPcS+j/+3HfX0mDgX2Bm3qZjnPOuXaT\n", + "gDFxHD8N7JysE8fxmnEcTwWIoqiF0Ba6BXgCuDKKotyP9d8CQ4BpcRw/Esfx+dXKqDr3S68eSV8g\n", + "jKk2mvYhNnKWAncAZ5nZv0uIy8xM3YVzFdTWZjQ1SRprZtcL2r+HWLKoH34f1fo7lNREqAiOBNoI\n", + "V/haktc/mtn3yojrZmAaoaJpJTQOfwjcYGYHJ2FOJpybJwJPJfu3BDY2szcKxOnnn3PO0bj1YaZP\n", + "J5rZ3cDukpYF1iP0cYLQB+o5M/soy/w4V6/MrI1wxf1XhH4mqxHGLrzdzJ4qM7oHgMOAEYRG5nOE\n", + "YRVyw9xgZpOSRukE2qfaG1Ooceicc67xZXoFsZIatcVe1/wKYifV+DuUNAh4FxhnZoX6p9Scn3/O\n", + "ORc0an1Yd+ObSRpOaLi+WOu8uE4W0NZmK6+8vEljk18WA02SAUxMXruLw8xWqWIe+zwzWyTpdcLV\n", + "Pueccy5zdXcFUVILIV/N3YRryBZ7n5BcSQTIXU0s9Qpio31vVeyDeDqwA7CPmS2pdPy91Wjfo3PO\n", + "9VSj1od1dwWRMDJ4w33QzpVpJWATYI6k2wgj7nf4NdfFoPPOOedcr9RdA9HMLi01rA/U67LW3QCp\n", + "FXQA8BHhx9IO+dkgNBa9geicc64q6q6BWA4fqNdlrZcDpJaTzohqxOucc86VIsuBspH0ZUlXJMvo\n", + "ZNvukh6V9IGk/0o6Mss8Oeecc865jjK7gijpYOCvhCm+3gVulnQ4cBHwT+AywhRi50tqNbPezhTh\n", + "XJ8mScAXgA2A5fL3m1nVRtB3zjnXv2V5i/lHhBkgjgaQdBgwBTjPzE7KBZI0Hzia3k8l5lyfJWkY\n", + "YR7mDbsI5g1E55xzVZHlLeYNgL+n1q8hTLc3NS/cVGD9rDLlXJ36BeFK+/BkfRtgXcI85U8DI2uU\n", + "L+ecc/1Alg3Ed4HVU+ufzHvNWS0J61x/thNwLvBqboOZvWBmZxO6Y5R89VDSOElTJc2X9L6kWZK+\n", + "WiDcKZJekrRQ0kxJn61EQZxzzvU9WTYQbwPOkrS3pB0It5DvBSJJ6wFIGgmcAdydYb6cq0crA2+a\n", + "WSvwHh1/SN0DbFdGXMcT5js/DtgXuAO4XNIxuQCSJhCuTv4U2Af4AJie3Op2zjnXz2TZQJwAvA/c\n", + "AMwkjOW2F/A28IykD4HZhM74EzLMl3P1aA6wdvL+CeCQ1L59COdNqfYxs0PM7Gozm2FmJwJ/A34I\n", + "IGk54GTgbDM738xuBw4kjLV4TNFYnXPONazMHlIxs/mSNgdGEabSexxA0i7AfsB6hH+KU81sYVb5\n", + "cq5O/QsYA1wOnAVcL+llwvzMnwJO6uLYDsysUGPyP8BXkvfbASsAV6WOWSjpBmBP4PSeFMA551zf\n", + "lelA2WbWRrgaktZGuEpxhJk9k2V+nKtXZnZy6v1NkrYDvgwMAm41s5t6mcS2wFPJ+1FAK5B//s0G\n", + "DuplOs455/qgephJpYnQIX+FWmfEuXplZg8CD1YirtRV+8OTTUOBD8zM8oIuAAZLGmBmLZVI2znn\n", + "XN9QDw1E51wRknYHtgTWAF4BHjCzW3sR3wjCbetry5n33DnnXP/iDUTn6pCkNYFrgS2A15NlGPAJ\n", + "SQ8BXzKzeWXGuQpwE6Gv79dSuxYAQyQp7yriUGChXz10zrn+p+YNRDNrkbQzYfBf51xwIWHc0C+Y\n", + "2T25jZK2B65I9u9damSSBgM3Es75fcxscWr3bKCZMEB9uh/iKODJLuKcmFqdYWYzSs2Pc865+lbz\n", + "BiKA/2NxrpOdgW+lG4cAZvZvSScBk0uNSNIAwixG6wHbmdmbeUHuIYy1OA74SXLMYMKYiX8sFq+Z\n", + "TSw1D8455/qWumggOuc6eR1YVGTfIuCNMuI6nzBczfcJt6g/kdr3sJktljQJOF3SAsLTzT9M9v+2\n", + "vGw755xrBN5AdK4+nQ3EkmaZ2cu5jZKGA3Gyv1RjCINe/zpvuxHmd37RzCZJaiIMUr8q4YnpMWZW\n", + "TkPUOedcg/AGonP1aQyhofacpIdpf0jl84Srh7skw9UIMDMbVywiM1u3lASTeZ7LaXg655xrUN5A\n", + "dK4+fYLwwMizyfpKwGJCf8HcfkgaiNlmzTnnXKPzBqJzdcjMRtc6D8455yorjuNVgCuBdYC5wLgo\n", + "it4pEG4P4DzCCBOToyg6J2//CcDPgdWiKCo0nWqvNVUjUuecc84518nJwLQoikYCtyXrHcRx3Az8\n", + "DtgD2AgYH8fxhqn9wwndkF6oZka9gehcnZK0qaS/SXpO0kJJz0q6XNJna50355xzPTIWuCR5fwnw\n", + "pQJhtgKejaJobhRFSwlj3+6X2v9L4MdVzSXeQHSuLkn6EvAQsBlhDMPTgX8QHlJ5UNKXa5g955xz\n", + "PTMsiqLXkvevER4+zLcW8FJq/eVkG3Ec7we8HEXRY1XNJd4H0bl6dQ5wHXBgevo7SROAq4BJwD9r\n", + "lDfnnHNFxHE8jTATVr5T0ytRFFkcx4UeMiz44GEcx4OAUwi3l3PU03x2xxuIztWn4cBxeXMjY2Zt\n", + "kibjjUPnnKsJSaOB0cX2R1E0pti+OI5fi+N49SiKXo3jeA3CEGb55hH+B+QMJ1xFXA8YATwaxzHA\n", + "2sBDcRxvFUVRoXh6xRuIztWnh4CNgVsK7Ns42e+ccy5jyfTAM3LrkqIyDr8eOJRwl+hQ4NoCYWYB\n", + "G8RxPAKYDxwEjI+i6ElSt6TjOJ4DbO5PMTvXv/wA+J6kkyV9RtLQ5HUCcBRwvKTBuaXGeXXOOVea\n", + "ScCYOI6fBnZO1onjeM04jqcCRFHUAhxDuEDwBHBl0jjMV9UxcJV3B6vPkGRmVrV7764LbW1GU5MA\n", + "pLFmdr1iyaISvo9G+96qVR5JbWUENzNrrnQeutJo36NzzvVUo9aHfovZufr0zUpFJGl94ERgW8Lt\n", + "6TvN7IsFwp1CuDqZm4v5ODN7tFL5cM4513d4A9G5OmRmU7raL2mgmS0tMbqNgD2BewnnfKfbBsmt\n", + "69OAHwGzgROA6ZI2MbPX8sM755xrbN4H0bk+QlKTpF0l/ZkwflapbjCzT5nZQYT+LPnxLkcYzf9s\n", + "MzvfzG4HDiQ0JI+pRN6dc871Ld5AdK7OSdpW0m8IQx/cShiJ/2+lHp8/VE4B2wErEMZXzB2zELiB\n", + "cOXROedcP+O3mJ2rQ5I2BcYDXyVM6v4RsCzwQ+B3ZtZSweRGAa3AM3nbZxOGV3DOOdfPeAOxn5H0\n", + "NjC0AlGlZ/cwgInJazcWVCDthiRpPUKjcDywIfAuMJXQH/A+wkCpD1e4cQjh7+GDAlcaFwCDJQ2o\n", + "QprOOefqmDcQ+5+hZiZprFnrteSGq+mtUoe5cV16BlgEXE54WGR67kEUSSvXMmPOOef6F28gOlc/\n", + "XiDcTt4JeCtZHsgg3QXAECWDeaW2DwUWFrt6KGlianVGMruAc865BuANROfqhJmtK2lbwi3mw4Af\n", + "S5pHmIrptiomPRtoBtanYz/EUUCh0fsBMLOJVcyTc865GvKnmJ2rI2Z2r5kdB6wF7EZ4avkQ4Jok\n", + "yBGStqxwsvcA7wHjchuS6fv2BW6qcFrOOef6AL+C6FwdMrNWYDphsOqjCMPNjAe+DBws6WkzG1VK\n", + "XJIGAXsnq2sBK0g6IFmfamaLJE0CTpe0AHiK8LQ0wG8rUyLnnHN9iTcQnatzZrYEuA64TtLywH6E\n", + "4W9KNYz2MQ5zfQyvSt6vC7xoZpMkNQETaJ9qb4yZvVGBIjjnnOtj1P0YuhVOUNqFcDVkFKETvBE6\n", + "yc8GbkpmcSglnoacHLvacp+bP8VcGf3177C/lts55/I1an2YWR9ESatIuhOYRrhNBjAHmJvkY3/C\n", + "7bSZklbJKl/OOeecc66jLG8x/4Zwq2trM3uwUABJWwCXJWEPyTBvzjnnnHMukWUDcR/gsGKNQwAz\n", + "myXpJOCS7LLlnHPOOefSshzmpg0o5R69krDOOeecc64GsmwgXgecK+kLxQJI2h44F/hnZrlyzjnn\n", + "nHMdZHmL+XjC0Bp3SnqV8NTyO8m+lQlPNa9OGBj4BxnmyznnnHPOpWTWQDSzd4Hdk6nE0sPcALwB\n", + "3EUY5ua+rPLknHPOOec6y3ygbDO7F7g363Sdc84551xpfC5m55xzzjnXQd01ECVNlnRRrfPhXH8j\n", + "aSNJt0n6UNI8SXEy/Z5zzrl+ph7nYh4NNNc6E871J5KGAtOB/wFjgfWBXxB+RJ5ew6w555yrgbpr\n", + "IJrZ+rXOg3P90JHAssD+ZvYBcJukFYGJkn5mZu/XNnvOOeeyVHcNROdcTewJ3JI0DnOuBM4BdgJu\n", + "rEmunHOugcRxvAqhbl0HmAuMi6LonQLh9gDOI9xRnRxF0TmpfccCRwOtwNQoik6qRl4z718kaQVJ\n", + "+0g6QdL/JcsJkvaWNCTr/JRC0uhGTGvGjBlZJdWwn2ED+QxhbNKPmdmLwMJkX7/QqH87Xq6+xcvV\n", + "0E4GpkVRNBK4LVnvII7jZuB3wB7ARsD4OI43TPZ9kdANaNMoijYhTC5SFZk1ECU1SToLeBW4HoiB\n", + "Q5MlBm4AXpV0pqRSpuTL0uhGTGvGzJlZJQUN+hk2kKG0D1yftoD28Ur7g9G1zkCVjK51BqpkdK0z\n", + "UCWja52BKhld6wzUgbHAJcn7S4AvFQizFfBsFEVzoyhaClwB7JfsOwr4abKdKPme9o0AABSOSURB\n", + "VIreqFZGs7yCGBFmSJkIjDCzIWY2PFmGEC63TkyF6ZVCv1TS2wq9L/Rayi+evpgWvNldUmWlNaeL\n", + "NBv1M/Rfw91/bqWuF9tWyr6ehCsnHi+Xl6uUfT0JV048Xq76L1eJhkVR9Fry/jVgWIEwawEvpdZf\n", + "TrYBbADsGMfxfXEcz4jjeItqZTTLBuK3gRPM7OfJrasOzOwlMzsXOCEJ21uju9lW6H2h10LxNEBa\n", + "b5WQVOlpze06zULx9DitImnUa1p9xQJgpQLbhyb7ihldwvtS1ottK2VfT8KVE0+x96WsF9tWyr6e\n", + "hCsnnmLvS1kvtq2UfT0JV048xd6Xsl5sWyn7ehKunHiKvS9lvdi2Uvb1JFw58RR7X8p6sW2l7OtJ\n", + "uJLEcTwtjuP/FljGpsNFUWSAFYii0LacAcDQKIq2AU4kTGFcFTLrKh8VTEj6EBhrZrd1E24X4AYz\n", + "G9xNuGwy7lw3zKzeukSUTdJMYJ6ZHZzaNhx4AdjXzKbmhffzzznnEqX+H4jjeDYwOoqiV+M4XgO4\n", + "I4qiUXlhtgEmRlG0R7I+AWiLouicOI5vAiZFUTQz2fcssHUURSVd9SlHlk8x3wecJOn+vCclP5Y8\n", + "pHISJUzF1wj/lJ2rIzcBJ0oakjo/DyI8pNKps6qff8451yPXE569OCd5vbZAmFnABnEcjwDmE+ri\n", + "8cm+a4GdgZlxHI8ElqlG4xCyvcV8LLAJ8IKkyyWdIem4ZDld0uWEqxWbAMdkmC/nHPwR+Ai4RtIu\n", + "ko4g9Bv+ZbEfdM4558o2CRgTx/HThIbeJIA4jteM43gqQBRFLYR20C3AE8CVURQ9mRx/EfDpOI7/\n", + "C/wN+Ea1MprZLWb4eLaGIwljrn2G9qcjFxCG2LgJ+KOZFXqa0jlXRZI2JAytsC3hnJwMTLQsKwnn\n", + "nHN1IdMGYtYk/QHYF1jTzKp2tVTSJsClwBDgSeBr1brqkmGZhgNTgDWANmCqmVVlMM4kvZmEhySa\n", + "gOeBw82sq4cjKpHm74Gjqvw5zgU+BJYkm8ab2eziR/R9tfguqy3r8yFLWdUpWcuyXs5aA39nDXme\n", + "9dU6sWH+sIq4DPh8Bun8ETjFzEYSroT+uIppZVWmpcCJZrYR8Dlga0n7VzG9fcxsMzPbFHiO6n6G\n", + "SNoBWJ6unxarBAP2NLPPJUtDNw4TmX6XGcn6fMhSVnVK1rKsl7PWqN9Zo55nfbJOrLsGoqTNJV1U\n", + "ibjM7G4ze70ScRUjaRhhXMebk01/Br5SrfSyKFOSzqtm9nDyfinwGLB2FdN7H8KA6oRf/FUb/FPS\n", + "ssBPgR8BWTxs0a8e6Mjyu8xK1udDlrKqU7KUdb2ctUb8zqBxz7O+WifWXQMRWBc4rNaZKMPahEEs\n", + "c14ChtcoL1UhaVXCaO+3VDmdfxFm2tkE+H0VkzoDmGxm3Y8WXhnXSfqPwrSS/WL+8wy/y8xldT64\n", + "Xmn4ernRNdp51hfrxCyn2ttJ0o5FlvGSrpP0HGHQx4JXXCRtJOk2SR9KmicpTlrkPcnP+pIukPSY\n", + "pFZJd/QwzW6vDlUwrSzLlQu3LHA18Csze6qaaZnZXsDqwN3Ar6uRlqRNga3MbIpUeErHCpdrezPb\n", + "DNieMKfmjwrFVWtZfpdZyvJ8yFKWdUqWsqyXs9Co3xNUt2y1Os+qWaZ6qRPLkeXVjIIfdEqXJ7TC\n", + "E9DTgf8R5jJcH/gFoZF7ehLmW7QPkXO0mXU1nuJGhKep7yV8Dp36opWSJuFXavoS+Kfo+Mu1kmmV\n", + "omJpSWom9HV5yMx+Vc20csysTdKlhLknq5HWdsBGkuakjnse2NLMcmNJVaxcZjY/ef1Q0p+B7+bH\n", + "VSey/C6zlOX5kKUs65QsZVkvZ6Ei5Snzf1tWqlG2o4AHqd15VtXvq07qxNKZWSYLYW63y4CNCZdY\n", + "iy2Phmx1On5CEseQ1LYTCU+IrtBFugLaCm1Pvb8auL2naRJ+EeyZvP8ZcFa10uqqTFUo12Tgoq4+\n", + "20qkBawMDEvtPwO4uJqfYWp/1f42gMHAisn7AcDF+X8b9bJk+V32xXIl27o8H/pquXLxFatT+mq5\n", + "6KZe7mvlKRR3Lb+zKtbJNTvPqlGmeqsTy1myvIR9H6HT8ONm9r9iC2HmhkL2BG6xjsMUXAkMAnYq\n", + "dICkycCLgEl6SdKFuX2WfFPdKDXNo4CfSHoaGEWojD5WybS6KlOF0toxSWd74JvA5pIeSZYOA5hX\n", + "sFxDgRskPSrpUWAkYU7uaqSVr1O8FUxrdWBmUqb/EJ7Q+0kJcWcuy+8yS1meD1nKsk7JUpb1chaq\n", + "VW/Vw3dWjbLV+jyr0vdVV3ViObK8xTwV+HoJ4RYCrxTY/hnCZd2PmdmLkhYm+27MP8DMvt2DfJad\n", + "ppn9l94POVBqWr0tU3dpjSKMPfVvKtNHtdtymdkcYKss0so/wMyaq5WWmT1PGKqhUWT5XWYpy/Mh\n", + "S1nWKVnKsl7OQi3+t2WlrLL1kfOs3DL1xToRyPCLMLPzzWzbEoLmZlXJNxQoNMPKAtpnZKm0LNP0\n", + "tDyteteoZfZy9S2NVq5GK09aI5atEctUUM1b6pKaJd0uaYNa58U555xzztVBA5HQ0XY0sEI34RYQ\n", + "pqrJNzTZVw1ZpulpeVr1rlHL7OXqWxqtXI1WnrRGLFsjlqmgemgglmo2sGF6g8K8jYMpfEu6r6Xp\n", + "aXla9a5Ry+zl6lsarVyNVp60RixbI5apoL7UQLwJ2F3SkNS2gwgPtcxsgDQ9LU+r3jVqmb1cfUuj\n", + "lavRypPWiGVrxDIVVutxdpKnyncDDgEOIAxQ+b/k/QHAIGsfS2g+cCuwC3AE8D5wZg/THJRKo6pp\n", + "elqeVr0vjVpmL5eXy8vjZevPZerV51HrDCQf+AigLVlakyX3/lOpcBsCtxFa6vOAmNTAlvWapqfl\n", + "adX70qhl9nJ5ubw8Xrb+XKbeLEoK65xzzjnnHNC3+iA655xzzrkMeAPROeecc8514A1E55xzzjnX\n", + "gTcQnXPOOedcB95AdM4555xzHXgD0TnnnHPOdeANROecc84514E3EJ1zzjnnXAcN2UCUNFFSW2qZ\n", + "L+mfkkZWIa0Zkv5eRvhxkg7tbTzJMVMkPZha30pSVE4c3cSf/gw3zdu3qqRfSZorabGkeZL+LOlT\n", + "eeFGJMfvVal8dZHfuRWOL/13VNZ341y9KFAf5pZba523vkTS6NRntyC1vWgdlzpmozLSSX9HJR/n\n", + "XKUNqHUGquhdYPfk/brAmcB0SRua2YcVTOdIYGkZ4ccBqwKX9DIeCGVaLrW+FRARpv2plHOBq4Fn\n", + "chskrQncRfj7ORt4gjBF0Y+BWZJGm9kTFcxDUZLGAc+Y2SOAJdvWA3Y2sz/1Mvo/ESZmPz8Xt3N9\n", + "VLo+TG9z5TsYeLqK8W8DbA78voppONetRm4gtpjZA8n7B5KrS/cCexIaPBVhZrNrFY+ZPV+JtLsx\n", + "N/U55pwPrAhsamavJNvuknQtMAv4K/D5DPIGoeF6jqT/ActIOgXYCzittxGb2TxgnqT3exuXczXW\n", + "UuA8LkjSIDNbVO0M9WGPVfMHsJk9IGlwteJ3rlQNeYu5iMeS1xHpjZK+Lenx5DbpXEkn5u3fWNLN\n", + "kt6S9IGkJyQdndrf4dawpLUlXSXpNUkLJT0r6cxk3xRgf2Cn1C2EM/LjKXZbQtJQSUskfTMXX+4W\n", + "s6TDgN8k73Nx3y5pw+T9TnlxDUnKc2w5H6KkEcC+wK9TjUMAzOx94CfAZpJ2yDt0eUkXSHpH0kvJ\n", + "bS+l4p0o6Y3kNvms5LO7K7l9s4ak6yW9n3xXo1NpPmJmuwEDgTWALYAdzWxG3me5s6TrkjI/LWk3\n", + "SQMl/VLSm5JelnR8OZ+Fc31d6vbowZIuTW6dXp/sW0XShZJelbRI0r8lbZV3/MqSLk/OzfmSTpF0\n", + "rqQ5qTATJb1RIO02Sd/L29ZdfTxF0oOSxkh6LDmf7ypQVzZLmpCc64uTOufiZN/RSX6XzzsmV1f8\n", + "vx5+nN1S8dv9c7o/2rls9acGYq5vXLrvyImEq2HXAHsDfwDOyqu0biDc+v0aoWH0W2BIar/R8fbj\n", + "pcBawHeAPQgNpmWSfWcCdwAPE24jbANMLhDPncArhNvRaV9OwvwjL32AG4FfJO9zcR9tZk8C9wGH\n", + "5cV1IOEK8l8pzw6AgGuL7L8uFS7tZ8B7wFeSNM8ADsgLMxi4kFCO8YTv7K/AVcAMQvnnA1dLGgQg\n", + "6bOSbgZaCJ/ZQ8AMSTvmxX0B4XP9EvAC8PckreWArxKuKv8y/x+gc40iaTQNyC15u88l3HI+APiJ\n", + "pGWB6cDOwI8I580bhG46w1LHXUyo544HjgB2Aw6ic5eMYl00Pt5eYn1shHrhZ8BZhHrik8CVefFe\n", + "AEwErkjiOgEYlOy7DGimc/1zOPCQmf23SF670+HzTT7j5rwwf6K9ft4G2BV4E3iqh2k6Vz1m1nAL\n", + "oWJ4g3ByDgDWA6YB7wCfSMKsCHwAnJ53bExoaAhYDWgDNu4irRnAVan194G9uwh/NXB7CfGcBzyZ\n", + "F+YW4PrU+hTgwdT6MUBbgbi/leRr+dS2O9PpFclrG6GRmd52crJ9hS6OWwD8Pnk/Igk/JS/MI8Df\n", + "8r6zNmCH1Lajkm2npbZtmGzbPVk/CPhc8n5O8vpp4Ijk/egk/OkF4pie2qbke5/U3Xfjiy99aUmd\n", + "W/nLzqnz8x95x3wL+AhYL7WtGXgW+FmyvnFy7IGpMMsDbwHP56X/RoF8fVy/UEJ9nKxPIfxgT+dr\n", + "vySukcn6qGT9mC4+k78AM1LrQ5I68ugujsnVJRvlbc99hl0tGxWJ80rgZeCTpaTliy9ZLo18BXFV\n", + "QkWyhNBPbUtgTzPL3erYlnDF6uq8X3x3AMOAtYG3gZeACxSePv5kCen+B5gk6VDlPdFbpiuBzyh5\n", + "eljSasAX6fxLuRRXJa8HJnGtB2xP+PWflfwnJp8kfMZpS8zsrtT6c8nr7QW2rQVgZldaeEAFkqsR\n", + "Zva8mV2YF/dtXcVrZgY8D6zZTTmc64veJXS/SC/pPolT88LvSrgaPzdVN4rww3KLJMyWyWvurgEW\n", + "HgCcloQtRyn1cc4cM3sutf5k8poL88XkdUoX6f0Z2EHSusn6OMLFhMvLzHfa8XT+jI8sFljSSYQr\n", + "sweY2eu9SNe5qmjkBmKuQtwa+C6hwvp2av9qyevjhEZkbrmd0NAYbmZthFsmrwIXAa9IulPSZl2k\n", + "exDhQY1fESrXRyTt3IP83we8mMQH4dZsC8Vv7RZloW/gVYRbKBBuN78C3NyDfM1LXkcU2ilpJWCl\n", + "VLicd/LWl9DxCWwIv+Dzw3Q41sxy2/KPxcw+XTDHxePIz9PSQvE61wBazOzhvOWD1P7X8sKvRrgF\n", + "mvuRnVsOo70htjrwfup8yunU37AE3dbHqbCF6hJoP3dXBT7MK18HFvooP09715vDgWvNLD/ucjyb\n", + "/xlT5GlnSbsRuh8db2b39SJN56qm0Z9ifjh5/6CkRcClki43s9sIVwch9E/JrxwhObHN7CngAEnN\n", + "wI7AOYRf22sVStTM5pM0xCRtTbi9cr2k4Wa2oNAxReIxSVcRftmeSmgo/st6PkTPZOBuSesD3wAu\n", + "Ta6aletOQoU9FijUV2dsKpxzrm/IrwveIvzQLXQF7KPk9VVgBUnL5DUS8++0LKa9HzYQHrjLC1NS\n", + "fZw7vMD+tLcID8UN6aqRSPjRf4Skywh3VPboJt6KkPRp4G/AX8zsD1mk6VxPNPIVxA7M7K+EX6e5\n", + "gaTvBRYBaxX4ZZ3/6xozazWzOwhXBteQtHIJad5PeDBlMLBOsnkJ7Z2lOwQvsO0KYD1J+xAap1d0\n", + "k+QSgKSDeX5e7iV0hL6Y8Gt8Snf5L8TMXiA85Xi8pNXT+yQNIQwv84iZ3d2T+GvMxzp0LrgNWB94\n", + "qUDd+HgSJjdI/5dyByV1wBg6nksvExqS6e4bu+WlV0593N15mus60mlCgjxTCFdDJyd5nNZN+F5L\n", + "npz+J+Hq5XernZ5zvdHIVxALORu4TNIXzOxuSROBX0tahzDwcxMwEhhtZvsn/f/OJTTM5gBDgZOA\n", + "/+TdihB8fHv1FsIg2M8AyxKennuF9n4yTwJjJe1HuA07z8JwMSLvl7GZPSzpWcLTtgsJTyp3JZfG\n", + "9yXdAbyXXAHN+TPwc+AeM+vNQK9HEz6v+yT9NEl3HcJA2SuT+ofRx3T6Dpzrpy4lXD2cIelcQv23\n", + "KmEw/lfM7Dwze1zS9cAfJK1IuKJ4IpB/l+MmQuPvIkm/JExc0KFxZGbvdFcfp4J3eY6a2VOSLgR+\n", + "kfQbv4tQL33FzManwr2SjICwN3B2D++olOtXhIfkDgE+r/aRvj5K9aV2ri406hXE/KFncq4kNNwm\n", + "AJjZzwlDM+xJ6Nt3OWHYhNzt0VcIld6pwL8II9s/Tvtt1Py0FhHGW/w+oeP2FMKTebuZWe62zPmE\n", + "BzYuInQS/04JeR4G3GBmi7sqZ/KAx8+T9O8jDBORlutMflGBdEqWNGi3IgxHcTLhl/c5hPJsYWFo\n", + "nfx8doomb3ux8lei0i41jmrmwblaKfZ3nd7fcUOor75IOLdjwg/f8wgjQtyfCnoYoT47jzCEyzTC\n", + "D2ql4nqL0Id6bcLVs4OTJT/N7urjrsqSv+3oJN+HELoE/YrODVdorxN7+8BeqZ/vBoSnwa8A7kkt\n", + "/yhwnHM1pWx+NLl6oDDA9znAGt30zcmFbyM0Nv9gZi3Vzl+9Ufh530y43fa6mR1Y4yw5V/eSK45f\n", + "MbN1uw1cY0k/72FmtlMJYUcTbl9vBjxuZq1VytMAYCdCY3sTy2jaUufyNeoVRJeiMFvCbsApwMWl\n", + "NA5Tfg0syQ23089EhH6dO+BXEZ1rGJL+n6TDCYPv/7rMw/9Dz57ULtUSQuPQ6xxXU/2tD2J/NZFw\n", + "q2YGcHoZx21JeyVVzcnp69UFJNOO0f6UpXOua93d0q4H1xP6VP7ezK4p8ZhZtI8BWc07Kluk3j9X\n", + "NJRzVea3mJ1zzjnnXAd+i9k555xzznXgDUTnnHPOOdeBNxCdc84551wH3kB0zjnnnHMdeAPROeec\n", + "c8514A1E55xzzjnXwf8HOnyht85O8qsAAAAASUVORK5CYII=\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotMT1DModelData(problem,[mopt,moptc,moptc1])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "modelList = [problem.survey.mtrue]\n", + "modelList.extend([mopt])\n", + "# problem.mapping.sigmaMap*mopt" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[['zyxr'], ['zyxi']]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "src = survey.srcList[0]\n", + "[[rx.rxType.replace('z1d','zyx')] for rx in src.rxList ]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'zyxr'" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'z1dr'.replace('z1d','zyx')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/MT1D inversion test.ipynb b/notebooks/MT1D inversion test.ipynb index b234c0fc..256cdaf0 100644 --- a/notebooks/MT1D inversion test.ipynb +++ b/notebooks/MT1D inversion test.ipynb @@ -25,12 +25,12 @@ "\n", "# Frequency\n", "nFreq = 33\n", - "# freqs = np.logspace(3,-3,nFreq)\n", - "freqs = np.array([100,10,1,0.1,0.01])\n", + "freqs = np.logspace(3,-3,nFreq)\n", + "# freqs = np.array([100,10,1,0.1,0.01])\n", "# Make the mesh\n", - "ct = 5\n", - "air = simpeg.Utils.meshTensor([(ct,25,1.3)])\n", - "core = np.concatenate( ( np.kron(simpeg.Utils.meshTensor([(ct,15,-1.2)]),np.ones((10,))) , simpeg.Utils.meshTensor([(ct,20)]) ) )\n", + "ct = 10\n", + "air = simpeg.Utils.meshTensor([(ct,15,1.3)])\n", + "core = np.concatenate( ( np.kron(simpeg.Utils.meshTensor([(ct,15,-1.2)]),np.ones((5,))) , simpeg.Utils.meshTensor([(ct,5)]) ) )\n", "bot = simpeg.Utils.meshTensor([(core[0],10,-1.3)])\n", "x0 = -np.array([np.sum(np.concatenate((core,bot)))])\n", "# Change to use no air\n", @@ -38,20 +38,24 @@ "\n", "## Setup model varibles\n", "active = m1d.vectorCCx<0.\n", - "layer = (m1d.vectorCCx<-200.) & (m1d.vectorCCx>=-600.)\n", + "layer1 = (m1d.vectorCCx<-200.) & (m1d.vectorCCx>=-600.)\n", + "layer2 = (m1d.vectorCCx<-2000.) & (m1d.vectorCCx>=-4000.)\n", "actMap = simpeg.Maps.ActiveCells(m1d, active, np.log(1e-8), nC=m1d.nCx)\n", "mappingExpAct = simpeg.Maps.ExpMap(m1d) * actMap\n", "sig_half = 2e-3\n", "sig_air = 1e-8\n", - "sig_layer = 1e-3\n", + "sig_layer1 = 1\n", + "sig_layer2 = .1\n", "# Make the true model\n", "sigma_true = np.ones(m1d.nCx)*sig_air\n", "sigma_true[active] = sig_half\n", - "sigma_true[layer] = sig_layer\n", + "sigma_true[layer1] = sig_layer1\n", + "sigma_true[layer2] = sig_layer2\n", "m_true = np.log(sigma_true[active])\n", "# Make the background model\n", - "sigma_0 = np.ones(m_true.size)*sig_half\n", - "m_0 = np.log10(np.ones(m_true.size)*sig_half)\n", + "sigma_0 = np.ones(m1d.nCx)*sig_air\n", + "sigma_0[active] = sig_half\n", + "m_0 = np.log(sigma_0[active])\n", "\n", "# Receivers \n", "# 1D impedance at the surface (elevation 0)\n", @@ -69,9 +73,11 @@ " srcList.append(simpegmt.SurveyMT.srcMT_polxy_1Dprimary(rxList,freq,sigma_0))\n", "# Make the survey\n", "survey = simpegmt.SurveyMT.SurveyMT(srcList)\n", - "survey.mtrue = sigma_true\n", + "survey.mtrue = m_true\n", "# Set the problem\n", "problem = simpegmt.ProblemMT1D.eForm_psField(m1d,mapping=mappingExpAct)\n", + "from pymatsolver import MumpsSolver\n", + "problem.solver = MumpsSolver\n", "problem.pair(survey)" ] }, @@ -81,20 +87,9 @@ "metadata": { "collapsed": false }, - "outputs": [ - { - "data": { - "text/plain": [ - "180" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "np.sum(active)" + "# problem.mapping.sigmaMap._transform(m_0)" ] }, { @@ -105,29 +100,27 @@ }, "outputs": [ { - "ename": "Exception", - "evalue": "Unexpected shape of tensor", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mException\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 1\u001b[0m \u001b[1;31m## Make the observed data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;31m# Project the data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0md_true\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msurvey\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[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0msurvey\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtrue\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0md_true\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;31m# Add noise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpeg/SimPEG/Utils/CounterUtils.pyc\u001b[0m in \u001b[0;36mwrapper\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 81\u001b[0m \u001b[0mcounter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'counter'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 82\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcounter\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mCounter\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m'.'\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 83\u001b[1;33m \u001b[0mout\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 84\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 85\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpeg/SimPEG/Utils/codeutils.pyc\u001b[0m in \u001b[0;36mrequiresVarWrapper\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 224\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvar\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 225\u001b[0m \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mextra\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 226\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 227\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 228\u001b[0m \u001b[0mdoc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrequiresVarWrapper\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__doc__\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpeg/SimPEG/Survey.pyc\u001b[0m in \u001b[0;36mdpred\u001b[1;34m(self, m, u)\u001b[0m\n\u001b[0;32m 306\u001b[0m \u001b[0mWhere\u001b[0m \u001b[0mP\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0ma\u001b[0m \u001b[0mprojection\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mfields\u001b[0m \u001b[0monto\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdata\u001b[0m \u001b[0mspace\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 307\u001b[0m \"\"\"\n\u001b[1;32m--> 308\u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mu\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mNone\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mu\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprob\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[0m\n\u001b[0m\u001b[0;32m 309\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mUtils\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmkvc\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[0mu\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 310\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpegmt/simpegMT/ProblemMT1D/Problems.pyc\u001b[0m in \u001b[0;36mfields\u001b[1;34m(self, m)\u001b[0m\n\u001b[0;32m 102\u001b[0m \u001b[0msys\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstdout\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mflush\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 103\u001b[0m \u001b[0mA\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgetA\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 104\u001b[1;33m \u001b[0mrhs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgetRHS\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 105\u001b[0m \u001b[0mAinv\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mSolver\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mA\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msolverOpts\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 106\u001b[0m \u001b[0me_s\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mAinv\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mrhs\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpegmt/simpegMT/ProblemMT1D/Problems.pyc\u001b[0m in \u001b[0;36mgetRHS\u001b[1;34m(self, freq)\u001b[0m\n\u001b[0;32m 74\u001b[0m \u001b[1;31m# Get sources for the frequncy(polarizations)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 75\u001b[0m \u001b[0mSrc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msurvey\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgetSrcByFreq\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 76\u001b[1;33m \u001b[0mS_e\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mSrc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mS_e\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 77\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1j\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0momega\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mS_e\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 78\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpegmt/simpegMT/SurveyMT.pyc\u001b[0m in \u001b[0;36mS_e\u001b[1;34m(self, problem)\u001b[0m\n\u001b[0;32m 244\u001b[0m \u001b[0mGet\u001b[0m \u001b[0mthe\u001b[0m \u001b[0melectrical\u001b[0m \u001b[0mfield\u001b[0m \u001b[0msource\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 245\u001b[0m \"\"\"\n\u001b[1;32m--> 246\u001b[1;33m \u001b[0me_p\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mePrimary\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mproblem\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 247\u001b[0m \u001b[0mMap_sigma_p\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMaps\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mVertical1DMap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mproblem\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmesh\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 248\u001b[0m \u001b[0msigma_p\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mMap_sigma_p\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_transform\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msigma1d\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpegmt/simpegMT/SurveyMT.pyc\u001b[0m in \u001b[0;36mePrimary\u001b[1;34m(self, problem)\u001b[0m\n\u001b[0;32m 227\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mePrimary\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mproblem\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 228\u001b[0m \u001b[1;31m# Get primary fields for both polarizations\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 229\u001b[1;33m \u001b[0meBG_bp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhomo1DModelSource\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mproblem\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmesh\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msigma1d\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 230\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0meBG_bp\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 231\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpegmt/simpegMT/Sources/backgroundModelSources.pyc\u001b[0m in \u001b[0;36mhomo1DModelSource\u001b[1;34m(mesh, freq, sigma_1d)\u001b[0m\n\u001b[0;32m 22\u001b[0m \u001b[0mmesh1d\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msimpeg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mMesh\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTensorMesh\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mmesh\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhz\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mmesh\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx0\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\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[0;32m 23\u001b[0m \u001b[1;31m# # Note: Everything is using e^iwt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 24\u001b[1;33m \u001b[0me0_1d\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mget1DEfields\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmesh1d\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0msigma_1d\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 25\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mmesh\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdim\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 26\u001b[0m \u001b[0meBG_px\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m-\u001b[0m\u001b[0msimpeg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmkvc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0me0_1d\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpegmt/simpegMT/Utils/MT1Dsolutions.pyc\u001b[0m in \u001b[0;36mget1DEfields\u001b[1;34m(m1d, sigma, freq, sourceAmp)\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[0mMmu\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msimpeg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mUtils\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msdiag\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mm1d\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvol\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1.0\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0mmu_0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 13\u001b[0m \u001b[1;31m# Conductivity\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0mMsig\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mm1d\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgetFaceInnerProduct\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msigma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 15\u001b[0m \u001b[1;31m# Set up the solution matrix\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[0mA\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mG\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mMmu\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mG\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1j\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m2.\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mfreq\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mMsig\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpeg/SimPEG/Mesh/InnerProducts.pyc\u001b[0m in \u001b[0;36mgetFaceInnerProduct\u001b[1;34m(self, prop, invProp, invMat, doFast)\u001b[0m\n\u001b[0;32m 20\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;32mreturn\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mM\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mthe\u001b[0m \u001b[0minner\u001b[0m \u001b[0mproduct\u001b[0m \u001b[0mmatrix\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mnF\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnF\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 21\u001b[0m \"\"\"\n\u001b[1;32m---> 22\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_getInnerProduct\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'F'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mprop\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minvProp\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minvProp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minvMat\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minvMat\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdoFast\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdoFast\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 24\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mgetEdgeInnerProduct\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minvProp\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minvMat\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdoFast\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpeg/SimPEG/Mesh/InnerProducts.pyc\u001b[0m in \u001b[0;36m_getInnerProduct\u001b[1;34m(self, projType, prop, invProp, invMat, doFast)\u001b[0m\n\u001b[0;32m 54\u001b[0m \u001b[0mprop\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minvPropertyTensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 55\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 56\u001b[1;33m \u001b[0mtensorType\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTensorType\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 57\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 58\u001b[0m \u001b[0mMu\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmakePropertyTensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m/media/gudni/ExtraDrive1/Codes/python/simpeg/SimPEG/Utils/matutils.pyc\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, M, tensor)\u001b[0m\n\u001b[0;32m 272\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_tts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'tensor'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 273\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 274\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Unexpected shape of tensor'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 275\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0m__str__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 276\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;34m'TensorType[%i]: %s'\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_tt\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_tts\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mException\u001b[0m: Unexpected shape of tensor" - ] + "data": { + "text/plain": [ + "0.002" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" } ], + "source": [ + "sig_half" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], "source": [ "## Make the observed data \n", "# Project the data\n", @@ -150,19 +143,30 @@ "collapsed": false }, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], "source": [ "## Setup the inversion proceedure\n", "C = simpeg.Utils.Counter()\n", "\n", "# Set the optimization\n", - "opt = simpeg.Optimization.InexactGaussNewton(maxIter = 10)\n", + "opt = simpeg.Optimization.InexactGaussNewton(maxIter = 30)\n", "opt.counter = C\n", "opt.LSshorten = 0.5\n", "opt.remember('xc')\n", "# Data misfit\n", "dmis = simpeg.DataMisfit.l2_DataMisfit(survey)\n", "# Regularization\n", - "reg = simpeg.Regularization.Tikhonov(m1d)\n", + "# regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]])\n", + "# reg = simpeg.Regularization.Tikhonov(regMesh)\n", + "reg = simpeg.Regularization.Tikhonov(m1d,mapping=mappingExpAct)\n", "reg.alpha_s = 1e-5\n", "reg.alpha_x = 1.\n", "\n", @@ -174,7 +178,355 @@ "betaest = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)\n", "saveModel = simpeg.Directives.SaveModelEveryIteration()\n", "# Create an inversion object\n", - "inv = simpeg.Inversion.BaseInversion(invProb, directiveList=[beta,betaest,saveModel]) \n" + "inv = simpeg.Inversion.BaseInversion(invProb, directiveList=[beta,betaest])#,saveModel]) \n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "problem.mapping.sigmaMap.maps[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem will set Regularization.mref to m0.\n", + "SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same solver as the problem***\n", + "SimPEG.l2_DataMisfit is creating default weightings for Wd.\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + " 0 4.83e+05 1.46e+06 6.90e-07 1.46e+06 2.09e+05 0 \n", + " 1 4.83e+05 1.80e+05 5.76e-06 1.80e+05 2.64e+04 0 \n", + " 2 4.83e+05 1.29e+05 7.58e-06 1.29e+05 2.05e+04 0 Skip BFGS \n", + " 3 6.04e+04 1.10e+05 8.89e-06 1.10e+05 1.82e+04 0 Skip BFGS \n", + " 4 6.04e+04 5.48e+04 1.97e-05 5.48e+04 1.05e+04 0 Skip BFGS \n", + " 5 6.04e+04 4.57e+04 2.46e-05 4.57e+04 9.11e+03 0 Skip BFGS \n", + " 6 7.55e+03 4.04e+04 2.88e-05 4.04e+04 8.25e+03 0 Skip BFGS \n", + " 7 7.55e+03 2.22e+04 6.11e-05 2.22e+04 5.14e+03 0 Skip BFGS \n", + " 8 7.55e+03 1.81e+04 7.86e-05 1.81e+04 4.38e+03 0 Skip BFGS \n", + " 9 9.44e+02 1.58e+04 9.29e-05 1.58e+04 3.94e+03 0 Skip BFGS \n", + " 10 9.44e+02 8.37e+03 1.97e-04 8.37e+03 2.43e+03 0 Skip BFGS \n", + " 11 9.44e+02 6.71e+03 2.54e-04 6.71e+03 2.05e+03 0 Skip BFGS \n", + " 12 1.18e+02 5.78e+03 3.01e-04 5.78e+03 1.83e+03 0 Skip BFGS \n", + " 13 1.18e+02 3.04e+03 6.06e-04 3.04e+03 1.11e+03 0 Skip BFGS \n", + " 14 1.18e+02 2.42e+03 7.75e-04 2.42e+03 9.25e+02 0 Skip BFGS \n", + " 15 1.47e+01 2.09e+03 9.10e-04 2.09e+03 8.15e+02 0 Skip BFGS \n", + " 16 1.47e+01 1.21e+03 1.66e-03 1.21e+03 4.81e+02 0 Skip BFGS \n", + " 17 1.47e+01 9.97e+02 2.07e-03 9.97e+02 3.82e+02 0 Skip BFGS \n", + " 18 1.84e+00 8.79e+02 2.36e-03 8.79e+02 3.30e+02 0 Skip BFGS \n", + " 19 1.84e+00 6.16e+02 3.62e-03 6.16e+02 1.99e+02 0 Skip BFGS \n", + " 20 1.84e+00 5.31e+02 4.24e-03 5.31e+02 1.64e+02 0 Skip BFGS \n", + " 21 2.30e-01 4.79e+02 4.68e-03 4.79e+02 1.45e+02 0 Skip BFGS \n", + " 22 2.30e-01 3.38e+02 6.36e-03 3.38e+02 1.01e+02 0 Skip BFGS \n", + " 23 2.30e-01 2.80e+02 7.02e-03 2.80e+02 8.93e+01 0 Skip BFGS \n", + " 24 2.88e-02 2.32e+02 7.55e-03 2.32e+02 8.14e+01 0 Skip BFGS \n", + " 25 2.88e-02 1.53e+02 1.08e-02 1.53e+02 6.94e+01 0 Skip BFGS \n", + " 26 2.88e-02 8.67e+01 1.27e-02 8.67e+01 3.84e+01 0 \n", + " 27 3.60e-03 6.54e+01 1.40e-02 6.54e+01 3.13e+01 0 Skip BFGS \n", + " 28 3.60e-03 3.48e+01 1.69e-02 3.48e+01 2.06e+01 0 Skip BFGS \n", + " 29 3.60e-03 2.63e+01 1.86e-02 2.63e+01 1.07e+01 0 Skip BFGS \n", + " 30 4.50e-04 2.19e+01 2.17e-02 2.19e+01 7.17e+00 0 Skip BFGS \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 4.3709e+00 <= tolF*(1+|f0|) = 1.4560e+05\n", + "1 : |xc-x_last| = 2.1874e+00 <= tolX*(1+|x0|) = 5.9957e+00\n", + "0 : |proj(x-g)-x| = 7.1673e+00 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 7.1673e+00 <= 1e3*eps = 1.0000e-02\n", + "1 : maxIter = 30 <= iter = 30\n", + "------------------------- DONE! -------------------------\n" + ] + } + ], + "source": [ + "# Runn the inversion\n", + "mopt = inv.run(m_0)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'left': >,\n", + " 'right': >,\n", + " 'stopType': 'critical',\n", + " 'str': '%d : maxIter = %3d <= iter = %3d'}]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Setup the inversion proceedure\n", + "C = simpeg.Utils.Counter()\n", + "\n", + "# Set the optimization\n", + "optc = simpeg.Optimization.InexactGaussNewton(maxIter = 20)\n", + "optc.counter = C\n", + "optc.LSshorten = 0.5\n", + "optc.remember('xc')\n", + "# Data misfit\n", + "dmisc = simpeg.DataMisfit.l2_DataMisfit(survey)\n", + "# Regularization\n", + "# regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]])\n", + "# reg = simpeg.Regularization.Tikhonov(regMesh)\n", + "regc = simpeg.Regularization.Tikhonov(m1d,mapping=mappingExpAct)\n", + "regc.alpha_s = 1e-5\n", + "regc.alpha_x = 1.\n", + "# Inversion problem\n", + "invProbc = simpeg.InvProblem.BaseInvProblem(dmisc, regc, optc)\n", + "invProbc.counter = C\n", + "# Beta cooling\n", + "betac = simpeg.Directives.BetaSchedule()\n", + "betaestc = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)\n", + "saveModel = simpeg.Directives.SaveModelEveryIteration()\n", + "# Create an inversion object\n", + "invc = simpeg.Inversion.BaseInversion(invProbc, directiveList=[betac,betaestc])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem will set Regularization.mref to m0.\n", + "SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same solver as the problem***\n", + "SimPEG.l2_DataMisfit is creating default weightings for Wd.\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + " 0 9.87e+02 2.19e+01 2.35e-02 4.51e+01 3.23e+01 0 \n", + " 1 9.87e+02 2.38e+01 1.74e-02 4.09e+01 7.61e+00 0 \n", + " 2 9.87e+02 2.30e+01 1.79e-02 4.06e+01 2.68e+00 0 \n", + " 3 1.23e+02 2.28e+01 1.79e-02 2.50e+01 1.54e+01 0 \n", + " 4 1.23e+02 2.07e+01 2.24e-02 2.35e+01 5.36e+00 0 \n", + " 5 1.23e+02 2.03e+01 2.22e-02 2.30e+01 6.78e+00 0 Skip BFGS \n", + " 6 1.54e+01 2.00e+01 2.33e-02 2.03e+01 7.34e+00 0 Skip BFGS \n", + " 7 1.54e+01 1.95e+01 3.01e-02 2.00e+01 7.09e+00 0 \n", + " 8 1.54e+01 1.92e+01 3.30e-02 1.97e+01 5.00e+00 0 \n", + " 9 1.93e+00 1.91e+01 3.72e-02 1.91e+01 5.68e+00 0 \n", + " 10 1.93e+00 1.88e+01 6.62e-02 1.89e+01 8.43e+00 1 \n", + " 11 1.93e+00 1.82e+01 1.12e-01 1.84e+01 5.37e+00 0 \n", + " 12 2.41e-01 1.81e+01 1.21e-01 1.81e+01 5.14e+00 0 \n", + " 13 2.41e-01 1.80e+01 1.18e-01 1.80e+01 3.93e+00 0 \n", + " 14 2.41e-01 1.80e+01 1.43e-01 1.80e+01 6.08e+00 0 \n", + " 15 3.01e-02 1.78e+01 1.19e-01 1.78e+01 4.97e+00 1 \n", + " 16 3.01e-02 1.78e+01 1.13e-01 1.78e+01 2.41e+00 0 Skip BFGS \n", + " 17 3.01e-02 1.78e+01 1.37e-01 1.78e+01 4.47e+00 0 \n", + " 18 3.77e-03 1.76e+01 1.28e-01 1.76e+01 6.24e+00 0 Skip BFGS \n", + " 19 3.77e-03 1.76e+01 1.07e-01 1.76e+01 7.34e+00 0 \n", + " 20 3.77e-03 1.75e+01 1.25e-01 1.75e+01 6.14e+00 1 \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 4.7935e-02 <= tolF*(1+|f0|) = 4.6080e+00\n", + "1 : |xc-x_last| = 3.4384e+00 <= tolX*(1+|x0|) = 4.0560e+00\n", + "0 : |proj(x-g)-x| = 6.1413e+00 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 6.1413e+00 <= 1e3*eps = 1.0000e-02\n", + "1 : maxIter = 20 <= iter = 20\n", + "------------------------- DONE! -------------------------\n" + ] + } + ], + "source": [ + "mopt2 = invc.run(mopt)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "moptc=mopt2" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "## Setup the inversion proceedure\n", + "C = simpeg.Utils.Counter()\n", + "\n", + "# Set the optimization\n", + "optc1 = simpeg.Optimization.InexactGaussNewton(maxIter = 20)\n", + "optc1.counter = C\n", + "optc1.LSshorten = 0.1\n", + "optc1.remember('xc')\n", + "# Data misfit\n", + "dmisc1 = simpeg.DataMisfit.l2_DataMisfit(survey)\n", + "# Regularization\n", + "# regMesh = simpeg.Mesh.TensorMesh([m1d.hx[problem.mapping.sigmaMap.maps[-1].indActive]])\n", + "# reg = simpeg.Regularization.Tikhonov(regMesh)\n", + "regc1 = simpeg.Regularization.Tikhonov(m1d,mapping=mappingExpAct)\n", + "regc1.alpha_s = 1e-5\n", + "regc1.alpha_x = 1.\n", + "regc1.mref = reg.mref\n", + "# Inversion problem\n", + "invProbc1 = simpeg.InvProblem.BaseInvProblem(dmisc1, regc1, optc1)\n", + "invProbc1.counter = C\n", + "# Beta cooling\n", + "betac1 = simpeg.Directives.BetaSchedule()\n", + "betaestc1 = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=0.75)\n", + "betaestc1.beta0 = 3.60e-03\n", + "saveModel = simpeg.Directives.SaveModelEveryIteration()\n", + "# Create an inversion object\n", + "invc1 = simpeg.Inversion.BaseInversion(invProbc1, directiveList=[betac1,betaestc1])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.\n", + " ***Done using same solver as the problem***\n", + "SimPEG.l2_DataMisfit is creating default weightings for Wd.\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + " 0 1.79e-02 1.75e+01 1.23e-01 1.75e+01 6.14e+00 0 \n", + " 1 1.79e-02 1.75e+01 1.23e-01 1.75e+01 6.14e+00 3 \n", + " 2 1.79e-02 1.75e+01 1.23e-01 1.75e+01 6.15e+00 3 Skip BFGS \n", + " 3 2.23e-03 1.75e+01 1.23e-01 1.75e+01 6.16e+00 3 Skip BFGS \n", + " 4 2.23e-03 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 5 2.23e-03 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 6 2.79e-04 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 7 2.79e-04 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 8 2.79e-04 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 9 3.49e-05 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 10 3.49e-05 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 11 3.49e-05 1.75e+01 1.23e-01 1.75e+01 6.17e+00 3 Skip BFGS \n", + " 12 4.36e-06 1.75e+01 1.23e-01 1.75e+01 6.16e+00 3 Skip BFGS \n", + " 13 4.36e-06 1.75e+01 1.23e-01 1.75e+01 6.16e+00 3 Skip BFGS \n", + " 14 4.36e-06 1.75e+01 1.23e-01 1.75e+01 6.29e+00 2 Skip BFGS \n", + " 15 5.46e-07 1.75e+01 1.23e-01 1.75e+01 6.32e+00 2 Skip BFGS \n", + " 16 5.46e-07 1.75e+01 1.23e-01 1.75e+01 6.31e+00 2 Skip BFGS \n", + " 17 5.46e-07 1.75e+01 1.23e-01 1.75e+01 6.29e+00 2 Skip BFGS \n", + " 18 6.82e-08 1.75e+01 1.23e-01 1.75e+01 6.26e+00 2 Skip BFGS \n", + " 19 6.82e-08 1.75e+01 1.23e-01 1.75e+01 6.22e+00 2 Skip BFGS \n", + " 20 6.82e-08 1.75e+01 1.23e-01 1.75e+01 6.18e+00 2 Skip BFGS \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 3.9817e-03 <= tolF*(1+|f0|) = 1.8547e+00\n", + "0 : |xc-x_last| = 4.1858e+01 <= tolX*(1+|x0|) = 5.7798e+00\n", + "0 : |proj(x-g)-x| = 6.1825e+00 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 6.1825e+00 <= 1e3*eps = 1.0000e-02\n", + "1 : maxIter = 20 <= iter = 20\n", + "------------------------- DONE! -------------------------\n" + ] + } + ], + "source": [ + "moptc1 = invc1.run(mopt2)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counters:\n", + " InexactGaussNewton.doEndIteration : 30\n", + " InexactGaussNewton.doStartIteration : 31\n", + " InexactGaussNewton.scaleSearchDirection : 30\n", + "\n", + "Times: mean sum\n", + " BaseInvProblem.evalFunction : 3.35e+00, 2.04e+02, 61x\n", + " InexactGaussNewton.findSearchDirection : 2.11e+01, 6.34e+02, 30x\n", + " InexactGaussNewton.minimize : 8.39e+02, 8.39e+02, 1x\n", + " InexactGaussNewton.modifySearchDirection: 1.90e+00, 5.71e+01, 30x\n", + " InexactGaussNewton.projection : 4.65e-05, 5.86e-03, 126x\n" + ] + } + ], + "source": [ + "opt.counter.summary()\n", + "xc = opt.recall('xc')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# import matplotlib.pyplot as plt\n", + "# # plt.figure(1)\n", + "# # for i in range(problem.G.shape[0]):\n", + "# # plt.plot(problem.G[i,:])\n", + "# meshPts = np.concatenate((mesh.gridN[0:1],np.kron(mesh.gridN[1::],np.ones(2))[:-1]))\n", + "# modelPts = np.kron(1./model,np.ones(2,))\n", + "# axM.semilogx(modelPts,meshPts,color=col)\n", + "# plt.figure(2)\n", + "# plt.plot(m1d.vectorCCx[active], np.log10(mappingExpAct*survey.mtrue)[active], 'b-')\n", + "# plt.plot(m1d.vectorCCx[active], np.log10(mappingExpAct*mopt)[active], 'r-')\n", + "# plt.show()\n" ] }, { @@ -188,56 +540,209 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "# Runn the inversion\n", - "mopt = inv.run(m_0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "opt.counter.summary()\n", - "xc = opt.recall('xc')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": false - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "# plt.figure(1)\n", - "# for i in range(problem.G.shape[0]):\n", - "# plt.plot(problem.G[i,:])\n", + "def plotMT1DModelData(problem,models,symList=None):\n", + " # Make the analytic solution\n", + " # \tdef makeAnalyticSolution(mesh,model,elev,freqs):\n", + " # \t\tdata1D = []\n", + " # \t\tfor freq in freqs:\n", + " # \t\t\tanaEd, anaEu, anaHd, anaHu = simpegmt.Utils.MT1Danalytic.getEHfields(mesh,model,freq,elev)\n", + " # \t\t\tanaE = anaEd+anaEu\n", + " # \t\t\tanaH = anaHd+anaHu\n", + " # \t\t\t# Scale the solution\n", + " # \t\t\t# anaE = (anaEtemp/anaEtemp[-1])#.conj()\n", + " # \t\t\t# anaH = (anaHtemp/anaEtemp[-1])#.conj()\n", + " # \t\t\tanaZ = anaE/anaH\n", + " # \t\t\t# Add to the list\n", + " # \t\t\tdata1D.append((freq,0,0,elev,anaZ[0]))\n", + " # \t\tdataRec = np.array(data1D,dtype=[('freq',float),('x',float),('y',float),('z',float),('zxx',complex)])\n", + " # \t\treturn dataRec\n", + " def appResPhs(freq,z):\n", + " fr = simpeg.mkvc(freq,2)*np.ones(z.shape)\n", + " app_res = ((1./(8e-7*np.pi**2))/fr)*np.abs(z)**2\n", + " app_phs = np.arctan2(z.imag,z.real)*(180/np.pi)\n", + " return app_res, app_phs\n", + " \n", + " # Setup the figure\n", + " fontSize = 15\n", "\n", - "plt.figure(2)\n", - "plt.plot(m1d.vectorCCx, np.log10(survey.mtrue), 'b-')\n", - "plt.plot(m1d.vectorCCx, np.log10(mopt), 'r-')\n", + " fig = plt.figure(figsize=[9,7])\n", + " axM = fig.add_axes([0.075,.1,.25,.875])\n", + " axM.set_xlabel('Resistivity [Ohm*m]',fontsize=fontSize)\n", + " axM.set_xlim(1e-1,1e5)\n", + " axM.set_ylim(-10000,5000)\n", + " axM.set_ylabel('Depth [km]',fontsize=fontSize)\n", + " axR = fig.add_axes([0.42,.575,.5,.4])\n", + " axR.set_xscale('log')\n", + " axR.set_yscale('log')\n", + " axR.invert_xaxis()\n", + " # axR.set_xlabel('Frequency [Hz]')\n", + " axR.set_ylabel('Apparent resistivity [Ohm m]',fontsize=fontSize)\n", + "\n", + " axP = fig.add_axes([0.42,.1,.5,.4])\n", + " axP.set_xscale('log')\n", + " axP.invert_xaxis()\n", + " axP.set_ylim(0,90)\n", + " axP.set_xlabel('Frequency [Hz]',fontsize=fontSize)\n", + " axP.set_ylabel('Apparent phase [deg]',fontsize=fontSize)\n", + "\n", + " # if not symList:\n", + " # \tsymList = ['x']*len(models)\n", + " sys.path.append('/home/gudni/Dropbox/code/python/MTview')\n", + " import plotDataTypes as pDt\n", + " # Loop through the models.\n", + " modelList = [problem.survey.mtrue]\n", + " modelList.extend(models)\n", + " if False:\n", + " modelList = [problem.mapping.sigmaMap*mod for mod in modelList]\n", + " for nr, model in enumerate(modelList):\n", + " # Calculate the data\n", + " if nr==0:\n", + " data1D = problem.dataPair(problem.survey,problem.survey.dobs).toRecArray('Complex')\n", + " else:\n", + " data1D = problem.dataPair(problem.survey,problem.survey.dpred(model)).toRecArray('Complex')\n", + " # Plot the data and the model \n", + " colRat = nr/((len(modelList)-2)*1.)\n", + " if colRat > 1.:\n", + " col = 'k'\n", + " else:\n", + " col = plt.cm.seismic(1-colRat)\n", + " # The model - make the pts to plot\n", + " meshPts = np.concatenate((problem.mesh.gridN[0:1],np.kron(problem.mesh.gridN[1::],np.ones(2))[:-1]))\n", + " modelPts = np.kron(1./(problem.mapping.sigmaMap*model),np.ones(2,))\n", + " axM.semilogx(modelPts,meshPts,color=col)\n", + "\n", + " ## Data\n", + " # Appres\n", + " pDt.plotIsoStaImpedance(axR,np.array([0,0]),data1D,'zyx','res',pColor=col)\n", + " # Appphs\n", + " pDt.plotIsoStaImpedance(axP,np.array([0,0]),data1D,'zyx','phs',pColor=col)\n", + " try:\n", + " allData = np.concatenate((allData,mkvc(data1D['zyx'],2)),1)\n", + " except:\n", + " allData = simpeg.mkvc(data1D['zyx'],2)\n", + " freq = data1D['freq']\n", + " res, phs = appResPhs(freq,allData)\n", + "\n", + " stdCol = 'gray'\n", + " axRtw = axR.twinx()\n", + " axRtw.set_ylabel('Std of log10',color=stdCol)\n", + " [(t.set_color(stdCol), t.set_rotation(-45)) for t in axRtw.get_yticklabels()]\n", + " axPtw = axP.twinx()\n", + " axPtw.set_ylabel('Std ',color=stdCol)\n", + " [t.set_color(stdCol) for t in axPtw.get_yticklabels()]\n", + " axRtw.plot(freq, np.std(np.log10(res),1),'--',color=stdCol)\n", + " axPtw.plot(freq, np.std(phs,1),'--',color=stdCol)\n", + "\n", + " # Fix labels and ticks\n", + "\n", + " yMtick = [l/1000 for l in axM.get_yticks().tolist()]\n", + " axM.set_yticklabels(yMtick)\n", + " [ l.set_rotation(90) for l in axM.get_yticklabels()]\n", + " [ l.set_rotation(90) for l in axR.get_yticklabels()]\n", + " [(t.set_color(stdCol), t.set_rotation(-45)) for t in axRtw.get_yticklabels()]\n", + " [t.set_color(stdCol) for t in axPtw.get_yticklabels()]\n", + " for ax in [axM,axR,axP]:\n", + " ax.xaxis.set_tick_params(labelsize=fontSize)\n", + " ax.yaxis.set_tick_params(labelsize=fontSize)\n", + " return fig\n", + "# plotMT1DModelData(problem,[mopt])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/gudni/anaconda/lib/python2.7/site-packages/numpy/ma/core.py:2834: FutureWarning: Numpy has detected that you (may be) writing to an array returned\n", + "by numpy.diagonal or by selecting multiple fields in a record\n", + "array. This code will likely break in a future numpy release --\n", + "see numpy.diagonal or arrays.indexing reference docs for details.\n", + "The quick fix is to make an explicit copy (e.g., do\n", + "arr.diagonal().copy() or arr[['f0','f1']].copy()).\n", + " if (obj.__array_interface__[\"data\"][0]\n", + "/home/gudni/anaconda/lib/python2.7/site-packages/numpy/ma/core.py:2835: FutureWarning: Numpy has detected that you (may be) writing to an array returned\n", + "by numpy.diagonal or by selecting multiple fields in a record\n", + "array. This code will likely break in a future numpy release --\n", + "see numpy.diagonal or arrays.indexing reference docs for details.\n", + "The quick fix is to make an explicit copy (e.g., do\n", + "arr.diagonal().copy() or arr[['f0','f1']].copy()).\n", + " != self.__array_interface__[\"data\"][0]):\n" + ] + } + ], + "source": [ + "plotMT1DModelData(problem,[mopt,mopt2])\n", "plt.show()\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [], "source": [ - "mopt" + "modelList = [problem.survey.mtrue]\n", + "modelList.extend([mopt])\n", + "# problem.mapping.sigmaMap*mopt" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[['zyxr'], ['zyxi']]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "src = survey.srcList[0]\n", + "[[rx.rxType.replace('z1d','zyx')] for rx in src.rxList ]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'zyxr'" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "'z1dr'.replace('z1d','zyx')" ] }, { @@ -255,6 +760,18 @@ "display_name": "Python 2", "language": "python", "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" } }, "nbformat": 4, diff --git a/simpegMT/BaseMT.py b/simpegMT/BaseMT.py index 5ec79aab..68f74945 100644 --- a/simpegMT/BaseMT.py +++ b/simpegMT/BaseMT.py @@ -24,7 +24,7 @@ class BaseMTProblem(BaseFDEMProblem): # Use the forward and devs from BaseFDEMProblem # Might need to add more stuff here. - def Jvec(self, m, v, f=None): + def Jvec(self, m, v, u=None): """ Function to calculate the data sensitivities dD/dm times a vector. @@ -36,8 +36,8 @@ class BaseMTProblem(BaseFDEMProblem): """ # Calculate the fields - if f is None: - f = self.fields(m) + if u is None: + u = self.fields(m) # Set current model self.curModel = m # Initiate the Jv object @@ -52,7 +52,7 @@ class BaseMTProblem(BaseFDEMProblem): # We need fDeriv_m = df/du*du/dm + df/dm # Construct du/dm, it requires a solve ftype = self._fieldType + 'Solution' - u_src = f[src, ftype] + u_src = u[src, ftype] dA_dm = self.getADeriv_m(freq, u_src, v) dRHS_dm = self.getRHSDeriv_m(freq, v) if dRHS_dm is None: @@ -62,14 +62,14 @@ class BaseMTProblem(BaseFDEMProblem): # Calculate the projection derivatives for rx in src.rxList: # Get the projection derivative - PDeriv = lambda v: rx.projectFieldsDeriv(src, self.mesh, f, v) # wrt u, also have wrt m + PDeriv = lambda v: rx.projectFieldsDeriv(src, self.mesh, u, v) # wrt u, also have wrt m Jv[src, rx] = PDeriv(du_dm) # Return the vectorized sensitivities return mkvc(Jv) - def Jtvec(self, m, v, f=None): - if f is None: - f = self.fields(m) + def Jtvec(self, m, v, u=None): + if u is None: + u = self.fields(m) self.curModel = m @@ -85,11 +85,11 @@ class BaseMTProblem(BaseFDEMProblem): for src in self.survey.getSrcByFreq(freq): ftype = self._fieldType + 'Solution' - u_src = f[src, ftype] + u_src = u[src, ftype] for rx in src.rxList: # Get the adjoint projectFieldsDeriv - PTv = rx.projectFieldsDeriv(src, self.mesh, f, v[src, rx], adjoint=True) # wrt u, need possibility wrt m + PTv = rx.projectFieldsDeriv(src, self.mesh, u, v[src, rx], adjoint=True) # wrt u, need possibility wrt m # Get the dA_duIT = ATinv * PTv dA_dmT = self.getADeriv_m(freq, u_src, dA_duIT, adjoint=True) diff --git a/simpegMT/DataMT.py b/simpegMT/DataMT.py index 6ef20939..19dd77d5 100644 --- a/simpegMT/DataMT.py +++ b/simpegMT/DataMT.py @@ -8,9 +8,9 @@ from numpy.lib import recfunctions as recFunc ############ class DataMT(Survey.Data): ''' - Data class for MTdata + Data class for MTdata - :param SimPEG survey object survey: + :param SimPEG survey object survey: :param v vector with data ''' @@ -37,14 +37,18 @@ class DataMT(Survey.Data): # Note: needs to be written more generally, using diffterent rxTypes and not all the data at the locaitons # Assume the same locs for all RX locs = src.rxList[0].locs + if locs.shape[1] == 1: + locs = np.hstack((np.array([[0.0,0.0]]),locs)) + elif locs.shape[1] == 2: + locs = np.hstack((np.array([[0.0]]),locs)) tArrRec = np.concatenate((src.freq*np.ones((locs.shape[0],1)),locs,np.nan*np.ones((locs.shape[0],8))),axis=1).view(dtRI) # np.array([(src.freq,rx.locs[0,0],rx.locs[0,1],rx.locs[0,2],np.nan ,np.nan ,np.nan ,np.nan ,np.nan ,np.nan ,np.nan ,np.nan ) for rx in src.rxList],dtype=dtRI) # Get the type and the value for the DataMT object as a list - typeList = [[rx.rxType,self[src,rx]] for rx in src.rxList] + typeList = [[rx.rxType.replace('z1d','zyx'),self[src,rx]] for rx in src.rxList] # Insert the values to the temp array for nr,(key,val) in enumerate(typeList): tArrRec[key] = mkvc(val,2) - # Masked array + # Masked array mArrRec = np.ma.MaskedArray(rec2ndarr(tArrRec),mask=np.isnan(rec2ndarr(tArrRec))).view(dtype=tArrRec.dtype) # Unique freq and loc of the masked array uniFLmarr = np.unique(mArrRec[['freq','x','y','z']]) @@ -66,5 +70,5 @@ class DataMT(Survey.Data): for comp in ['zxx','zxy','zyx','zyy']: outArr[comp] = outTemp[comp+'r'].copy() + 1j*outTemp[comp+'i'].copy() - # Return + # Return return outArr diff --git a/simpegMT/FieldsMT.py b/simpegMT/FieldsMT.py index b9832309..bd6ec799 100644 --- a/simpegMT/FieldsMT.py +++ b/simpegMT/FieldsMT.py @@ -118,4 +118,18 @@ class FieldsMT_1D(FieldsMT): This function stacks the fields derivatives appropriately """ - return None \ No newline at end of file + return None + +class FieldsMT_3D(FieldsMT): + """ + Fields storage for the 3D MT solution. + """ + knownFields = {'e_px':'E','e_py':'E','b_px':'F','b_py':'F'} + aliasFields = { } + # 'e_1d' : ['e_1dSolution','F','_e'], + # 'e_1dPrimary' : ['e_1dSolution','F','_ePrimary'], + # 'e_1dSecondary' : ['e_1dSolution','F','_eSecondary'], + # 'b_1d' : ['e_1dSolution','E','_b'], + # 'b_1dPrimary' : ['e_1dSolution','E','_bPrimary'], + # 'b_1dSecondary' : ['e_1dSolution','E','_bSecondary'] + # } \ No newline at end of file diff --git a/simpegMT/ProblemMT1D/Problems.py b/simpegMT/ProblemMT1D/Problems.py index a667cc7c..ead5764d 100644 --- a/simpegMT/ProblemMT1D/Problems.py +++ b/simpegMT/ProblemMT1D/Problems.py @@ -108,7 +108,7 @@ class eForm_psField(BaseMTProblem): # Store the fields Src = self.survey.getSrcByFreq(freq)[0] # NOTE: only store the e_solution(secondary), all other components calculated in the fields object - F[Src, 'e_1dSolution'] = e_s[:,1] # Only storing the yx polarization as 1d + F[Src, 'e_1dSolution'] = e_s[:,-1] # Only storing the yx polarization as 1d # Note curl e = -iwb so b = -curl e /iw # b = -( self.mesh.nodalGrad * e )/( 1j*omega(freq) ) @@ -195,7 +195,7 @@ class eForm_TotalField(BaseMTProblem): eBC = np.r_[Etot[0],Etot[-1]] # The right hand side - return Aio*eBC, eBC + return -Aio*eBC, eBC def getRHSderiv(self, freq, backSigma, u, v, adjoint=False): raise NotImplementedError('getRHSDeriv not implemented yet') @@ -211,7 +211,7 @@ class eForm_TotalField(BaseMTProblem): self.curModel = m # RHS, CalcFields = self.getRHS(freq,m_back), self.calcFields - F = FieldsMT(self.mesh, self.survey) + F = FieldsMT_1D(self.mesh, self.survey) for freq in self.survey.freqs: if self.verbose: startTime = time.time() @@ -224,14 +224,8 @@ class eForm_TotalField(BaseMTProblem): e = mkvc(np.r_[e_o[0], e_i, e_o[1]],2) # Store the fields Src = self.survey.getSrcByFreq(freq) - # Store the fields - # NOTE: only store - F[Src, 'e_1d'] = e - # F[Src, 'e_py'] = 0*e[:,0] - # Note curl e = -iwb so b = -curl e /iw - b = -( self.mesh.nodalGrad * e )/( 1j*omega(freq) ) - # F[Src, 'b_px'] = 0*b[:,0] - F[Src, 'b_1d'] = b + # NOTE: only store e fields + F[Src, 'e_1dSolution'] = e[:,0] if self.verbose: print 'Ran for {:f} seconds'.format(time.time()-startTime) sys.stdout.flush() diff --git a/simpegMT/ProblemMT3D/Problems.py b/simpegMT/ProblemMT3D/Problems.py index a2b61edd..30f73b0d 100644 --- a/simpegMT/ProblemMT3D/Problems.py +++ b/simpegMT/ProblemMT3D/Problems.py @@ -3,7 +3,7 @@ from simpegEM.Utils.EMUtils import omega from scipy.constants import mu_0 from simpegMT.BaseMT import BaseMTProblem from simpegMT.SurveyMT import SurveyMT -from simpegMT.FieldsMT import FieldsMT +from simpegMT.FieldsMT import FieldsMT_3D from simpegMT.DataMT import DataMT import multiprocessing, sys, time @@ -22,7 +22,7 @@ class eForm_ps(BaseMTProblem): # From FDEMproblem: Used to project the fields. Currently not used for MTproblem. _fieldType = 'e' _eqLocs = 'FE' - + fieldsPair = FieldsMT_3D # Need to add the src .... @@ -112,7 +112,7 @@ class eForm_ps(BaseMTProblem): # Set the current model self.curModel = m - F = FieldsMT(self.mesh, self.survey) + F = FieldsMT_3D(self.mesh, self.survey) for freq in self.survey.freqs: if self.verbose: startTime = time.time() @@ -149,7 +149,7 @@ class eForm_Tp(BaseMTProblem): _fieldType = 'e' _eqLocs = 'FE' - fieldsPair = FieldsMT + fieldsPair = FieldsMT_3D # Set new properties # Background model @@ -242,7 +242,7 @@ class eForm_Tp(BaseMTProblem): self.backModel = m_back # RHS, CalcFields = self.getRHS(freq,m_back), self.calcFields - F = FieldsMT(self.mesh, self.survey) + F = FieldsMT_3D(self.mesh, self.survey) for freq in self.survey.freqs: if self.verbose: startTime = time.time() diff --git a/simpegMT/Sources/backgroundModelSources.py b/simpegMT/Sources/backgroundModelSources.py index ebd6cd37..e152bbd8 100644 --- a/simpegMT/Sources/backgroundModelSources.py +++ b/simpegMT/Sources/backgroundModelSources.py @@ -23,8 +23,8 @@ def homo1DModelSource(mesh,freq,sigma_1d): # # Note: Everything is using e^iwt e0_1d = get1DEfields(mesh1d,sigma_1d,freq) if mesh.dim == 1: - eBG_px = -simpeg.mkvc(e0_1d,2) - eBG_py = simpeg.mkvc(e0_1d,2) + eBG_px = simpeg.mkvc(e0_1d,2) + eBG_py = -simpeg.mkvc(e0_1d,2) # added a minus to make the results in the correct quadrents. elif mesh.dim == 2: ex_px = np.zeros(mesh.vnEx,dtype=complex) ey_px = np.zeros((mesh.nEy,1),dtype=complex) diff --git a/simpegMT/SurveyMT.py b/simpegMT/SurveyMT.py index 4175efcd..5f9b2c23 100644 --- a/simpegMT/SurveyMT.py +++ b/simpegMT/SurveyMT.py @@ -93,7 +93,9 @@ class RxMT(Survey.BaseRx): Pbx = mesh.getInterpolationMat(self.locs,'Ex') ex = Pex*mkvc(f[src,'e_1d'],2) bx = Pbx*mkvc(f[src,'b_1d'],2)/mu_0 - f_part_complex = ex/bx + # Note: Has a minus sign in front, to comply with quadrant calculations. + # Can be derived from zyx case for the 3D case. + f_part_complex = -ex/bx # elif self.projType is 'Z2D': elif self.projType is 'Z3D': # Get the projection @@ -146,8 +148,8 @@ class RxMT(Survey.BaseRx): Pbx = mesh.getInterpolationMat(self.locs,'Ex') # ex = Pex*mkvc(f[src,'e_1d'],2) # bx = Pbx*mkvc(f[src,'b_1d'],2)/mu_0 - dP_de = mkvc(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))*(Pex*v),2) - dP_db = mkvc(- Utils.sdiag(Pex*mkvc(f[src,'e_1d'],2))*(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)).T*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)))*(Pbx*f._bDeriv_u(src,v)/mu_0),2) + dP_de = -mkvc(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))*(Pex*v),2) + dP_db = mkvc( Utils.sdiag(Pex*mkvc(f[src,'e_1d'],2))*(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)).T*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)))*(Pbx*f._bDeriv_u(src,v)/mu_0),2) PDeriv_complex = np.sum(np.hstack((dP_de,dP_db)),1) elif self.projType is 'Z2D': raise NotImplementedError('Has not be implement for 2D impedance tensor') @@ -162,8 +164,8 @@ class RxMT(Survey.BaseRx): Pbx = mesh.getInterpolationMat(self.locs,'Ex') # ex = Pex*mkvc(f[src,'e_1d'],2) # bx = Pbx*mkvc(f[src,'b_1d'],2)/mu_0 - dP_deTv = mkvc(Pex.T*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)).T*v,2) - db_duv = -Pbx.T/mu_0*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))*(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))).T*Utils.sdiag(Pex*mkvc(f[src,'e_1d'],2)).T*v + dP_deTv = -mkvc(Pex.T*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0)).T*v,2) + db_duv = Pbx.T/mu_0*Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))*(Utils.sdiag(1./(Pbx*mkvc(f[src,'b_1d'],2)/mu_0))).T*Utils.sdiag(Pex*mkvc(f[src,'e_1d'],2)).T*v dP_dbTv = mkvc(f._bDeriv_u(src,db_duv,adjoint=True),2) PDeriv_real = np.sum(np.hstack((dP_deTv,dP_dbTv)),1) elif self.projType is 'Z2D': @@ -323,7 +325,6 @@ class SurveyMT(Survey.BaseSurvey): def projectFields(self, u): data = DataMT(self) for src in self.srcList: - print 'Project at freq: {:.3e}'.format(src.freq) sys.stdout.flush() for rx in src.rxList: data[src, rx] = rx.projectFields(src, self.mesh, u) diff --git a/simpegMT/Tests/test_Problem1D_againstAnalyticHalfspace.py b/simpegMT/Tests/test_Problem1D_againstAnalyticHalfspace.py index b8a50980..afb24d5d 100644 --- a/simpegMT/Tests/test_Problem1D_againstAnalyticHalfspace.py +++ b/simpegMT/Tests/test_Problem1D_againstAnalyticHalfspace.py @@ -45,7 +45,7 @@ def getAppResPhs(MTdata): # Make impedance def appResPhs(freq,z): app_res = ((1./(8e-7*np.pi**2))/freq)*np.abs(z)**2 - app_phs = np.arctan2(-z.imag,z.real)*(180/np.pi) + app_phs = np.arctan2(z.imag,z.real)*(180/np.pi) return app_res, app_phs zList = [] for src in MTdata.survey.srcList: @@ -93,7 +93,7 @@ def appPhs_TotalFieldNorm(sigmaHalf): # Calculate the app phs app_p = np.array(getAppResPhs(data))[:,1] - return np.linalg.norm(np.abs(app_p - np.ones(survey.nFreq)*135)/ 135) + return np.linalg.norm(np.abs(app_p - np.ones(survey.nFreq)*45)/ 45) def appRes_psFieldNorm(sigmaHalf): @@ -129,7 +129,7 @@ def appPhs_psFieldNorm(sigmaHalf): # Calculate the app phs app_p = np.array(getAppResPhs(data))[:,1] - return np.linalg.norm(np.abs(app_p - np.ones(survey.nFreq)*135)/ 135) + return np.linalg.norm(np.abs(app_p - np.ones(survey.nFreq)*45)/ 45) class TestAnalytics(unittest.TestCase): diff --git a/simpegMT/Tests/test_Problem1D_totalDvsPSvsAnalytic.py b/simpegMT/Tests/test_Problem1D_totalDvsPSvsAnalytic.py new file mode 100644 index 00000000..74af340e --- /dev/null +++ b/simpegMT/Tests/test_Problem1D_totalDvsPSvsAnalytic.py @@ -0,0 +1,155 @@ +import unittest +import SimPEG as simpeg +import simpegMT as simpegmt +from SimPEG.Utils import meshTensor +import numpy as np +# Define the tolerances +TOLr = 5e-2 +TOLp = 5e-2 + + +def setupSurvey(sigmaHalf,tD=True): + + # Frequency + nFreq = 33 + freqs = np.logspace(3,-3,nFreq) + # Make the mesh + ct = 5 + air = meshTensor([(ct,25,1.3)]) + # coreT0 = meshTensor([(ct,15,1.2)]) + # coreT1 = np.kron(meshTensor([(coreT0[-1],15,1.3)]),np.ones((7,))) + core = np.concatenate( ( np.kron(meshTensor([(ct,15,-1.2)]),np.ones((10,))) , meshTensor([(ct,20)]) ) ) + bot = meshTensor([(core[0],15,-1.3)]) + x0 = -np.array([np.sum(np.concatenate((core,bot)))]) + m1d = simpeg.Mesh.TensorMesh([np.concatenate((bot,core,air))], x0=x0) + # Make the model + sigma = np.zeros(m1d.nC) + sigmaHalf + sigma[m1d.gridCC > 0 ] = 1e-8 + sigmaBack = sigma.copy() + # Add structure + shallow = (m1d.gridCC < -200) * (m1d.gridCC > -600) + deep = (m1d.gridCC < -3000) * (m1d.gridCC > -5000) + sigma[shallow] = 1 + sigma[deep] = 0.1 + + rxList = [] + for rxType in ['z1dr','z1di']: + rxList.append(simpegmt.SurveyMT.RxMT(simpeg.mkvc(np.array([0.0]),2).T,rxType)) + # Source list + srcList =[] + if tD: + for freq in freqs: + srcList.append(simpegmt.SurveyMT.srcMT_polxy_1DhomotD(rxList,freq)) + else: + for freq in freqs: + srcList.append(simpegmt.SurveyMT.srcMT_polxy_1Dprimary(rxList,freq,sigmaBack)) + + survey = simpegmt.SurveyMT.SurveyMT(srcList) + return survey, sigma, m1d + +def getAppResPhs(MTdata): + # Make impedance + def appResPhs(freq,z): + app_res = ((1./(8e-7*np.pi**2))/freq)*np.abs(z)**2 + app_phs = np.arctan2(z.imag,z.real)*(180/np.pi) + return app_res, app_phs + zList = [] + for src in MTdata.survey.srcList: + zc = [src.freq] + for rx in src.rxList: + if 'i' in rx.rxType: + m=1j + else: + m = 1 + zc.append(m*MTdata[src,rx]) + zList.append(zc) + return [appResPhs(zList[i][0],np.sum(zList[i][1:3])) for i in np.arange(len(zList))] + +def calculateAnalyticSolution(srcList,mesh,model): + surveyAna = simpegmt.SurveyMT.SurveyMT(srcList) + data1D = simpegmt.DataMT.DataMT(surveyAna) + for src in surveyAna.srcList: + elev = src.rxList[0].locs[0] + anaEd, anaEu, anaHd, anaHu = simpegmt.Utils.MT1Danalytic.getEHfields(mesh,model,src.freq,elev) + anaE = anaEd+anaEu + anaH = anaHd+anaHu + # Scale the solution + # anaE = (anaEtemp/anaEtemp[-1])#.conj() + # anaH = (anaHtemp/anaEtemp[-1])#.conj() + anaZ = anaE/anaH + for rx in src.rxList: + data1D[src,rx] = getattr(anaZ, rx.projComp) + return data1D + +def dataMis_AnalyticTotalDomain(sigmaHalf): + + # Make the survey + + # Total domain solution + surveyTD, sigma, mesh = setupSurvey(sigmaHalf) + problemTD = simpegmt.ProblemMT1D.eForm_TotalField(mesh) + problemTD.pair(surveyTD) + # Analytic data + dataAnaObj = calculateAnalyticSolution(surveyTD.srcList,mesh,sigma) + # dataTDObj = simpegmt.DataMT.DataMT(surveyTD, surveyTD.dpred(sigma)) + dataTD = surveyTD.dpred(sigma) + dataAna = simpeg.mkvc(dataAnaObj) + return np.all((dataTD - dataAna)/dataAna < 2.) + # surveyTD.dtrue = -simpeg.mkvc(dataAna,2) + # surveyTD.dobs = -simpeg.mkvc(dataAna,2) + # surveyTD.Wd = np.ones(surveyTD.dtrue.shape) #/(np.abs(surveyTD.dtrue)*0.01) + # # Setup the data misfit + # dmis = simpeg.DataMisfit.l2_DataMisfit(surveyTD) + # dmis.Wd = surveyTD.Wd + # return dmis.eval(sigma) + + +def dataMis_AnalyticPrimarySecondary(sigmaHalf): + + # Make the survey + # Primary secondary + surveyPS, sigmaPS, mesh = setupSurvey(sigmaHalf,False) + problemPS = simpegmt.ProblemMT1D.eForm_psField(mesh) + problemPS.pair(surveyPS) + # Analytic data + dataAna = calculateAnalyticSolution(surveyPS.srcList,mesh,sigma) + + surveyPS.dtrue = dataAna + # Project the data + data = surveyPS.dpred(sigmaPS) + + # Setup the data misfit + dmis = simpeg.DataMisfit.l2_DataMisfit(survey) + return dmis.eval(sigma) + + + +class TestNumericVsAnalytics(unittest.TestCase): + + def setUp(self): + pass + # Total Fields + # def test_appRes2en1(self):self.assertLess(appRes_TotalFieldNorm(2e-1), TOLr) + # def test_appPhs2en1(self):self.assertLess(appPhs_TotalFieldNorm(2e-1), TOLp) + + def test_appRes2en2(self):self.assertTrue(dataMis_AnalyticTotalDomain(2e-2)) + # def test_appPhs2en2(self):self.assert(appPhs_TotalFieldNorm(2e-2), TOLp) + + # def test_appRes2en3(self):self.assertLess(appRes_TotalFieldNorm(2e-3), TOLr) + # def test_appPhs2en3(self):self.assertLess(appPhs_TotalFieldNorm(2e-3), TOLp) + + # def test_appRes2en4(self):self.assertLess(appRes_TotalFieldNorm(2e-4), TOLr) + # def test_appPhs2en4(self):self.assertLess(appPhs_TotalFieldNorm(2e-4), TOLp) + + # def test_appRes2en5(self):self.assertLess(appRes_TotalFieldNorm(2e-5), TOLr) + # def test_appPhs2en5(self):self.assertLess(appPhs_TotalFieldNorm(2e-5), TOLp) + + # def test_appRes2en6(self):self.assertLess(appRes_TotalFieldNorm(2e-6), TOLr) + # def test_appPhs2en6(self):self.assertLess(appPhs_TotalFieldNorm(2e-6), TOLp) + + # Primary/secondary + # def test_appRes2en2_ps(self):self.assertLess(appRes_psFieldNorm(2e-2), TOLr) + # def test_appPhs2en2_ps(self):self.assertLess(appPhs_psFieldNorm(2e-2), TOLp) + +if __name__ == '__main__': + unittest.main() \ No newline at end of file diff --git a/simpegMT/Utils/MT1Danalytic.py b/simpegMT/Utils/MT1Danalytic.py index 5380355d..d656fa84 100644 --- a/simpegMT/Utils/MT1Danalytic.py +++ b/simpegMT/Utils/MT1Danalytic.py @@ -53,7 +53,7 @@ def getEHfields(m1d,sigma,freq,zd): # Loop over the layers and calculate the fields # In the halfspace below the mesh - dup = m1d.vectorNx[0] + dup = m1d.vectorNx[0] dind = dup >= zd Ed[dind] = UDp[1,0]*np.exp(-1j*k[0]*(dup-zd[dind])) Eu[dind] = UDp[0,0]*np.exp(1j*k[0]*(dup-zd[dind]))