4.3.16 Probabilistic AVO analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "from collections import namedtuple\n",
    "import warnings\n",
    "import pandas as pd\n",
    "from packages.functions import vshale_from_gr, vrh\n",
    "import glob\n",
    "import os\n",
    "#!pip install lasio\n",
    "import lasio as lasio\n",
    "import numpy as np\n",
    "import platform\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy.stats import gaussian_kde\n",
    "from matplotlib.lines import Line2D\n",
    "import math\n",
    "import statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def r0g(vp1, vs1, rho1, vp2, vs2, rho2):\n",
    "    \n",
    "    R0 = []\n",
    "    G = []\n",
    "    R_theta = []\n",
    "\n",
    "    for i in range(len(vp1)):\n",
    "\n",
    "        delta_rho = rho2[i] - rho1[i]\n",
    "        delta_vp = vp2[i] - vp1[i]\n",
    "        delta_vs = vs2[i] - vs1[i]\n",
    "\n",
    "        vp = (vp2[i] + vp1[i]) / 2\n",
    "        vs = (vs2[i] + vs1[i]) / 2\n",
    "        rho = (rho2[i] + rho1[i]) / 2\n",
    "\n",
    "        R0_temp = 1/2*((delta_vp / vp) + (delta_rho / rho))\n",
    "        R0.append(R0_temp)\n",
    "\n",
    "        G_temp = 1/2 * (delta_vp / vp) - 2 * vs**2/vp**2 * ((delta_rho / rho) + (2*delta_vs / vs))\n",
    "        G.append(G_temp)\n",
    "\n",
    "        R_theta_i = []\n",
    "        for theta in range(41):\n",
    "            R_theta_i.append(R0_temp + G_temp*(np.sin(math.radians(theta))**2))\n",
    "        R_theta.append([R_theta_i])        \n",
    "\n",
    "    median = []\n",
    "\n",
    "    for j in range(41):\n",
    "        angle = []\n",
    "        for k in range(len(vp2)):\n",
    "            angle.append(R_theta[k][0][j])\n",
    "        median.append(statistics.median(angle))\n",
    "        \n",
    "    return R0, G, R_theta, median\n",
    "\n",
    "\n",
    "def load():\n",
    "    well_df = [0] * len(paths)\n",
    "\n",
    "    for i in range(len(paths)):\n",
    "        # read with lasio\n",
    "        well = lasio.read(paths[i])\n",
    "        # convert to dataframe\n",
    "        df = well.df()\n",
    "        # in this dataframe, depth is positioned as index, not as column\n",
    "        # so better to change depth index to column\n",
    "        well_df[i] = df.reset_index()\n",
    "        well_df[i].rename(columns={'DEPT': 'DEPTH'}, inplace=True)\n",
    "        # replace null values (-9999.0) with NaN\n",
    "        well_df[i] = well_df[i].replace(-9999.0, np.NaN)\n",
    "\n",
    "    return well_df\n",
    "\n",
    "\n",
    "def well2_add_features():\n",
    "    well1, well2, well3, well4, well5, well5_resist = load()\n",
    "\n",
    "    # well2 adding features\n",
    "\n",
    "    well2 = vshale_from_gr(well2)\n",
    "\n",
    "    well2[\"PHIE\"] = (2.65 - well2.RHOB) / (2.65 - 1.05)\n",
    "    well2[\"IP\"] = well2.VP * 1000 * well2.RHOB\n",
    "    well2[\"IS\"] = well2.VS * 1000 * well2.RHOB\n",
    "    well2[\"VPVS\"] = well2.VP / well2.VS\n",
    "    # well2['K'] = well2.DEN*(well2.VP**2 - 4/3.*(well2.VS)**2)  # ?? what is this bulk modulus ??\n",
    "\n",
    "    well2['sandy-shaly'] = np.where(well2['VSH'] >= 0.35, 'shaly', 'sandy')\n",
    "\n",
    "    shale = well2.VSH.values  #\n",
    "    # shale = df.VWCL.values\n",
    "\n",
    "    sand = 1 - shale - well2.PHIE.values\n",
    "    shaleN = shale / (shale + sand)  # normalized shale and sand volumes\n",
    "    sandN = sand / (shale + sand)\n",
    "\n",
    "    # mineral mixture bulk and shear moduli, k0 and mu0  # ?? A mineral mixture BUT NOT dry rock bulk modulus??\n",
    "    k_u, k_l, mu_u, mu_l, k0, mu0 = vrh([shaleN, sandN], [K_CLAY, K_QUARTZ], [MU_CLAY, MU_QUARTZ])\n",
    "\n",
    "    well2['K0'] = k0\n",
    "\n",
    "    ## well2 should be\n",
    "    # Facies I: Gravels => not used\n",
    "    # Facies II: Thick bedded sandstones; IIa, IIb, IIc, IId\n",
    "    # Facies III: Interbedded sandstone-shale\n",
    "    # Facies IV: Silty shales and silt-laminated shale\n",
    "    # Facies V: Pure shales\n",
    "    # Facies VI: Chaotic deposits => not used\n",
    "\n",
    "    conditions = [\n",
    "        (well2[\"DEPTH\"].ge(2078.0) & well2[\"DEPTH\"].lt(2105.0)),\n",
    "        (well2[\"DEPTH\"].ge(2143.2) & well2[\"DEPTH\"].lt(2154.1)),\n",
    "        (well2[\"DEPTH\"].ge(2154.1) & well2[\"DEPTH\"].lt(2164.1)),\n",
    "        (well2[\"DEPTH\"].ge(2168.1) & well2[\"DEPTH\"].lt(2184.1)),\n",
    "        (well2[\"DEPTH\"].ge(2186.1) & well2[\"DEPTH\"].lt(2200.1)),\n",
    "        (well2[\"DEPTH\"].ge(2254.0) & well2[\"DEPTH\"].lt(2300.1)),\n",
    "    ]\n",
    "    # facies = [\"shale\", \"sltShale\", \"clnSand\", \"sltSand1\", \"sltSand2\", \"cemSand\"]\n",
    "    facies = [1, 2, 3, 4, 5, 6]  # == FCODES[1:]\n",
    "    well2[\"FACIES\"] = np.select(conditions, facies)\n",
    "\n",
    "    reservoir = [0, 0, 1, 1, 0, 1]\n",
    "    well2[\"RESERVOIR\"] = np.select(conditions, reservoir)\n",
    "\n",
    "    facies_labels = [\"shale\", \"sltShale\", \"clnSand\", \"sltSand1\", \"sltSand2\", \"cemSand\"]\n",
    "    well2[\"LABELS\"] = np.select(conditions, facies_labels)\n",
    "    # well2[\"FACIES\"] = np.select(conditions, facies)  # can I use FCODES[1:] ???\n",
    "\n",
    "    facies_codes = [6, 0, 6, 1, 2, 6, 3, 6, 4, 6, 5, 6]  # for well log plot\n",
    "    conditions = [\n",
    "        (well2[\"DEPTH\"].ge(well2.DEPTH.min()) & well2[\"DEPTH\"].lt(2078.0)),  # undef=0    6\n",
    "        (well2[\"DEPTH\"].ge(2078.0) & well2[\"DEPTH\"].lt(2105.0)),  # shale=1    0\n",
    "        (well2[\"DEPTH\"].ge(2105.0) & well2[\"DEPTH\"].lt(2143.2)),  # undef=0    6\n",
    "        (well2[\"DEPTH\"].ge(2143.2) & well2[\"DEPTH\"].lt(2154.1)),  # sltShale=2 1\n",
    "        (well2[\"DEPTH\"].ge(2154.1) & well2[\"DEPTH\"].lt(2164.1)),  # clnSand=3  2\n",
    "        (well2[\"DEPTH\"].ge(2164.1) & well2[\"DEPTH\"].lt(2168.1)),  # undef=0    6\n",
    "        (well2[\"DEPTH\"].ge(2168.1) & well2[\"DEPTH\"].lt(2184.1)),  # sltSand1=4 3\n",
    "        (well2[\"DEPTH\"].ge(2184.1) & well2[\"DEPTH\"].lt(2186.1)),  # undef=0    6\n",
    "        (well2[\"DEPTH\"].ge(2186.1) & well2[\"DEPTH\"].lt(2200.1)),  # sltSand2=5 4\n",
    "        (well2[\"DEPTH\"].ge(2200.1) & well2[\"DEPTH\"].lt(2254.0)),  # undef=0    6\n",
    "        (well2[\"DEPTH\"].ge(2254.0) & well2[\"DEPTH\"].lt(2300.1)),  # cemSand=6  5\n",
    "        (well2[\"DEPTH\"].ge(2300.1) & well2[\"DEPTH\"].lt(well2.DEPTH.max()))  # undef=0    6\n",
    "    ]\n",
    "    well2[\"FCODES\"] = np.select(conditions, facies_codes)\n",
    "\n",
    "    return well1, well2, well3, well4, well5, well5_resist\n",
    "\n",
    "\n",
    "# FROM AGILE SCIENTIFIC, Bruges\n",
    "\n",
    "def twolayer(vp0,vs0,rho0,vp1,vs1,rho1):\n",
    "    #from bruges.reflection import shuey2      # TODO:  install bruges.reflection\n",
    "    #from bruges.filters import ricker         # TODO:  install bruges.filters\n",
    "\n",
    "    n_samples = 500\n",
    "    interface=int(n_samples/2)\n",
    "    ang=np.arange(31)\n",
    "    wavelet=ricker(.25, 0.001, 25)\n",
    "    # !!! MODIFICATION !!!\n",
    "    # numpy.convolve(a, v, mode='full')\n",
    "    # v(M,) array_like, Second one-dimensional input array.\n",
    "    # wavelet return from ricker is >1 dimensional\n",
    "    wavelet = wavelet[0]\n",
    "\n",
    "    model_ip, model_vpvs, rc0, rc1 = (np.zeros(n_samples) for _ in range(4))\n",
    "    \n",
    "    model_z = np.arange(n_samples)\n",
    "    model_ip[:interface]=vp0*rho0\n",
    "    model_ip[interface:]=vp1*rho1\n",
    "    model_vpvs[:interface]=np.true_divide(vp0,vs0)\n",
    "    model_vpvs[interface:]=np.true_divide(vp1,vs1)\n",
    "\n",
    "    avo=shuey(vp0,vs0,rho0,vp1,vs1,rho1,ang)\n",
    "    rc0[interface]=avo[0]\n",
    "    rc1[interface]=avo[-1]\n",
    "    synt0=np.convolve(rc0,wavelet,mode='same')\n",
    "    synt1=np.convolve(rc1,wavelet,mode='same')\n",
    "    clip=np.max(np.abs([synt0, synt1]))\n",
    "    clip += clip*.2\n",
    "    \n",
    "    opz0={'color':'b', 'linewidth':4}\n",
    "    opz1={'color':'k', 'linewidth':2}\n",
    "    opz2={'linewidth':0, 'alpha':0.5}\n",
    "\n",
    "    f = plt.subplots(figsize=(10, 4))\n",
    "    ax0 = plt.subplot2grid((1,16), (0,0), colspan=2) # ip\n",
    "    ax1 = plt.subplot2grid((1,16), (0,2), colspan=2) # vp/vs\n",
    "    ax2 = plt.subplot2grid((1,16), (0,4), colspan=2) # synthetic @ 0 deg\n",
    "    ax3 = plt.subplot2grid((1,16), (0,6), colspan=2) # synthetic @ 30 deg\n",
    "    ax4 = plt.subplot2grid((1,16), (0,9), colspan=7) # avo curve\n",
    "\n",
    "    ax0.plot(model_ip, model_z, **opz0)\n",
    "    ax0.set_xlabel('IP')\n",
    "    ax0.locator_params(axis='x', nbins=2)\n",
    "\n",
    "    ax1.plot(model_vpvs, model_z, **opz0)\n",
    "    ax1.set_xlabel('VP/VS')\n",
    "    ax1.locator_params(axis='x', nbins=2)\n",
    "\n",
    "    ax2.plot(synt0, model_z, **opz1)\n",
    "    ax2.fill_betweenx(model_z, 0, synt0, where=synt0>0, facecolor='black', **opz2)\n",
    "    ax2.set_xlim(-clip,clip)\n",
    "    ax2.set_xlabel('angle={:.0f}'.format(ang[0]))\n",
    "    ax2.locator_params(axis='x', nbins=2)\n",
    "\n",
    "    ax3.plot(synt1, model_z, **opz1)\n",
    "    ax3.fill_betweenx(model_z, 0, synt1, where=synt1>0, facecolor='black', **opz2)\n",
    "    ax3.set_xlim(-clip,clip)\n",
    "    ax3.set_xlabel('angle={:.0f}'.format(ang[-1]))\n",
    "    ax3.locator_params(axis='x', nbins=2)\n",
    "\n",
    "    ax4.plot(ang, avo, **opz0)\n",
    "    ax4.axhline(0, color='k', lw=2)\n",
    "    ax4.set_xlabel('angle of incidence')\n",
    "    ax4.tick_params(which='major', labelsize=8)\n",
    "    ax4.set_ylim(0, 0.15)                                   ## added 27/5/2022\n",
    "\n",
    "    for aa in [ax0,ax1,ax2,ax3]:\n",
    "        aa.set_ylim(350,150)\n",
    "        aa.tick_params(which='major', labelsize=8)\n",
    "        aa.set_yticklabels([])\n",
    "\n",
    "    plt.subplots_adjust(wspace=.8,left=0.05,right=0.95)\n",
    "\n",
    "\n",
    "def vectorize(func):\n",
    "    \"\"\"\n",
    "    Decorator to make sure the inputs are arrays. We also add a dimension\n",
    "    to theta to make the functions work in an 'outer product' way.\n",
    "    Takes a reflectivity function requiring Vp, Vs, and RHOB for 2 rocks\n",
    "    (upper and lower), plus incidence angle theta, plus kwargs. Returns\n",
    "    that function with the arguments transformed to ndarrays.\n",
    "    \"\"\"\n",
    "    @wraps(func)\n",
    "    def wrapper(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0, **kwargs):\n",
    "\n",
    "        vp1 = np.asanyarray(vp1, dtype=float)\n",
    "        vs1 = np.asanyarray(vs1, dtype=float) + 1e-12  # Prevent singular matrix.\n",
    "        rho1 = np.asanyarray(rho1, dtype=float)\n",
    "        vp2 = np.asanyarray(vp2, dtype=float)\n",
    "        vs2 = np.asanyarray(vs2, dtype=float) + 1e-12  # Prevent singular matrix.\n",
    "        rho2 = np.asanyarray(rho2, dtype=float)\n",
    "\n",
    "        new_shape = [-1] + vp1.ndim * [1]\n",
    "        theta1 = theta1.reshape(*new_shape)\n",
    "        if (np.nan_to_num(theta1) > np.pi/2.).any():\n",
    "            raise ValueError(\"Incidence angle theta1 must be less than 90 deg.\")\n",
    "\n",
    "        return func(vp1, vs1, rho1, vp2, vs2, rho2, theta1, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "def preprocess(func):\n",
    "    \"\"\"\n",
    "    Decorator to preprocess arguments for the reflectivity equations.\n",
    "    Takes a reflectivity function requiring Vp, Vs, and RHOB for 2 rocks\n",
    "    (upper and lower), plus incidence angle theta, plus kwargs. Returns\n",
    "    that function with some arguments transformed.\n",
    "    \"\"\"\n",
    "    @wraps(func)\n",
    "    def wrapper(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0, **kwargs):\n",
    "\n",
    "        # Interpret tuple for theta1 as a linspace.\n",
    "        if isinstance(theta1, tuple):\n",
    "            if len(theta1) == 2:\n",
    "                start, stop = theta1\n",
    "                theta1 = np.linspace(start, stop, num=stop+1)\n",
    "            elif len(theta1) == 3:\n",
    "                start, stop, step = theta1\n",
    "                steps = (stop / step) + 1\n",
    "                theta1 = np.linspace(start, stop, num=steps)\n",
    "            else:\n",
    "                raise TypeError(\"Expected 2 or 3 parameters for theta1 expressed as range.\")\n",
    "\n",
    "        # Convert theta1 to radians and complex numbers.\n",
    "        theta1 = np.radians(theta1).astype(complex)\n",
    "\n",
    "        return func(vp1, vs1, rho1, vp2, vs2, rho2, theta1, **kwargs)\n",
    "    return wrapper\n",
    "    \n",
    "@preprocess\n",
    "@vectorize\n",
    "def shuey(vp1, vs1, rho1, vp2, vs2, rho2, theta1=0,\n",
    "          terms=False,\n",
    "          return_gradient=False):\n",
    "    \"\"\"\n",
    "    Compute Shuey approximation with 3 terms.\n",
    "    http://subsurfwiki.org/wiki/Shuey_equation\n",
    "    Args:\n",
    "        vp1 (ndarray): The upper P-wave velocity; float or 1D array length m.\n",
    "        vs1 (ndarray): The upper S-wave velocity; float or 1D array length m.\n",
    "        rho1 (ndarray): The upper layer's density; float or 1D array length m.\n",
    "        vp2 (ndarray): The lower P-wave velocity; float or 1D array length m.\n",
    "        vs2 (ndarray): The lower S-wave velocity; float or 1D array length m.\n",
    "        rho2 (ndarray): The lower layer's density; float or 1D array length m.\n",
    "        theta1 (ndarray): The incidence angle; float or 1D array length n.\n",
    "        terms (bool): Whether or not to return a tuple of the terms of the\n",
    "            equation. The first term is the acoustic impedance.\n",
    "        return_gradient (bool): Whether to return a tuple of the intercept\n",
    "            and gradient (i.e. the second term divided by sin^2(theta)).\n",
    "    Returns:\n",
    "        ndarray. The Aki-Richards approximation for P-P reflectivity at the\n",
    "            interface. Will be a float (for float inputs and one angle), a\n",
    "            1 x n array (for float inputs and an array of angles), a 1 x m\n",
    "            array (for float inputs and one angle), or an n x m array (for\n",
    "            array inputs and an array of angles).\n",
    "    \"\"\"\n",
    "    theta1 = np.real(theta1)\n",
    "\n",
    "    drho = rho2-rho1\n",
    "    dvp = vp2-vp1\n",
    "    dvs = vs2-vs1\n",
    "    rho = (rho1+rho2)/2.0\n",
    "    vp = (vp1+vp2)/2.0\n",
    "    vs = (vs1+vs2)/2.0\n",
    "\n",
    "    # Compute three-term reflectivity\n",
    "    r0 = 0.5 * (dvp/vp + drho/rho)\n",
    "    g = 0.5 * dvp/vp - 2 * (vs**2/vp**2) * (drho/rho + 2 * dvs/vs)\n",
    "    f = 0.5 * dvp/vp\n",
    "\n",
    "    term1 = r0\n",
    "    term2 = g * np.sin(theta1)**2\n",
    "    term3 = f * (np.tan(theta1)**2 - np.sin(theta1)**2)\n",
    "\n",
    "    if return_gradient:\n",
    "        fields = ['intercept', 'gradient']\n",
    "        Shuey = namedtuple('Shuey', fields)\n",
    "        return Shuey(np.squeeze(r0), np.squeeze(term2))\n",
    "    elif terms:\n",
    "        fields = ['R0', 'Rg', 'Rf']\n",
    "        Shuey = namedtuple('Shuey', fields)\n",
    "        return Shuey(np.squeeze([term1 for _ in theta1]),\n",
    "                     np.squeeze(term2),\n",
    "                     np.squeeze(term3)\n",
    "                     )\n",
    "    else:\n",
    "        return np.squeeze(term1 + term2 + term3)\n",
    "    \n",
    "    \n",
    "def ricker(duration, dt, f, t=None, return_t=True, sym=True):\n",
    "    \"\"\"\n",
    "    Also known as the mexican hat wavelet, models the function:\n",
    "    .. math::\n",
    "        A =  (1 - 2 \\pi^2 f^2 t^2) e^{-\\pi^2 f^2 t^2}\n",
    "    If you pass a 1D array of frequencies, you get a wavelet bank in return.\n",
    "    .. plot::\n",
    "        import matplotlib.pyplot as plt\n",
    "        import bruges\n",
    "        w, t = bruges.filters.ricker(0.256, 0.002, 40)\n",
    "        plt.plot(t, w)\n",
    "    Args:\n",
    "        duration (float): The length in seconds of the wavelet.\n",
    "        dt (float): The sample interval in seconds (often one of  0.001, 0.002,\n",
    "            or 0.004).\n",
    "        f (array-like): Centre frequency of the wavelet in Hz. If a sequence is\n",
    "            passed, you will get a 2D array in return, one row per frequency.\n",
    "        t (array-like): The time series to evaluate at, if you don't want one\n",
    "            to be computed. If you pass `t` then `duration` and `dt` will be\n",
    "            ignored, so we recommend passing `None` for those arguments.\n",
    "        return_t (bool): If True, then the function returns a tuple of\n",
    "            wavelet, time-basis.\n",
    "        sym (bool): If True (default behaviour before v0.5) then the wavelet\n",
    "            is forced to have an odd number of samples and the central sample\n",
    "            is at 0 time.\n",
    "    Returns:\n",
    "        ndarray. Ricker wavelet(s) with centre frequency f sampled on t. If\n",
    "            you passed `return_t=True` then a tuple of (wavelet, t) is returned.\n",
    "    \"\"\"\n",
    "    if not return_t:\n",
    "        m = \"return_t is deprecated. In future releases, return_t will always be True.\"\n",
    "        warnings.warn(m, DeprecationWarning, stacklevel=2)\n",
    "\n",
    "    f = np.asanyarray(f).reshape(-1, 1)\n",
    "\n",
    "    if t is None:\n",
    "        t = _get_time(duration, dt, sym=sym)\n",
    "    else:\n",
    "        if (duration is not None) or (dt is not None):\n",
    "            m = \"`duration` and `dt` are ignored when `t` is passed.\"\n",
    "            warnings.warn(m, UserWarning, stacklevel=2)\n",
    "\n",
    "    pft2 = (np.pi * f * t)**2\n",
    "    w = np.squeeze((1 - (2 * pft2)) * np.exp(-pft2))\n",
    "\n",
    "    if return_t:\n",
    "        RickerWavelet = namedtuple('RickerWavelet', ['amplitude', 'time'])\n",
    "        return RickerWavelet(w, t)\n",
    "    else:\n",
    "        return w\n",
    "    \n",
    "    \n",
    "def _get_time(duration, dt, sym=True):\n",
    "    \"\"\"\n",
    "    Make a time vector.\n",
    "    If `sym` is `True`, the time vector will have an odd number of samples,\n",
    "    and will be symmetric about 0. If it's False, and the number of samples\n",
    "    is even (e.g. duration = 0.016, dt = 0.004), then 0 will bot be center.\n",
    "    \"\"\"\n",
    "    # This business is to avoid some of the issues with `np.arange`:\n",
    "    # (1) unpredictable length and (2) floating point weirdness, like\n",
    "    # 1.234e-17 instead of 0. Not using `linspace` because figuring out\n",
    "    # the length and offset gave me even more of a headache than this.\n",
    "    n = int(duration / dt)\n",
    "    odd = n % 2\n",
    "    k = int(10**-np.floor(np.log10(dt)))\n",
    "    dti = int(k * dt)  # integer dt\n",
    "\n",
    "    if (odd and sym):\n",
    "        t = np.arange(n)\n",
    "    elif (not odd and sym):\n",
    "        t = np.arange(n + 1)\n",
    "    elif (odd and not sym):\n",
    "        t = np.arange(n)\n",
    "    elif (not odd and not sym):\n",
    "        t = np.arange(n) - 1\n",
    "\n",
    "    t -= t[-1] // 2\n",
    "\n",
    "    return dti * t / k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_os = platform.system()\n",
    "if my_os == 'Windows':\n",
    "    path = \".\\data\"\n",
    "elif my_os == 'Linux':\n",
    "    path = './data'\n",
    "\n",
    "# get all paths and alphabetically ordered\n",
    "paths = sorted(glob.glob(os.path.join(path, \"*.las\")))\n",
    "#print(paths)\n",
    "\n",
    "# # Rock properties\n",
    "K_QUARTZ = 36.8  # GPa\n",
    "MU_QUARTZ = 44  # GPa\n",
    "K_CLAY = 15  # GPa\n",
    "MU_CLAY = 5  # GPa\n",
    "\n",
    "ccc = ['#996633', '#1B4F72', '#FFC82E','#FF7A36', '#DB0000', '#40CBFF', '#B3B3B3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if at work...\n",
    "# path = r\"C:\\Users\\ALDUNBAR\\OneDrive - Wintershall Dea AG\\QSI\\data\"\n",
    "file = 'well-2.las'\n",
    "# if os=linux\n",
    "# path = '/home/alex/Dropbox/Work/QSI/data'\n",
    "\n",
    "# if at home, os=windows\n",
    "path = r\"C:\\Users\\Dunbar\\Dropbox\\Work\\QSI\\data\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "well1, well2, well3, well4, well5_resist, well5 = well2_add_features()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2234-2274m,262 samples) Vp=2.922, Vs=1.342, rho=2.17, Ip=6.351, Vp/Vs=2.18 \n",
      "(2274-2314m,263 samples) Vp=3.193, Vs=1.564, rho=2.22, Ip=7.073, Vp/Vs=2.04 \n"
     ]
    }
   ],
   "source": [
    "df = well2\n",
    "top=2274\n",
    "z0=top-40\n",
    "z1=top\n",
    "z2=top+40\n",
    "z=well2.DEPTH\n",
    "ss = (z>=z1) & (z<=z2)\n",
    "sh = (z>=z0) & (z<=z1)\n",
    "\n",
    "vp0_mean, vs0_mean, rho0_mean = df[['VP','VS','RHOB']][sh].mean().values\n",
    "vp1_mean, vs1_mean, rho1_mean = df[['VP','VS','RHOB']][ss].mean().values\n",
    "#vpg_mean, vsg_mean, rhog_mean = df[['VP_FRMG', 'VS_FRMG', 'RHO_FRMG']][ss].mean().values\n",
    "samples_sh=np.isfinite(df.DEPTH[sh]).size\n",
    "samples_ss=np.isfinite(df.DEPTH[ss]).size\n",
    "\n",
    "print('({:>4.0f}-{:<4.0f}m,{:3d} samples) Vp={:.3f}, Vs={:.3f}, rho={:.2f}, Ip={:.3f}, Vp/Vs={:.2f} '.format(z0,z1,samples_sh,vp0_mean,vs0_mean,rho0_mean,vp0_mean*rho0_mean,vp0_mean/vs0_mean))\n",
    "print('({:>4.0f}-{:<4.0f}m,{:3d} samples) Vp={:.3f}, Vs={:.3f}, rho={:.2f}, Ip={:.3f}, Vp/Vs={:.2f} '.format(z1,z2,samples_ss,vp1_mean,vs1_mean,rho1_mean,vp1_mean*rho1_mean,vp1_mean/vs1_mean))\n",
    "#print('({:>4.0f}-{:<4.0f}m,{:3d} samples) Vp={:.0f}, Vs={:.0f}, rho={:.2f}, Ip={:.0f}, Vp/Vs={:.2f} '.format(z1,z2,samples_ss,vpg_mean,vsg_mean,rhog_mean,vpg_mean*rhog_mean,vpg_mean/vsg_mean))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "twolayer(vp0_mean, vs0_mean, rho0_mean, vp1_mean, vs1_mean, rho1_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kde_resample(df, col, lithologies, logs,  num_samples=1000):\n",
    "    \"\"\"\n",
    "    Resample from each litho-facies a set number of times\n",
    "    Inputs:\n",
    "    df: well data in pandas dataframe with column of litho-facies and columns of Vp, Vs and rho logs\n",
    "    col: column containing the litho-facies categories\n",
    "    lithologies: the categories (could use column and .unique() instead of input list)\n",
    "    logs: list of column names of Vp, Vs, rho (e.g. 'RHOB' or 'DEN', etc)\n",
    "    num_samples: number of resamples from gaussian_kde.resample()\n",
    "    \"\"\"\n",
    "    \n",
    "    kde_resample_array = [0] * len(lithologies)\n",
    "    \n",
    "    for i in range(len(lithologies)):\n",
    "        lith_logs = df[df[col]==lithologies[i]][logs[0]],\\\n",
    "                        df[df[col]==lithologies[i]][logs[1]],\\\n",
    "                        df[df[col]==lithologies[i]][logs[2]]\n",
    "        # reset_index() ??\n",
    "        kde_lith_logs = gaussian_kde(lith_logs)\n",
    "        kde_resample_array[i] = kde_lith_logs.resample(num_samples)\n",
    "            \n",
    "    return kde_resample_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "column = 'LABELS'\n",
    "lith_list = ['shale', 'sltShale', 'clnSand', 'sltSand1', 'sltSand2', 'cemSand']\n",
    "logs = ['VP', 'VS', 'RHOB']\n",
    "num_samples = 1000\n",
    "\n",
    "kde = kde_resample(well2, column, lith_list, logs, num_samples=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# kde[0]=='shale', kde[1]=='sltShale', kde[2]=='clnSand', kde[3]. kde[4], kde[5]\n",
    "# kde[.][0]=='VP', kde[.][1]=='VS', kde[.][2]=='RHOB'\n",
    "# Assumes that cap rock is in position 0\n",
    "\n",
    "#                                r0g(vp0      , vs0      , rho0     , vp1      , vs1      , rho1)\n",
    "r01_b, G1_b, Rtheta1_b, med1_b = r0g(kde[0][0], kde[0][1], kde[0][2], kde[1][0], kde[1][1], kde[1][2])\n",
    "r02_b, G2_b, Rtheta2_b, med2_b = r0g(kde[0][0], kde[0][1], kde[0][2], kde[2][0], kde[2][1], kde[2][2])\n",
    "r03_b, G3_b, Rtheta3_b, med3_b = r0g(kde[0][0], kde[0][1], kde[0][2], kde[3][0], kde[3][1], kde[3][2])\n",
    "r04_b, G4_b, Rtheta4_b, med4_b = r0g(kde[0][0], kde[0][1], kde[0][2], kde[4][0], kde[4][1], kde[4][2])\n",
    "r05_b, G5_b, Rtheta5_b, med5_b = r0g(kde[0][0], kde[0][1], kde[0][2], kde[5][0], kde[5][1], kde[5][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha1=0.01\n",
    "alpha2=0.05\n",
    "\n",
    "fig, ((ax1, ax2, ax3, ax4,ax5),(ax6,ax7,ax8,ax9,ax10)) = plt.subplots(2, 5, figsize=(12,6))\n",
    "fig.suptitle('AVO')\n",
    "\n",
    "ax1.scatter(r01_b, G1_b, label=\"sltShale\", alpha=alpha1, color='blue')\n",
    "sns.kdeplot(ax=ax1, x=r01_b, y=G1_b, color='blue', linestyles=\"-\", levels=4)\n",
    "ax1.set_xlabel(\"R(0)\"); ax1.set_ylabel(\"G\")\n",
    "\n",
    "ax2.scatter(r02_b, G2_b, label=\"clnSand\", alpha=alpha1, color='blue')\n",
    "sns.kdeplot(ax=ax2, x=r02_b, y=G2_b, color=\"blue\", linestyles=\"-\", levels=4)\n",
    "ax2.set_xlabel(\"R(0)\"); ax3.set_ylabel(\"G\")\n",
    "\n",
    "ax3.scatter(r03_b, G3_b, label=\"sltSand1\", alpha=alpha1, color='blue')\n",
    "sns.kdeplot(ax=ax3, x=r03_b, y=G3_b, color=\"blue\", linestyles=\"-\", levels=4)\n",
    "ax3.set_xlabel(\"R(0)\"); ax3.set_ylabel(\"G\")\n",
    "\n",
    "ax4.scatter(r04_b, G4_b, label=\"sltSand2\", alpha=alpha1, color='blue')\n",
    "sns.kdeplot(ax=ax4, x=r04_b, y=G4_b, color=\"blue\", linestyles=\"-\", levels=4)\n",
    "ax4.set_xlabel(\"R(0)\"); ax4.set_ylabel(\"G\")\n",
    "\n",
    "ax5.scatter(r05_b, G5_b, label=\"cemSand\", alpha=alpha1, color='blue')\n",
    "sns.kdeplot(ax=ax5, x=r05_b, y=G5_b, color=\"blue\", linestyles=\"-\", levels=4)\n",
    "ax5.set_xlabel(\"R(0)\"); ax5.set_ylabel(\"G\")\n",
    "\n",
    "for i in range(num_samples):\n",
    "    ax6.plot(Rtheta1_b[i][0], alpha=alpha2, color='blue')\n",
    "ax6.plot(med1_b, 'k')\n",
    "ax6.set_xlabel(\"theta\"); ax6.set_ylabel(\"Amplitude\")\n",
    "\n",
    "for i in range(num_samples):\n",
    "    ax7.plot(Rtheta2_b[i][0], alpha=alpha2, color='blue')\n",
    "ax7.plot(med2_b, 'k')\n",
    "ax7.set_xlabel(\"theta\"); ax7.set_ylabel(\"Amplitude\")\n",
    "\n",
    "for i in range(num_samples):\n",
    "    ax8.plot(Rtheta3_b[i][0], alpha=alpha2, color='blue')\n",
    "ax8.plot(med3_b, 'k')\n",
    "ax8.set_xlabel(\"theta\"); ax8.set_ylabel(\"Amplitude\")\n",
    "\n",
    "for i in range(num_samples):\n",
    "    ax9.plot(Rtheta4_b[i][0], alpha=alpha2, color='blue')\n",
    "ax9.plot(med4_b, 'k')\n",
    "ax9.set_xlabel(\"theta\"); ax9.set_ylabel(\"Amplitude\")\n",
    "\n",
    "for i in range(num_samples):\n",
    "    ax10.plot(Rtheta5_b[i][0], alpha=alpha2, color='blue')\n",
    "ax10.plot(med5_b, 'k')\n",
    "ax10.set_xlabel(\"theta\"); ax10.set_ylabel(\"Amplitude\")\n",
    "\n",
    "\n",
    "\n",
    "ax1.set_xlim(-0.15, 0.5); ax1.set_ylim(-0.6, 0.4);\n",
    "ax2.set_xlim(-0.15, 0.5); ax2.set_ylim(-0.6, 0.4); \n",
    "ax3.set_xlim(-0.15, 0.5); ax3.set_ylim(-0.6, 0.4);\n",
    "ax4.set_xlim(-0.15, 0.5); ax4.set_ylim(-0.6, 0.4);\n",
    "ax5.set_xlim(-0.15, 0.5); ax5.set_ylim(-0.6, 0.4);\n",
    "\n",
    "ax6.set_xlim(0,40); ax6.set_ylim(-0.15, 0.3);\n",
    "ax7.set_xlim(0,40); ax7.set_ylim(-0.15, 0.3);\n",
    "ax8.set_xlim(0,40); ax8.set_ylim(-0.15, 0.3);\n",
    "ax9.set_xlim(0,40); ax9.set_ylim(-0.15, 0.3);\n",
    "ax10.set_xlim(0,40); ax10.set_ylim(-0.15, 0.3);\n",
    "\n",
    "\n",
    "for ax in fig.get_axes():\n",
    "    ax.legend()\n",
    "    #ax.label_outer()\n",
    "    ax.axvline(0, color='gray')\n",
    "    ax.axhline(0, color='gray')\n",
    "    \n",
    "plt.tight_layout()\n",
    "\n",
    "#plt.savefig(\"./images/R0_G_AVO_modeling.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}