scalar_field_cokriging_minimal_example-fixed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Minimal working example for cokringing of a scalar field for geological modeling\n",
    "\n",
    "The aim of this notebook is to explain in simple steps the scalar-field (or: potential-field) interpolation implemented in GemPy and GeoModeller, based on Lajaunie et al. (1997) and Calcagno et al. (2008). The derivation and description of the covariance functions follows from the thesis of Aug (2004) and the implementation in GemPy (de la Varga et al., submitted).\n",
    "\n",
    "## Basic principle behind a scalar-field interpolation\n",
    "\n",
    "The method is based on a zonation principle, i.e. a segmentation of continuous space into discrete zones with similar properties (or other aspects of interest). Typical examples are the distinction of rock units with different lithological features (e.g. different types of sandstones, clay layers, magmatic sequences, etc), but also metamorphic sequences that can be distinguished. Quite generally, it is basically the same concept that is underlying the construction of geological map.\n",
    "\n",
    "The general idea behind this interpolation method is that geological structures exhibit a specific continuity. As a very basic first principle, we can consider the deposition of sedimentary sequences, for example in a marine environment: we may observe a sequence of more sand-dominated and more clay-dominated units. In a quiet and continuous sedimentation environment, we can assume that we have wide lateral continuity and a \"layer-by-layer\" deposition.\n",
    "\n",
    "In the context of geomodeling, we may attempt to describe now these sedimented zones by the interface surfaces between them. It is then obvious that these surfaces should not cross (considering no disturbance during sedimentation). Furthermore, we can assume that the layers show a specific influence on each other: to first order, they can be considered as parallel. And, maybe for a finer distinction, we can assume that a (topographic) variability of in one layer (for example a sea mound, to stay in our example) has a certain upward continuation and can potentially still be apparent (though to a lesser extent) on the next interface above.\n",
    "\n",
    "We can now take a more abstract view and assume that we do not only have two or three interfaces, but more or less a continuous description of subsequent layers, representing a continuous sedimentation process and showing a similar continuous influence on each other, and the layer interfaces can not cross. \n",
    "\n",
    "With this intuition, we can describe these layer interfaces as isosurfaces in a scalar field. In our example, we can even interpret the scalar field values as related to a specific depositional age (note that this notion will not generally be possible - nor a requirement). Even further, we can interpret the gradient of this scalar field as orientation values, i.e. measurements of strike/ dip/ dip direction in a geological sequence.\n",
    "\n",
    "The question now is: how can we interpolate this scalar field from a set of limited observations of surface contact points and orientation measurements?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Notation and scalar field interpolation\n",
    "\n",
    "Multiple methods are possible to obtain this scalar field. A very common approach (mostly from the field of image segmentation, but also applied in geophysics) is to use a Level Set formulation (Chan & Vese?). Other previous approaches implemented Radial Basis Functions (RBF's, e.g. the implementation in LeapFrog, see also Hillier, 2014) and a stochastic time interpretation (? Mallet 2004 - the GoCAD implicit modeling approach). We use here a geostatistical method based on (universal) co-kriging, described in Lajaunie et al., 1997.\n",
    "\n",
    "We denote the 3-D surface in an *implicit* form (therefore also the name of these methods as \"implicit geomodeling\"), associated with a function $\\psi_\\alpha$ such that (Lajaunie et al., 1997):\n",
    "\n",
    "$$C_\\alpha = \\{x : \\psi_a(x) = 0 \\}$$\n",
    "\n",
    "\n",
    "We describe the scalar field that we aim to obtain as a function $T( \\vec{x} )$. \n",
    "\n",
    "Next, we denote $Z$ as a realization of the (differentiable) random function $\\psi$. We now use a kriging method to to estimate $Z$ in the entire domain of interest.\n",
    "\n",
    "Note: important basic principle: multivariate (co-)kriging, IRK-f model (Matheron!) CHECK!!\n",
    "\n",
    "However, co-kriging is not \"standard\" form, as variables are algebraically linked!\n",
    "\n",
    "More notation:\n",
    "\n",
    "Gradient data:\n",
    "\n",
    "$$\\frac{\\partial Z}{\\partial x} (x_i) = G_i^x$$\n",
    "\n",
    "$$\\frac{\\partial Z}{\\partial y} (x_i) = G_i^y$$\n",
    "\n",
    "Tangent vector $\\tau_i$ is defined through a scalar product:\n",
    "\n",
    "$$ <\\nabla Z(x_i), \\tau_i > = 0$$\n",
    "\n",
    "Points on a single interface belong to a single set $J_k$, $k$ is the index of the interface.\n",
    "\n",
    "Increments for points on a single interface, the increments must be zero:\n",
    "\n",
    "$$Z(x_j) - Z(x_{j'}) = 0 \\;\\;\\forall (j,j') \\in J_k$$\n",
    "\n",
    "\n",
    "### The spatial model\n",
    "\n",
    "As we only consider increments, we can only obtain a (unique) solution when we fix/ select an arbitrary origin $x_0$ and we estimate increments with respect to this origin:\n",
    "\n",
    "$$Z(x) - Z(x_0) = \\sum_{i \\in I} \\left( \\lambda_i G_i^x + \\mu_i G_i^y  \\right) + \\sum_{i' + I'} <\\nabla Z(x_{i'}), \\tau_{i'} > + \\sum_k \\sum_{jj' \\in \\mathcal{P}(J_k)} \\lambda_{jj'}[Z(x_j) - Z(x_{j'})] $$ \n",
    "\n",
    "\n",
    "$\\mathcal{P}(J_k)$ is the set of pairs associated with one interface $J_k$. Note that, in this formulation, the contribution from the scalar field increments for points on one interface $Z(x_j) - Z(x_{j'})$ would theoretically be zero. However, the consideration of this (zero-)increment is essential in order to obtain the co-kriging equations, in which these terms will matter (see below).\n",
    "\n",
    "In a sense, the interpolation can be interpreted as a co-kriging of increments and gradients. Chiles (2004) actually describes it as a kriging of a gradient field - with the additional contribution of \"zero-increment\" constraints for points on one interface. \n",
    "\n",
    "### Derivation of the co-kriging equations\n",
    "\n",
    "\n",
    "(See Chiles book for derivation of universal co-kriging equations!)\n",
    "\n",
    "We now have to set up the kriging equation to solve for the parameters/ coefficients $\\lambda_i, \\mu_i, \\lambda_{jj'}$ in order to obtain an (explicit?) equation that we can use to determine the potential field value at any point in space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Covariance functions\n",
    "\n",
    "The situation is (a \"bit\") complicated by the fact that we have to consider all covariances and cross-covariances of each function involved.\n",
    "\n",
    "\n",
    "(Side note/ Idea/ Check: can the same form of co-kriging be used in the context of posterior-space estimation/ reduced order modeling, etc. - i.e. all the cases where kriging is used, also ML? Because: we could estimate the gradient quite easily using AD-methods and the approach could lead to a more robust estimate? )\n",
    "\n",
    "For simplicity in the description, we consider an isotropic covariance field. We follow the description in Lajaunie et al. (1997) and denote the covariance of $Z$ as $K_Z$. Furthermore, a vector connecting two points in space is:\n",
    "\n",
    "$$\\vec{h} = \\vec{x} - \\vec{y}$$\n",
    "\n",
    "And the components of this vector in $x$- and $y$-direction respectively are $h_x$ and $h_y$. The base covariance function is:\n",
    "\n",
    "$$K_Z(\\vec{h}) = C_Z(r)$$\n",
    "\n",
    "In order for $Z$ to be differentiable, $K_Z$ must be twice differentiable. Under these conditions (??), the covariances are:\n",
    "\n",
    "$$K_{ZG^x}(\\vec{x} - \\vec{y})= Cov(Z(x),Z_x'(y)) = - \\frac{h_x}{r} C_Z'(r)$$\n",
    "\n",
    "Similar:\n",
    "\n",
    "$$K_{G^x G^y}((\\vec{x} - \\vec{y})$$\n",
    "\n",
    "$$K_{G^x}((\\vec{x} - \\vec{y})$$\n",
    "\n",
    "As a first test, we use the covariance functions defined in Lajaunie et al. for the Gaussian model (pg. 578):\n",
    "\n",
    "If\n",
    "\n",
    "$$C(r) = \\exp{-(r/a)^2}$$\n",
    "then:\n",
    "\n",
    "$$K_{ZG^x}(\\vec{h}) = -2 \\frac{h_x}{a^2} C(r)$$\n",
    "\n",
    "$$K_{G^x}(\\vec{h}) = \\left(\\frac{2}{a^2} - 4 \\frac{x^2}{a^4}  \\right) C(r)$$\n",
    "\n",
    "$$K_{G^x G^y}(\\vec{h}) = -4 \\frac{h_x h_y}{a^4} C(r)$$\n",
    "\n",
    "where $\\vec{h} = \\vec{x} - \\vec{y}$, $r = |\\vec{h}|$ and $h_x$ the component of $\\vec{h}$ in $x$-direction, etc.\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "  <strong>To do (Miguel?):</strong> Include better covariance function (spline?).\n",
    "</div>\n",
    "\n",
    "**To Do**\": Include equations for cubic covariance functions (see notebook and description in paper of Miguel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.346407Z",
     "start_time": "2020-02-25T10:59:05.167171Z"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.387400Z",
     "start_time": "2020-02-25T10:59:05.347931Z"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "# define covariance functions (note: no nugget effect so far...):\n",
    "\n",
    "def K_Z(h, a=25.):\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    return np.exp(-(r/a)**2)\n",
    "                  \n",
    "# cross-cov space-grad\n",
    "def K_ZGx(h, a=25.):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hx = h[0]\n",
    "    return -2 * hx/a**2 * K_Z(h,a) * 5\n",
    "\n",
    "def K_ZGy(h, a=25.):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hy = h[1]    \n",
    "    return -2 * hy/a**2 * K_Z(h,a) * 5\n",
    "\n",
    "# cov grad\n",
    "def K_Gx(h, a=25.):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hx = h[0]\n",
    "    return (2/a**2 - 4 * hx**2/a**4) * K_Z(h,a)* 5\n",
    "\n",
    "def K_Gy(h, a=25.):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hy = h[1]\n",
    "    return (2/a**2 - 4 * hy**2/a**4) * K_Z(h,a)* 5\n",
    "\n",
    "# cross-cov grad\n",
    "def K_GxGy(h, a=25.):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hx = h[0]\n",
    "    hy = h[1]\n",
    "    return -4 * hx * hy /a**4 * K_Z(h,a)* 5\n",
    "\n",
    "           \n",
    "# From Miguel's prototype notebooks\n",
    "\n",
    "def cov_cubic_f(r, a = 10):\n",
    "    c_o = a**2/14/3\n",
    "    if r > a:\n",
    "        ans_d0 = 0\n",
    "    else:\n",
    "        ans_d0 = c_o*(1-7*(r/a)**2+35/4*(r/a)**3-7/2*(r/a)**5+3/4*(r/a)**7)\n",
    "    # ans_d0[r>a] = 0\n",
    "    return ans_d0\n",
    "\n",
    "cov_cubic_f = np.vectorize(cov_cubic_f)\n",
    "\n",
    "def cov_cubic_d1_f(r, a = 10.):\n",
    "    c_o = a**2/14/3\n",
    "    if r>a:\n",
    "        ans_d1 = 0\n",
    "    else:\n",
    "        ans_d1 = (-7* (a - r)**3 *r* (8* a**2 + 9 *a* r + 3* r**2)* (c_o))/(4* a**7)\n",
    "    return ans_d1\n",
    "\n",
    "cov_cubic_d1_f = np.vectorize(cov_cubic_d1_f)\n",
    "                    \n",
    "def cov_cubic_d2_f(r, a = 10.):\n",
    "    c_o = a**2/14/3\n",
    "    if r>a:\n",
    "        ans_d2 = 0\n",
    "    else:\n",
    "        ans_d2 = (-7 * (4.* a**5. - 15. *a**4. * r + 20. *( a**2)*(r**3) - 9* r**5) * \n",
    "            (c_o))/(2*a**7)\n",
    "    return ans_d2\n",
    "\n",
    "cov_cubic_d2_f = np.vectorize(cov_cubic_d2_f)\n",
    "\n",
    "\n",
    "# Now, adjust coariance functions from above:\n",
    "\n",
    "def K_Z(h):\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    return cov_cubic_f(r)\n",
    "\n",
    "\n",
    "# cross-cov space-grad\n",
    "def K_ZGx(h):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hx = h[0]\n",
    "    return -hx/r * cov_cubic_d1_f(r)\n",
    "\n",
    "\n",
    "def K_ZGy(h):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hy = h[1]    \n",
    "    return -hy/r * cov_cubic_d1_f(r)\n",
    "\n",
    "# cov grad\n",
    "def K_Gx(h):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hx = h[0]\n",
    "    if r == 0:\n",
    "        return 0.\n",
    "    else:\n",
    "        return (hx**2/r**3 ) * cov_cubic_d1_f(r) - (hx/r)**2 * cov_cubic_d2_f(r)\n",
    "\n",
    "\n",
    "def K_Gy(h):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hy = h[1]\n",
    "    if r == 0:\n",
    "        return 0.\n",
    "    else:\n",
    "        return (hy**2/r**3 ) * cov_cubic_d1_f(r) - (hy/r)**2 * cov_cubic_d2_f(r)\n",
    "\n",
    "# cross-cov grad\n",
    "def K_GxGy(h):\n",
    "    \"\"\"Note: requires the vector h!\"\"\"\n",
    "    r = np.sqrt(h[0]**2 + h[1]**2)\n",
    "    hx = h[0]\n",
    "    hy = h[1]\n",
    "    if r == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return hx * hy /r**2 * (1/r * cov_cubic_d1_f(r) - cov_cubic_d2_f(r))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a plot of the cubic covariance functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.578963Z",
     "start_time": "2020-02-25T10:59:05.389088Z"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rs = np.arange(0.01,2,0.01)\n",
    "hs = np.vstack([-rs, rs]).transpose()\n",
    "# determine h-vectors:\n",
    "v1 = cov_cubic_f(rs)\n",
    "# for h vector: use 45 degrees/ [1,1]-direction with increasing distance\n",
    "plt.plot(rs, v1, label='C(r)')\n",
    "plt.plot(rs, cov_cubic_d1_f(rs), label='C\\'(r)')\n",
    "plt.plot(rs, cov_cubic_d2_f(rs), label='C\\'\\'(r)')\n",
    "\n",
    "v2 = [K_ZGx(h) for h in hs]\n",
    "plt.plot(rs, v2, label='K_ZGx')\n",
    "plt.plot(rs, [K_ZGy(h) for h in hs])\n",
    "plt.plot(rs, [K_Gx(h) for h in hs], label='K_Gx')\n",
    "plt.plot(rs, [K_GxGy(h) for h in hs], label='K_GxGy')\n",
    "plt.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Dual form\n",
    "\n",
    "Under the above conditions, we can actually write the kriging equations in the dual form and finally obtain the estimator:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.583789Z",
     "start_time": "2020-02-25T10:59:05.580929Z"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "TEST1 = np.array([4,3])\n",
    "TEST2 = np.array([1,2])\n",
    "h = TEST2 -TEST1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.590653Z",
     "start_time": "2020-02-25T10:59:05.585731Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3473059387587056\n",
      "-0.4454155553479704\n",
      "-0.14847185178265682\n",
      "-0.04802709196380725\n",
      "-0.14408127589142178\n",
      "-0.016009030654602414\n"
     ]
    }
   ],
   "source": [
    "print(K_Z(h))\n",
    "print(K_ZGx(h))\n",
    "print(K_ZGy(h))\n",
    "print(K_GxGy(h))\n",
    "print(K_Gx(h))\n",
    "print(K_Gy(h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Simple example: 4 points, one gradient\n",
    "\n",
    "We first start with a very simple example: twi interfaces iwth two points each, and one common gradient.\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "  <strong>To do:</strong> Include sketch of points and gradient.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.596597Z",
     "start_time": "2020-02-25T10:59:05.592169Z"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "# interface points:\n",
    "# interface 1:\n",
    "x1 = [0,0]\n",
    "x2 = [2,0]\n",
    "x_int1 = np.vstack([x1,x2])\n",
    "# interface 2:\n",
    "x3 = [0,2]\n",
    "x4 = [2,2]\n",
    "x_int2 = np.vstack([x3,x4])\n",
    "# orientation point:\n",
    "x5 = [0,1]\n",
    "x = np.vstack([x1, x2, x3, x4, x5])\n",
    "# orientation values\n",
    "gx5 = 1.\n",
    "gy5 = 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.750695Z",
     "start_time": "2020-02-25T10:59:05.598201Z"
    },
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1163abdd0>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x_int1[:,0], x_int1[:,1], 'ro')\n",
    "plt.plot(x_int2[:,0], x_int2[:,1], 'bo')\n",
    "plt.plot(x5[0], x5[1], 'go')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Calculate distance matrix\n",
    "\n",
    "(Note: not required anymore for this implementation - as h-vectors used...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.893704Z",
     "start_time": "2020-02-25T10:59:05.753096Z"
    }
   },
   "outputs": [],
   "source": [
    "import scipy.spatial.distance as dist\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.898356Z",
     "start_time": "2020-02-25T10:59:05.895481Z"
    }
   },
   "outputs": [],
   "source": [
    "d = dist.squareform(dist.pdist(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.903488Z",
     "start_time": "2020-02-25T10:59:05.899644Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0, 2.0)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[1,0], d[0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.908305Z",
     "start_time": "2020-02-25T10:59:05.904698Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0, 0],\n",
       "        [2, 0]]),\n",
       " array([2, 0]))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:2], x[1] - x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up K matrix\n",
    "\n",
    "We follow the K-matrix setup described in the Appendix of Lajaunie et al. (pg. 584):\n",
    "\n",
    "Note: we have to use the spacing vector $\\vec{h}$ instead of simply the (radial) distance $r$ in order to get correctly calculated covariance values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.914171Z",
     "start_time": "2020-02-25T10:59:05.909906Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [2, 0],\n",
       "       [0, 2],\n",
       "       [2, 2],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.927170Z",
     "start_time": "2020-02-25T10:59:05.915465Z"
    }
   },
   "outputs": [],
   "source": [
    "# Previous implementation:\n",
    "# K = np.array([[K_Gx(d[4,4]), K_GxGy(d[4,4]), K_ZGx(d[4,0])-K_ZGx(d[4,1]), K_ZGx(d[4,2])-K_ZGx(d[4,3])],\n",
    "#               [K_GxGy(d[4,4]), K_Gy(d[4,4]), K_ZGy(d[4,0])-K_ZGy(d[4,1]), K_ZGy(d[4,2])-K_ZGy(d[4,3])],\n",
    "#               [K_ZGx(d[0,4])-K_ZGx(d[1,4]), K_Gy(d[0,4])-K_ZGy(d[1,4]), K_Z(d[0,0])-K_Z(d[0,1])-K_Z(d[1,0])+K_Z(d[1,1]), K_Z(d[0,2])-K_Z(d[0,3])-K_Z(d[1,2])+K_Z(d[1,3])],\n",
    "#               [K_ZGx(d[0,4])-K_ZGx(d[1,4]), K_Gy(d[0,4])-K_ZGy(d[1,4]), K_Z(d[0,0])-K_Z(d[0,1])-K_Z(d[1,0])+K_Z(d[1,1]), K_Z(d[0,2])-K_Z(d[0,3])-K_Z(d[1,2])+K_Z(d[1,3])]])\n",
    "\n",
    "K = np.array([[K_Gx(x[4]-x[4]), K_GxGy(x[4]-x[4]), K_ZGx(x[4]-x[0])-K_ZGx(x[4]-x[1]), K_ZGx(x[4]-x[2])-K_ZGx(x[4]-x[3])],\n",
    "              [K_GxGy(x[4]-x[4]), K_Gy(x[4]-x[4]), K_ZGy(x[4]-x[0])-K_ZGy(x[4]-x[1]), K_ZGy(x[4]-x[2])-K_ZGy(x[4]-x[3])],\n",
    "              [K_ZGx(x[0]-x[4])-K_ZGx(x[1]-x[4]), K_ZGy(x[0]-x[4])-K_ZGy(x[1]-x[4]), K_Z(x[0]-x[0])-K_Z(x[0]-x[1])-K_Z(x[1]-x[0])+K_Z(x[1]-x[1]), K_Z(x[0]-x[2])-K_Z(x[0]-x[3])-K_Z(x[1]-x[2])+K_Z(x[1]-x[3])],\n",
    "              [K_ZGx(x[2]-x[4])-K_ZGx(x[3]-x[4]), K_ZGy(x[2]-x[4])-K_ZGy(x[3]-x[4]), K_Z(x[2]-x[0])-K_Z(x[2]-x[1])-K_Z(x[3]-x[0])+K_Z(x[3]-x[1]), K_Z(x[2]-x[2])-K_Z(x[2]-x[3])-K_Z(x[3]-x[2])+K_Z(x[3]-x[3])]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.932093Z",
     "start_time": "2020-02-25T10:59:05.928599Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.        ,  0.39633537,  0.39633537],\n",
       "       [ 0.        ,  0.        ,  0.07308107, -0.07308107],\n",
       "       [-0.39633537, -0.07308107,  1.00528762,  0.7482227 ],\n",
       "       [-0.39633537,  0.07308107,  0.7482227 ,  1.00528762]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.940277Z",
     "start_time": "2020-02-25T10:59:05.933558Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.67670915105059"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.cond(K)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.948148Z",
     "start_time": "2020-02-25T10:59:05.942071Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.58152246e+00, -6.47013039e-16, -1.26155787e+00,\n",
       "        -1.26155787e+00],\n",
       "       [-5.04126166e-17,  2.40659527e+01, -6.84171725e+00,\n",
       "         6.84171725e+00],\n",
       "       [ 1.26155787e+00,  6.84171725e+00,  0.00000000e+00,\n",
       "         0.00000000e+00],\n",
       "       [ 1.26155787e+00, -6.84171725e+00, -0.00000000e+00,\n",
       "        -0.00000000e+00]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, this first step looks reasonable now. Theoretically, we could now solve the kriging system without the universality conditions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.952511Z",
     "start_time": "2020-02-25T10:59:05.949883Z"
    }
   },
   "outputs": [],
   "source": [
    "# setting up the RHS - only gradient in x,y directions:\n",
    "b  = [gx5,gy5,0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.959021Z",
     "start_time": "2020-02-25T10:59:05.954477Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5.58152246 24.06595268  8.10327513 -5.58015938]\n"
     ]
    }
   ],
   "source": [
    "w = np.linalg.solve(K, b)\n",
    "print(w)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, weights are large - let's see what we actually interpolate - in writing the interpolator function (1) without a drift term:\n",
    "\n",
    "$$Z(x_\\alpha)^K = a_5 K_{ZG^x}^{\\alpha 5} + b_5 K_{ZG^y}^{\\alpha 5} + c_{12}(K_Z^{\\alpha 1} - K_Z^{\\alpha 2})\n",
    "+ c_{34}(K_Z^{\\alpha 3} - K_Z^{\\alpha 4})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.965826Z",
     "start_time": "2020-02-25T10:59:05.960806Z"
    }
   },
   "outputs": [],
   "source": [
    "def interp_val(xa, w, x):\n",
    "    \"\"\"Determine interpolation for scalar field value (without drift)\n",
    "    \n",
    "    Parameters:\n",
    "    xa = [x,y]: x-vector to point of estimation\n",
    "    w = [a,b,c1,c2]: estimnated weights\n",
    "    x = (n,2)-vector of known value positions\n",
    "    \"\"\"\n",
    "    return w[0]*K_ZGx(xa - x[4]) + \\\n",
    "            w[1]*K_ZGy(xa - x[4]) + \\\n",
    "            w[2]*(K_Z(xa-x[0])-K_Z(xa-x[1])) + \\\n",
    "            w[3]*(K_Z(xa-x[2])-K_Z(xa-x[3]))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.971763Z",
     "start_time": "2020-02-25T10:59:05.967461Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4.5423994553779306"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp_val([0,0], w, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And in a map-view:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:05.977077Z",
     "start_time": "2020-02-25T10:59:05.973293Z"
    }
   },
   "outputs": [],
   "source": [
    "# create points:\n",
    "xx = np.arange(-.5,2.5,0.1)\n",
    "yy = np.arange(-.5,2.5,0.1)\n",
    "XX,YY = np.meshgrid(xx,yy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.179678Z",
     "start_time": "2020-02-25T10:59:05.979257Z"
    }
   },
   "outputs": [],
   "source": [
    "scalar_field_no_drift = np.empty((len(xx), len(yy)))\n",
    "for i,xxx in enumerate(xx):\n",
    "    for j,yyy in enumerate(yy):\n",
    "        scalar_field_no_drift[i,j] = interp_val([xxx,yyy], w, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.444838Z",
     "start_time": "2020-02-25T10:59:06.184566Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 2.3999999999999995, -0.5, 2.3999999999999995)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.contour(XX, YY, scalar_field_no_drift.T, 20)\n",
    "plt.colorbar()\n",
    "plt.plot(x_int1[:,0], x_int1[:,1], 'ro')\n",
    "plt.plot(x_int2[:,0], x_int2[:,1], 'bo')\n",
    "plt.plot(x5[0], x5[1], 'go')\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"alert alert-danger\">\n",
    "  <strong>Check:</strong> The result obviously does not make sense... is this because of the missing drift or is it a problem in the implementation?\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding universal kriging terms\n",
    "\n",
    "We now add the universal kriging terms in order to obtain a meaningful drift/ variability in the interpolated scalar field. How these additional terms are included is not so directly obvious from Lajaunie et al., but the description in the appendix for a second-order drift provides some insight.\n",
    "\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "  <strong>To do:</strong> Include more information - and reference to gempy paper?\n",
    "</div>\n",
    "\n",
    "### Set up F-matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.451512Z",
     "start_time": "2020-02-25T10:59:06.447503Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [2, 0],\n",
       "       [0, 2],\n",
       "       [2, 2],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.457115Z",
     "start_time": "2020-02-25T10:59:06.453344Z"
    }
   },
   "outputs": [],
   "source": [
    "# new 25.11.2019\n",
    "F = np.array([[1, 0, x[0,0]-x[1,0], x[2,0]-x[3,0]],\n",
    "              [0, 1, x[0,1]-x[1,1], x[2,1]-x[3,1]]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combine matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.462788Z",
     "start_time": "2020-02-25T10:59:06.458796Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  0],\n",
       "       [ 0,  1],\n",
       "       [-2,  0],\n",
       "       [-2,  0]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.467654Z",
     "start_time": "2020-02-25T10:59:06.464227Z"
    }
   },
   "outputs": [],
   "source": [
    "A = np.hstack([K, F.transpose()])\n",
    "B = np.hstack([F, np.zeros((2,2))])\n",
    "krig_full = np.vstack([A,B])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.668181Z",
     "start_time": "2020-02-25T10:59:06.469205Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.682108Z",
     "start_time": "2020-02-25T10:59:06.669617Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.396335</td>\n",
       "      <td>0.396335</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.073081</td>\n",
       "      <td>-0.073081</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.396335</td>\n",
       "      <td>-0.073081</td>\n",
       "      <td>1.005288</td>\n",
       "      <td>0.748223</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.396335</td>\n",
       "      <td>0.073081</td>\n",
       "      <td>0.748223</td>\n",
       "      <td>1.005288</td>\n",
       "      <td>-2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-2.000000</td>\n",
       "      <td>-2.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2         3    4    5\n",
       "0  0.000000  0.000000  0.396335  0.396335  1.0  0.0\n",
       "1  0.000000  0.000000  0.073081 -0.073081  0.0  1.0\n",
       "2 -0.396335 -0.073081  1.005288  0.748223 -2.0  0.0\n",
       "3 -0.396335  0.073081  0.748223  1.005288 -2.0  0.0\n",
       "4  1.000000  0.000000 -2.000000 -2.000000  0.0  0.0\n",
       "5  0.000000  1.000000  0.000000  0.000000  0.0  0.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(krig_full)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.689010Z",
     "start_time": "2020-02-25T10:59:06.683976Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 0.        ,  0.        ,  0.39633537,  0.39633537,  1.        ,\n",
       "          0.        ],\n",
       "        [ 0.        ,  0.        ,  0.07308107, -0.07308107,  0.        ,\n",
       "          1.        ],\n",
       "        [-0.39633537, -0.07308107,  1.00528762,  0.7482227 , -2.        ,\n",
       "          0.        ],\n",
       "        [-0.39633537,  0.07308107,  0.7482227 ,  1.00528762, -2.        ,\n",
       "          0.        ],\n",
       "        [ 1.        ,  0.        , -2.        , -2.        ,  0.        ,\n",
       "          0.        ],\n",
       "        [ 0.        ,  1.        ,  0.        ,  0.        ,  0.        ,\n",
       "          0.        ]]),\n",
       " (6, 6))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "krig_full, krig_full.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.693175Z",
     "start_time": "2020-02-25T10:59:06.690491Z"
    }
   },
   "outputs": [],
   "source": [
    "b = np.zeros(6)\n",
    "b[0] = gx5\n",
    "b[1] = gy5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.698868Z",
     "start_time": "2020-02-25T10:59:06.694717Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.56227712, 0.        , 1.14056928, 1.14056928, 0.09590412,\n",
       "       1.        ])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = np.linalg.solve(krig_full, b)\n",
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.704050Z",
     "start_time": "2020-02-25T10:59:06.700184Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(krig_full,w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpolation function with universal drift\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.709684Z",
     "start_time": "2020-02-25T10:59:06.705311Z"
    }
   },
   "outputs": [],
   "source": [
    "def interp_val_with_drift(xa, w, x):\n",
    "    \"\"\"Determine interpolation for scalar field value\n",
    "    \n",
    "    Parameters:\n",
    "    xa = [x,y]: x-vector to point of estimation\n",
    "    w = [a,b,c1,c2]: estimnated weights\n",
    "    x = (n,2)-vector of known value positions\n",
    "    \"\"\"\n",
    "    return  w[0]*K_ZGx(xa - x[4]) + \\\n",
    "            w[1]*K_ZGy(xa - x[4]) + \\\n",
    "            w[2]*(K_Z(xa-x[0])-K_Z(xa-x[1])) + \\\n",
    "            w[3]*(K_Z(xa-x[2])-K_Z(xa-x[3])) + \\\n",
    "            w[4]*xa[0] + w[5]*xa[1]\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.716311Z",
     "start_time": "2020-02-25T10:59:06.712162Z"
    }
   },
   "outputs": [],
   "source": [
    "# create points:\n",
    "xx = np.arange(-.5,2.5,0.1)\n",
    "yy = np.arange(-.5,2.5,0.1)\n",
    "XX,YY = np.meshgrid(xx,yy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:06.885789Z",
     "start_time": "2020-02-25T10:59:06.718060Z"
    }
   },
   "outputs": [],
   "source": [
    "scalar_field_no_drift = np.empty((len(xx), len(yy)))\n",
    "for i,xxx in enumerate(xx):\n",
    "    for j,yyy in enumerate(yy):\n",
    "        scalar_field_no_drift[i,j] = interp_val_with_drift([xxx,yyy], w, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:49.727909Z",
     "start_time": "2020-02-25T10:59:49.723108Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp_val_with_drift([0,2],w,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T10:59:40.725818Z",
     "start_time": "2020-02-25T10:59:40.720519Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp_val_with_drift([2,2],w,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-19T11:47:47.000258Z",
     "start_time": "2020-02-19T11:47:46.748380Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 2.3999999999999995, -0.5, 2.3999999999999995)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.contour(XX, YY, scalar_field_no_drift.T, 20)\n",
    "plt.colorbar()\n",
    "plt.plot(x_int1[:,0], x_int1[:,1], 'ro')\n",
    "plt.plot(x_int2[:,0], x_int2[:,1], 'bo')\n",
    "plt.plot(x5[0], x5[1], 'go')\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### second order drifting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-19T11:38:19.316172Z",
     "start_time": "2020-02-19T11:38:19.310971Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  0, -2, -2],\n",
       "       [ 0,  1,  0,  0]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = np.array([[1, 0, x[0,0]-x[1,0], x[2,0]-x[3,0]],\n",
    "              [0, 1, x[0,1]-x[1,1], x[2,1]-x[3,1]]])\n",
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-19T11:38:19.326240Z",
     "start_time": "2020-02-19T11:38:19.317830Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  0, -2, -2],\n",
       "       [ 0,  1,  0,  0],\n",
       "       [ 0,  0, -4, -4],\n",
       "       [ 0,  2,  0,  0],\n",
       "       [ 1,  0,  0, -4]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_all = x\n",
    "F1 = np.array([[1, 0, x_all[0,0]-x_all[1,0], x_all[2,0]-x_all[3,0]],\n",
    "              [0, 1, x_all[0,1]-x_all[1,1], x_all[2,1]-x_all[3,1]],\n",
    "              [2*x_all[4,0], 0, x_all[0,0]**2-x_all[1,0]**2, x_all[2,0]**2-x_all[3,0]**2],\n",
    "              [0, 2*x_all[4,1], x_all[0,1]**2-x_all[1,1]**2, x_all[2,1]**2-x_all[3,1]**2],\n",
    "              [x_all[4,1], x_all[4,0], x_all[0,0]*x_all[0,1]-x_all[1,0]*x_all[1,1], x_all[2,0]*x_all[2,1]-x_all[3,0]*x_all[3,1]]])\n",
    "F1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-19T11:38:19.331482Z",
     "start_time": "2020-02-19T11:38:19.327544Z"
    }
   },
   "outputs": [],
   "source": [
    "A = np.hstack([K, F1.transpose()])\n",
    "B = np.hstack([F1, np.zeros((5,5))])\n",
    "krig_full = np.vstack([A,B])\n",
    "\n",
    "b = np.zeros(9)\n",
    "b[0] = gx5\n",
    "b[1] = gy5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This is not working due to too few data points (according to Miguel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-19T11:38:19.495283Z",
     "start_time": "2020-02-19T11:38:19.333068Z"
    }
   },
   "outputs": [
    {
     "ename": "LinAlgError",
     "evalue": "Singular matrix",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mLinAlgError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-06df1b7a4fda>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinalg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkrig_full\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36msolve\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36msolve\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m    392\u001b[0m     \u001b[0msignature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'DD->D'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misComplexType\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'dd->d'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    393\u001b[0m     \u001b[0mextobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_linalg_error_extobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_raise_linalgerror_singular\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 394\u001b[0;31m     \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgufunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextobj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mextobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    395\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    396\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mwrap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult_t\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/numpy/linalg/linalg.py\u001b[0m in \u001b[0;36m_raise_linalgerror_singular\u001b[0;34m(err, flag)\u001b[0m\n\u001b[1;32m     86\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_raise_linalgerror_singular\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 88\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mLinAlgError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Singular matrix\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     89\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_raise_linalgerror_nonposdef\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflag\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mLinAlgError\u001b[0m: Singular matrix"
     ]
    }
   ],
   "source": [
    "np.linalg.solve(krig_full, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-19T11:38:19.501979Z",
     "start_time": "2020-02-19T11:38:17.223Z"
    }
   },
   "outputs": [],
   "source": [
    "def interp_val_with_drift(xa, w, x):\n",
    "    \"\"\"Determine interpolation for scalar field value\n",
    "    \n",
    "    Parameters:\n",
    "    xa = [x,y]: x-vector to point of estimation\n",
    "    w = [a,b,c1,c2]: estimnated weights\n",
    "    x = (n,2)-vector of known value positions\n",
    "    \"\"\"\n",
    "    return  w[0]*K_ZGx(xa - x[4]) + \\\n",
    "            w[1]*K_ZGy(xa - x[4]) + \\\n",
    "            w[2]*(K_Z(xa-x[0])-K_Z(xa-x[1])) + \\\n",
    "            w[3]*(K_Z(xa-x[2])-K_Z(xa-x[3])) + \\\n",
    "            w[4]*xa[0] + w[5]*xa[1]+\\\n",
    "            w[6]*xa[0]**2+w[7]*xa[1]**2+\\\n",
    "            w[8]*xa[0]*x1Thank [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_code_all_hidden": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}