NoteBooks/GPU_Grid and Gravity_kernel_Figure5.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"accelerator":"GPU","colab":{"provenance":[],"collapsed_sections":[],"mount_file_id":"1oI88o5rkvxumyfYj3YPPs5_a4i2rC49S","authorship_tag":"ABX9TyPXH7SqoVIe2d6kX9EHzU4N"},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","metadata":{"id":"sZshD13pruJK"},"source":["# Dependency"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"IcqdD6dBrm6x","executionInfo":{"status":"ok","timestamp":1663168498353,"user_tz":300,"elapsed":45536,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"2fca2828-a536-41da-dbc4-1c991dda6cc4"},"source":["!pip install nptyping==1.0.1\n","!pip install SciencePlots\n","!pip install Theano"],"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting nptyping==1.0.1\n","  Downloading nptyping-1.0.1-py3-none-any.whl (7.2 kB)\n","Collecting typish>=1.5.2\n","  Downloading typish-1.9.3-py3-none-any.whl (45 kB)\n","\u001b[K     |████████████████████████████████| 45 kB 2.6 MB/s \n","\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from nptyping==1.0.1) (1.21.6)\n","Installing collected packages: typish, nptyping\n","Successfully installed nptyping-1.0.1 typish-1.9.3\n","Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting SciencePlots\n","  Downloading SciencePlots-1.0.9.tar.gz (10 kB)\n","  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n","\u001b[33m  WARNING: Missing build requirements in pyproject.toml for SciencePlots from https://files.pythonhosted.org/packages/c2/44/7b5c0ecd6f2862671a076425546f86ac540bc48c1a618a82d6faa3b26f58/SciencePlots-1.0.9.tar.gz#sha256=2b002f263734a718acdf1e5be57f0de5ee887e70517dfbe1118a27d0ee3dfb0f.\u001b[0m\n","\u001b[33m  WARNING: The project does not specify a build backend, and pip cannot fall back to setuptools without 'wheel'.\u001b[0m\n","  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n","  Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n","    Preparing wheel metadata ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from SciencePlots) (3.2.2)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->SciencePlots) (0.11.0)\n","Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->SciencePlots) (2.8.2)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->SciencePlots) (1.4.4)\n","Requirement already satisfied: numpy>=1.11 in /usr/local/lib/python3.7/dist-packages (from matplotlib->SciencePlots) (1.21.6)\n","Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->SciencePlots) (3.0.9)\n","Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->SciencePlots) (4.1.1)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->SciencePlots) (1.15.0)\n","Building wheels for collected packages: SciencePlots\n","  Building wheel for SciencePlots (PEP 517) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for SciencePlots: filename=SciencePlots-1.0.9-py3-none-any.whl size=6484 sha256=babb87a049286ae74c83d2c418915b138fa9c183839532052c03c31d2f4e3b60\n","  Stored in directory: /root/.cache/pip/wheels/37/f8/e9/b2f53a40b336388dfc57b108150daff7d6ffbbfc618dba3924\n","Successfully built SciencePlots\n","Installing collected packages: SciencePlots\n","Successfully installed SciencePlots-1.0.9\n","Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n","Collecting Theano\n","  Downloading Theano-1.0.5.tar.gz (2.8 MB)\n","\u001b[K     |████████████████████████████████| 2.8 MB 7.6 MB/s \n","\u001b[?25hRequirement already satisfied: numpy>=1.9.1 in /usr/local/lib/python3.7/dist-packages (from Theano) (1.21.6)\n","Requirement already satisfied: scipy>=0.14 in /usr/local/lib/python3.7/dist-packages (from Theano) (1.7.3)\n","Requirement already satisfied: six>=1.9.0 in /usr/local/lib/python3.7/dist-packages (from Theano) (1.15.0)\n","Building wheels for collected packages: Theano\n","  Building wheel for Theano (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for Theano: filename=Theano-1.0.5-py3-none-any.whl size=2668111 sha256=49eaccbe242bda1d2db0abe9975efbe448948fa3dac4fe889314d9948db0fec5\n","  Stored in directory: /root/.cache/pip/wheels/26/68/6f/745330367ce7822fe0cd863712858151f5723a0a5e322cc144\n","Successfully built Theano\n","Installing collected packages: Theano\n","Successfully installed Theano-1.0.5\n"]}]},{"cell_type":"markdown","metadata":{"id":"6xx-tcn1sA8G"},"source":["# Initiate the model"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vAwlBmjwr4XB","executionInfo":{"status":"ok","timestamp":1663168527214,"user_tz":300,"elapsed":28868,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"82e658f6-063e-4f40-c225-a7602d63aa09"},"source":["\n","import tensorflow as tf\n","\n","# gpus = tf.config.experimental.list_physical_devices('GPU') \n","# for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True)\n","from sys import getsizeof\n","\n","import matplotlib\n","# from ipywidgets import interact, interactive\n","import os\n","import numpy as np\n","import sys\n","import timeit\n","import csv\n","from functools import reduce\n","import operator\n","\n","sys.path.append('/content/drive/My Drive/YJ/GP_old')\n","\n","sys.path.append('/content/drive/My Drive/YJ')\n","\n","sys.path.append('/content/drive/MyDrive/YJ/Gravity_valid')\n","import matplotlib.pyplot as plt\n","\n","from gempy.core.grid_modules.grid_types import CenteredGrid\n","\n","import gempy as gp\n","from gempy.core.tensor.tensorflow_graph_test import TFGraph\n","import tensorflow as tf\n","import tensorflow_probability as tfp\n","import pandas as pd\n","from gempy import create_data, map_series_to_surfaces\n","from gempy.assets.geophysics import GravityPreprocessing\n","tfd = tfp.distributions\n","import seaborn as sns\n","import copy\n","from gempy.plot.visualization_2d_pro import *\n","from ThreeLayer import *\n","# %%\n","\n","X = [5000]\n","Y = [5000]\n","# X = np.linspace(2000,8000,5)\n","# Y = np.linspace(3000,7000,4)\n","\n","r = []\n","for x in X:\n","  for y in Y:\n","    r.append(np.array([x,y]))\n","receivers = np.array(r)\n","Z = 1000\n","n_devices = receivers.shape[0]\n","\n","path = '/content/drive/MyDrive/YJ/GP_old/notebooks'\n","orientation_path = \"/data/input_data/George_models/modely_orientations.csv\"\n","surface_path = '/data/input_data/George_models/'+\"modely\"+'_surface_points.csv'\n","\n","center_grid_resolution = [21,21,10]\n","# center_grid_resolution = [51,51,30]\n","regular_grid_resolution =[100, 100, 30]\n","radius=[3000,3000,1000]\n","\n","model = ModelThree(path,surface_path,orientation_path,receivers = receivers,center_grid_resolution = center_grid_resolution,regular_grid_resolution =regular_grid_resolution,dtype = 'float64',radius = radius)\n","# model.plot_model()\n","# plt.show()"],"execution_count":2,"outputs":[{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.add_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.\n","  res = method(*args, **kwargs)\n","/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.set_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.\n","  res = method(*args, **kwargs)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:2302: FutureWarning: Dropping of nuisance columns in DataFrame reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError.  Select only valid columns before calling the reduction.\n","  max_coord = df.max()[['X', 'Y', 'Z']]\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:2303: FutureWarning: Dropping of nuisance columns in DataFrame reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError.  Select only valid columns before calling the reduction.\n","  min_coord = df.min()[['X', 'Y', 'Z']]\n"]},{"output_type":"stream","name":"stdout","text":["Active grids: ['regular']\n"]},{"output_type":"stream","name":"stderr","text":["/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:1100: FutureWarning: The behavior of DataFrame([categorical, ...]) is deprecated and in a future version will be changed to match the behavior of DataFrame([any_listlike, ...]). To retain the old behavior, pass as a dictionary DataFrame({col: categorical, ..})\n","  f, columns=['series'])\n","/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n","  res = method(*args, **kwargs)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/model.py:920: FutureWarning: The `inplace` parameter in pandas.Categorical.reorder_categories is deprecated and will be removed in a future version. Reordering categories will always return a new Categorical object.\n","  ordered=False, inplace=True)\n","/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.set_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.\n","  res = method(*args, **kwargs)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/model.py:356: FutureWarning: The `inplace` parameter in pandas.Categorical.reorder_categories is deprecated and will be removed in a future version. Reordering categories will always return a new Categorical object.\n","  ordered=False, inplace=True)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:2302: FutureWarning: Dropping of nuisance columns in DataFrame reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError.  Select only valid columns before calling the reduction.\n","  max_coord = df.max()[['X', 'Y', 'Z']]\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:2303: FutureWarning: Dropping of nuisance columns in DataFrame reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError.  Select only valid columns before calling the reduction.\n","  min_coord = df.min()[['X', 'Y', 'Z']]\n","/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.set_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.\n","  res = method(*args, **kwargs)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:1100: FutureWarning: The behavior of DataFrame([categorical, ...]) is deprecated and in a future version will be changed to match the behavior of DataFrame([any_listlike, ...]). To retain the old behavior, pass as a dictionary DataFrame({col: categorical, ..})\n","  f, columns=['series'])\n","/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.remove_unused_categories is deprecated and will be removed in a future version.\n","  res = method(*args, **kwargs)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/model.py:920: FutureWarning: The `inplace` parameter in pandas.Categorical.reorder_categories is deprecated and will be removed in a future version. Reordering categories will always return a new Categorical object.\n","  ordered=False, inplace=True)\n","/usr/local/lib/python3.7/dist-packages/pandas/core/arrays/categorical.py:2631: FutureWarning: The `inplace` parameter in pandas.Categorical.set_categories is deprecated and will be removed in a future version. Removing unused categories will always return a new Categorical object.\n","  res = method(*args, **kwargs)\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:2302: FutureWarning: Dropping of nuisance columns in DataFrame reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError.  Select only valid columns before calling the reduction.\n","  max_coord = df.max()[['X', 'Y', 'Z']]\n","/content/drive/My Drive/YJ/GP_old/gempy/core/data.py:2303: FutureWarning: Dropping of nuisance columns in DataFrame reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError.  Select only valid columns before calling the reduction.\n","  min_coord = df.min()[['X', 'Y', 'Z']]\n"]},{"output_type":"stream","name":"stdout","text":["Active grids: ['regular' 'centered']\n","Active grids: ['regular' 'centered']\n"]}]},{"cell_type":"markdown","metadata":{"id":"vNyQccFmuRiR"},"source":["#Centered regular grid"]},{"cell_type":"code","metadata":{"id":"7xEkpwmXsb9c","executionInfo":{"status":"ok","timestamp":1663168527214,"user_tz":300,"elapsed":21,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["class CenteredRegGrid(CenteredGrid):\n","    \"\"\"\n","    linear spaced centered grid.\n","    \"\"\"\n","    @staticmethod\n","    def create_irregular_grid_kernel(resolution, radius):\n","        \"\"\"\n","        Create an isometric grid kernel (centered at 0)\n","\n","        Args:\n","            resolution: [s0]\n","            radius (float): Maximum distance of the kernel\n","\n","        Returns:\n","            tuple: center of the voxel, left edge of each voxel (for xyz), right edge of each voxel (for xyz).\n","        \"\"\"\n","\n","        if not isinstance(radius, list) or isinstance(radius, np.ndarray):\n","            radius = np.repeat(radius, 3)\n","\n","        g_ = []\n","        g_2 = [] # contains exp coord, left right xy, top and bottom\n","        d_ = []\n","        # size of each grid\n","        res_ =copy.deepcopy(resolution)\n","        if res_[0]%2 == 0:\n","          res_[0]+=1\n","        if res_[1]%2 == 0:\n","          res_[1]+=1\n","        dx = radius[0]*2/res_[0]\n","        dy = radius[1]*2/res_[1]\n","        dz = radius[2]/res_[2]\n","        dxyz = [dx,dy,dz]\n","        for xyz in [0, 1, 2]:\n","            if xyz == 2: # --> z\n","                # Make the grid only negative for the z axis\n","                g_.append(np.linspace(0, 1, int(resolution[xyz]),endpoint=False))\n","                g_2.append(\n","                    ((g_[xyz]+0.005)* - radius[xyz] - dz/2))\n","                \n","                d_.append(np.diff(np.pad(g_2[xyz], 1, 'reflect', reflect_type='odd')))\n","            else:\n","                g_.append(np.linspace(0, 1, num = resolution[xyz] // 2+1,endpoint=True))\n","                g_2.append(\n","                    np.concatenate((-g_[xyz][::-1], g_[xyz][1:])) * (radius[xyz]-dxyz[xyz]/2))\n","                d_.append(np.diff(np.pad(g_2[xyz], 1, 'reflect', reflect_type='odd')))\n","        \n","        g = np.meshgrid(*g_2)\n","        d_left = np.meshgrid(d_[0][:-1] / 2, d_[1][:-1] / 2, d_[2][:-1]/2)\n","        d_right = np.meshgrid(d_[0][1:] / 2, d_[1][1:] / 2, d_[2][1:]/2)\n","        kernel_g = np.vstack(tuple(map(np.ravel, g))).T.astype(\"float64\")\n","        kernel_d_left = np.vstack(tuple(map(np.ravel, d_left))).T.astype(\"float64\")\n","        kernel_d_right = np.vstack(tuple(map(np.ravel, d_right))).T.astype(\"float64\")\n","\n","        return kernel_g, kernel_d_left, kernel_d_right\n"],"execution_count":3,"outputs":[]},{"cell_type":"code","metadata":{"id":"Y0bqGcObuXfa","executionInfo":{"status":"ok","timestamp":1663168527214,"user_tz":300,"elapsed":20,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["res = center_grid_resolution\n","centerReg = CenteredRegGrid(model.xy_ravel,radius=radius,resolution=res)\n","size = reduce((lambda x, y: x * y), res)"],"execution_count":4,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":546},"id":"HBq3XMNuxHZH","executionInfo":{"status":"ok","timestamp":1663169026759,"user_tz":300,"elapsed":287,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"46f5c423-1960-4bb3-c67a-0b5c04792b95"},"source":["def plot_centered_kernel(res,radius,centerkernel,direction = 'y',n_section = 5,ax = None):\n","  if ax is None:\n","    fig,ax = plt.subplots(1,1)\n","  res_ =copy.deepcopy(res)\n","  if direction == 'y': i = 0 \n","  else: i = 1\n","  \n","  if isinstance(centerkernel,CenteredRegGrid):\n","    kernel_g, kernel_d_left, kernel_d_right = centerkernel.create_irregular_grid_kernel(resolution = res,radius=radius)\n","    print(kernel_g.shape)\n","    Slice = n_section\n","    # Trick just for plotting\n","    # the resolution is transposed in meshgrid\n","    if res_[0]%2 == 0:\n","      res_[0]+=1\n","    if res_[1]%2 == 0:\n","      res_[1]+=1\n","    res_[0],res_[1] =res_[1], res_[0]\n","    # plotting the centers\n","    if i == 0: # y direction        \n","      ax.scatter(kernel_g[:,i].reshape(res_)[Slice,:,:],kernel_g[:,2].reshape(res_)[Slice,:,:],c = 'b') # center\n","      ax.scatter((kernel_g[:,i]-kernel_d_left[:,i]).reshape(res_)[Slice,:,:],kernel_g[:,2].reshape(res_)[Slice,:,:],'r')\n","    if i == 1: # x direction\n","      ax.scatter(kernel_g[:,i].reshape(res_)[:,Slice,:],kernel_g[:,2].reshape(res_)[:,Slice,:],s  =19,c = 'cornflowerblue') # center\n","      left_x = (kernel_g[:,i]-kernel_d_left[:,i]).reshape(res_)[:,Slice,:].flatten()\n","      right_x = (kernel_g[:,i]+kernel_d_right[:,i]).reshape(res_)[:,Slice,:].flatten()\n","      top_z = (kernel_g[:,2]-kernel_d_left[:,2]).reshape(res_)[:,Slice,:].flatten()\n","      bot_z = (kernel_g[:,2]+kernel_d_left[:,2]).reshape(res_)[:,Slice,:].flatten()\n","\n","      ax.vlines(x = left_x[::res[-1]],ymax = np.min(bot_z),ymin = np.max(top_z),linewidth=0.3,alpha=1,colors='black')\n","      ax.vlines(x = right_x[-1],ymax = np.min(bot_z),ymin = np.max(top_z),linewidth=0.3,alpha=1,colors='black')\n","\n","      ax.hlines(y = bot_z[:res[-1]],xmax = np.min(left_x),xmin = np.max(right_x),linewidth=0.3,alpha=1,colors='black')\n","      ax.hlines(y = top_z[0],xmax = np.min(left_x),xmin = np.max(right_x),linewidth=0.3,alpha=1,colors='black')\n","      ax.plot(0,0,marker = 7,c='r',markersize = 15,label = 'Receiver')\n","      ax.set_xlabel('x')\n","      ax.set_ylabel('z')\n","\n","      # a= ax.get_yticks().tolist()\n","      # ax.set_yticklabels([int(abs(tick)) for tick in a], minor=False)\n","\n","      print(a)\n","\n","plot_centered_kernel(res,radius,centerReg,'x',n_section = 2)"],"execution_count":32,"outputs":[{"output_type":"stream","name":"stdout","text":["(4410, 3)\n","<tf.Variable 'Variable:0' shape=(11,) dtype=float32, numpy=\n","array([-1.2403723 , -0.06536541,  0.41015726,  0.7887358 ,  1.1164645 ,\n","        1.4143891 ,  1.7306225 ,  2.0853188 ,  2.5096593 ,  3.082     ,\n","        3.9924538 ], dtype=float32)>\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 748.8x514.8 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"8nhMANN4xejl","executionInfo":{"status":"ok","timestamp":1663168527373,"user_tz":300,"elapsed":7,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["# activate the customized grid\n","def activate_customized_grid(model,centerReg):\n","  model.geo_data.grid.custom_grid=centerReg\n","  model.geo_data.grid.deactivate_all_grids()\n","  # activate also rescaled the grid\n","  model.geo_data.grid.set_active('custom')\n","  model.geo_data.rescaling.set_rescaled_grid()\n"],"execution_count":6,"outputs":[]},{"cell_type":"code","metadata":{"id":"mpC0o7H7xur1","executionInfo":{"status":"ok","timestamp":1663168527373,"user_tz":300,"elapsed":6,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["def calculate_grav_center_regular(model,centerReg,values_properties):\n","  activate_customized_grid(model,centerReg)\n","  g_center_regulargrid = GravityPreprocessing(centerReg)\n","  tz_center_regulargrid = g_center_regulargrid.set_tz_kernel()\n","  fault_drift = np.zeros((0, model.grid.values.shape[0] ))\n","  size = centerReg.values.shape[0]\n","  fault_drift = fault_drift[:,:size]\n","  grid_tensor = model.geo_data.grid.values_r\n","  model.TFG = TFGraph(model.dip_angles, model.azimuth,model.polarity, fault_drift,\n","  grid_tensor, model.values_properties, model.len_rest_form, model.Range,\n","  model.C_o, model.nugget_effect_scalar, model.nugget_effect_grad,\n","  model.rescale_factor,dtype = model.tfdtype)\n","  Z_x = model.TFG.scalar_field(model.surface_points_coord,model.dips_position)\n","\n","  scalar_field_at_surface_points = model.TFG.get_scalar_field_at_surface_points(Z_x)\n","  # formations_block = model.TFG.export_formation_block(\n","  #     Z_x, scalar_field_at_surface_points, model.values_properties)\n","  formations_block = model.TFG.export_formation_block(\n","      Z_x, scalar_field_at_surface_points, values_properties)\n","\n","  # densities = formations_block[1][model.lg_0:model.lg_1]\n","  densities = formations_block[1][:size]\n","\n","  gravity_center_reg = model.TFG.compute_forward_gravity(tz_center_regulargrid, 0, size, densities)\n","  return gravity_center_reg"],"execution_count":7,"outputs":[]},{"cell_type":"code","source":["model.activate_regular_grid()"],"metadata":{"id":"HbHt9chLGZPo","executionInfo":{"status":"ok","timestamp":1663168527563,"user_tz":300,"elapsed":196,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"execution_count":8,"outputs":[]},{"cell_type":"code","metadata":{"id":"ZRa2SFgrxsFd","executionInfo":{"status":"ok","timestamp":1663168536606,"user_tz":300,"elapsed":9045,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["gravity_center_reg = calculate_grav_center_regular(model,centerReg,model.values_properties)"],"execution_count":9,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"0-TA6QXhbylM"},"source":["## Resolution"]},{"cell_type":"code","metadata":{"id":"RS2G5GdZb0wL","executionInfo":{"status":"ok","timestamp":1663168536607,"user_tz":300,"elapsed":14,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["# gravity_center_reg_list = []\n","# for i in range(5,30,2):\n","#   print(i)\n","#   res = [i,40,i]\n","#   centerReg = CenteredRegGrid(model.xy_ravel,radius=[2000,2000,1000],resolution=res)\n","#   print(centerReg.kernel_centers.shape)\n","#   gravity_center_reg = calculate_grav_center_regular(model.values_properties)\n","#   gravity_center_reg_list.append(gravity_center_reg)\n","#   # plot_centered_kernel(res,1000,centerReg,'x',n_section = 2)"],"execution_count":10,"outputs":[]},{"cell_type":"code","metadata":{"id":"CcE8b-sYyDRp","executionInfo":{"status":"ok","timestamp":1663168536608,"user_tz":300,"elapsed":14,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["# plt.plot(gravity_center_reg_list)"],"execution_count":11,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"ooEdNcFEMr8O"},"source":["# Centered grid"]},{"cell_type":"code","metadata":{"id":"Cjk_3bdZyOhB","executionInfo":{"status":"ok","timestamp":1663168547780,"user_tz":300,"elapsed":11186,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["center_grid_resolution = res\n","# path = '/content/drive/MyDrive/YJ/GP_old/notebooks'\n","# model = ModelThree(path,surface_path,orientation_path,receivers = receivers,center_grid_resolution = center_grid_resolution,regular_grid_resolution =regular_grid_resolution,dtype = 'float64')\n","\n","model.activate_centered_grid()\n","grav_centered = model.calculate_grav(model.surface_points_coord,model.values_properties)"],"execution_count":12,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":458},"id":"RHyWuHGEcflE","executionInfo":{"status":"ok","timestamp":1663169031995,"user_tz":300,"elapsed":209,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"b32acb67-eb7f-426d-b645-14ee1592956c"},"source":["def plot_centered_kernel(res,radius,centerkernel,direction = 'y',n_section = 5,ax = None):\n","  if ax is None: \n","    fig,ax = plt.subplots(1,1)\n","  res_ =copy.deepcopy(res)\n","  if direction == 'y': i = 0 \n","  else: i = 1\n","  \n","  if isinstance(centerkernel,CenteredGrid):\n","    kernel_g, kernel_d_left, kernel_d_right = centerkernel.create_irregular_grid_kernel(resolution = res,radius=radius)\n","    print(kernel_g.shape)\n","    Slice = n_section\n","    # Trick just for plotting\n","    # the resolution is transposed in meshgrid\n","    if res_[0]%2 == 0:\n","      res_[0]+=1\n","    if res_[1]%2 == 0:\n","      res_[1]+=1\n","    # res_[2]+=1\n","    res_[0],res_[1] =res_[1], res_[0]\n","    # plotting the centers\n","    if i == 0: # y direction        \n","      ax.scatter(kernel_g[:,i].reshape(res_)[Slice,:,:],kernel_g[:,2].reshape(res_)[Slice,:,:],c = 'b') # center\n","      ax.scatter((kernel_g[:,i]-kernel_d_left[:,i]).reshape(res_)[Slice,:,:],kernel_g[:,2].reshape(res_)[Slice,:,:],'r')\n","    if i == 1: # x direction\n","      ax.scatter(kernel_g[:,i].reshape(res_)[:,Slice,:],kernel_g[:,2].reshape(res_)[:,Slice,:],s  =19,c = 'cornflowerblue') # center\n","      left_x = (kernel_g[:,i]-kernel_d_left[:,i]).reshape(res_)[:,Slice,:].flatten()\n","      right_x = (kernel_g[:,i]+kernel_d_right[:,i]).reshape(res_)[:,Slice,:].flatten()\n","      top_z = (kernel_g[:,2]-kernel_d_left[:,2]).reshape(res_)[:,Slice,:].flatten()\n","      bot_z = (kernel_g[:,2]+kernel_d_left[:,2]).reshape(res_)[:,Slice,:].flatten()\n","\n","      # ax.scatter(left_x,kernel_g[:,2].reshape(res_)[:,Slice,:].flatten(),s  =13, c = 'g',alpha=0.5) # left\n","      # ax.scatter(right_x,kernel_g[:,2].reshape(res_)[:,Slice,:].flatten(),s = 13, c = 'r',alpha=0.5) # right\n","      # ax.scatter(kernel_g[:,i].reshape(res_)[:,Slice,:],top_z,s = 13, c = 'k',alpha=0.5) # top\n","      # ax.scatter(kernel_g[:,i].reshape(res_)[:,Slice,:],bot_z,s = 13, c = 'y',alpha=0.5) # bot\n","\n","    ax.vlines(x = left_x[::res[-1]],ymax = np.min(bot_z),ymin = np.max(top_z),linewidth=0.3,alpha=1,colors='black')\n","    ax.vlines(x = right_x[-1],ymax = np.min(bot_z),ymin = np.max(top_z),linewidth=0.3,alpha=1,colors='black')\n","\n","    ax.hlines(y = bot_z[:res[-1]],xmax = np.min(left_x),xmin = np.max(right_x),linewidth=0.3,alpha=1,colors='black')\n","    ax.hlines(y = top_z[0],xmax = np.min(left_x),xmin = np.max(right_x),linewidth=0.3,alpha=1,colors='black')\n","    ax.plot(0,0,marker = 7,c='r',markersize = 15,label = 'Receiver')\n","\n","    # set axis to depth\n","    # a= ax.get_yticks().tolist()\n","    # ax.set_yticklabels([int(abs(tick)) for tick in a], minor=False)\n","    \n","plot_centered_kernel(center_grid_resolution,radius,model.grid.centered_grid,direction='x',n_section = 2)"],"execution_count":33,"outputs":[{"output_type":"stream","name":"stdout","text":["(4410, 3)\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 748.8x514.8 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","metadata":{"id":"DM0fGPHwclOa"},"source":["# ML"]},{"cell_type":"code","metadata":{"id":"7GmbhMm27Ilq","executionInfo":{"status":"ok","timestamp":1663168548263,"user_tz":300,"elapsed":11,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["def make_variables(k, initializer):\n","  return (tf.Variable(initializer(shape=[k], dtype=tf.float32)))\n","\n","def softmax_space(parameters):\n","  return tf.nn.softmax(parameters)\n","\n","def constant32(x):\n","  return tf.constant(x,dtype=tf.float32)"],"execution_count":14,"outputs":[]},{"cell_type":"code","metadata":{"id":"LjDe1WljUUeN","executionInfo":{"status":"ok","timestamp":1663168548263,"user_tz":300,"elapsed":10,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["resolution = constant32(center_grid_resolution)\n","radius_t =constant32(radius)\n","size = (resolution[0]+1)*(resolution[1]+1)*(resolution[2])\n"],"execution_count":15,"outputs":[]},{"cell_type":"code","metadata":{"id":"j26RDwrt7hCF","executionInfo":{"status":"ok","timestamp":1663168548263,"user_tz":300,"elapsed":10,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["\n","def compute_tz(a,b,c):\n","  g_x = tf.cumsum(softmax_space(a))\n","  g_y = tf.cumsum(softmax_space(b))\n","  g_z = tf.cumsum(softmax_space(c))\n","\n","  g2_x = tf.concat((-g_x[::-1], g_x),axis=0) * radius_t[0]\n","  g2_y = tf.concat((-g_y[::-1], g_y),axis=0) * radius_t[1]\n","  g2_z =  (tf.concat(([0], g_z),axis=0) + 0.005) * - radius_t[2]\n","\n","  x_center = (g2_x[:-1]+g2_x[1:])/2 \n","  y_center = (g2_y[:-1]+g2_y[1:])/2\n","  z_center = (g2_z[:-1]+g2_z[1:])/2\n","\n","  g = tf.meshgrid(x_center,y_center,z_center)\n","\n","  d_left_x = tf.math.abs(g2_x[:-1] - x_center)\n","  d_left_y = tf.math.abs(g2_y[:-1] - y_center)\n","  d_right_x = tf.math.abs(g2_x[1:] - x_center)\n","  d_right_y = tf.math.abs(g2_y[1:] - y_center)\n","  d_z = z_center - g2_z[:-1]\n","\n","  d_left = tf.meshgrid(d_left_x,d_left_y,d_z)\n","  d_right = tf.meshgrid(d_right_x,d_right_y,d_z)\n","\n","  kernel_g = tf.concat([tf.reshape(g[0],[-1,1]),tf.reshape(g[1],[-1,1]),tf.reshape(g[2],[-1,1])],axis=1)\n","  kernel_d_left = tf.concat([tf.reshape(d_left[0],[-1,1]),tf.reshape(d_left[1],[-1,1]),tf.reshape(d_left[2],[-1,1])],axis=1)\n","  kernel_d_right = tf.concat([tf.reshape(d_right[0],[-1,1]),tf.reshape(d_right[1],[-1,1]),tf.reshape(d_right[2],[-1,1])],axis=1)\n","\n","  s_gr_x = kernel_g[:, 0]\n","  s_gr_y = kernel_g[:, 1]\n","  s_gr_z = kernel_g[:, 2]\n","\n","  # # getting the coordinates of the corners of the voxel...\n","  x_cor = tf.transpose(tf.stack([s_gr_x - kernel_d_left[:, 0], s_gr_x + kernel_d_right[:, 0]], axis=0))\n","  y_cor = tf.transpose(tf.stack((s_gr_y - kernel_d_left[:, 1], s_gr_y + kernel_d_right[:, 1]), axis=0))\n","  z_cor = tf.transpose(tf.stack((s_gr_z - kernel_d_left[:, 2], s_gr_z + kernel_d_right[:, 2]), axis=0))\n","\n","  x_matrix = tf.repeat(x_cor, 4, axis=1)\n","  y_matrix = tf.tile(tf.repeat(y_cor, 2, axis=1), (1, 2))\n","  z_matrix = tf.tile(z_cor, (1, 4))\n","\n","  s_r = tf.sqrt(x_matrix ** 2 + y_matrix ** 2 + z_matrix ** 2)\n","\n","  mu = constant32([1, -1, -1, 1, -1, 1, 1, -1])\n","\n","  G = constant32(6.674e-3)\n","\n","  tz = (\n","        G *\n","        tf.reduce_sum(- 1 *\n","                mu * (\n","                        x_matrix * tf.math.log(y_matrix + s_r) +\n","                        y_matrix * tf.math.log(x_matrix + s_r) -\n","                        z_matrix * tf.math.atan(x_matrix * y_matrix / (z_matrix * s_r))),\n","                axis=1))\n","  return tz\n","\n","\n","\n","def loss(a,b,c):\n","  tz = compute_tz(a,b,c)\n","  l = tf.math.reduce_std(tz)\n","  return l\n","\n"],"execution_count":16,"outputs":[]},{"cell_type":"code","metadata":{"id":"pspECC2lX5Xt","executionInfo":{"status":"ok","timestamp":1663168549071,"user_tz":300,"elapsed":817,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["min = -1\n","max = 1\n","a = make_variables(tf.cast(resolution[0]/2+1,tf.int32),initializer= tf.random_uniform_initializer(minval=min, maxval=max, seed=None))\n","b = make_variables(tf.cast(resolution[1]/2+1,tf.int32),initializer= tf.random_uniform_initializer(minval=min, maxval=max, seed=None))\n","c = make_variables(tf.cast(resolution[2],tf.int32),initializer= tf.random_uniform_initializer(minval=min, maxval=max, seed=None))\n","\n","var_list =[a,b,c]\n","\n","@tf.function\n","def train_step(a,b,c):\n","  with tf.GradientTape() as tape:\n","    loss_value = loss(a,b,c)\n","    grads = tape.gradient(loss_value,var_list)\n","\n","  opt.apply_gradients(zip(grads, var_list))\n","  return loss_value"],"execution_count":17,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"OgGgUsZ_iJg8","executionInfo":{"status":"ok","timestamp":1663168553799,"user_tz":300,"elapsed":4738,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"efe95327-0dbd-4b20-d519-80b1bf215bd8"},"source":["# opt = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)\n","opt = tf.keras.optimizers.Adam(\n","    learning_rate=0.01, beta_1=0.9, beta_2=0.999, epsilon=1e-07, amsgrad=False,\n","    name='Adam')\n","\n","import time\n","epochs = 1000\n","for epoch in range(epochs):\n","  \n","  \n","  start_time = time.time()\n","  loss_value = train_step(a,b,c)\n","  if epoch%200==0:\n","    print(\"\\nStart of epoch %d\" % (epoch,))\n","    print(\"loss: %.4f\" % (float(loss_value),))\n","    print(\"Time taken: %.2fs\" % (time.time() - start_time))"],"execution_count":18,"outputs":[{"output_type":"stream","name":"stdout","text":["\n","Start of epoch 0\n","loss: 0.1185\n","Time taken: 2.78s\n","\n","Start of epoch 200\n","loss: 0.0207\n","Time taken: 0.01s\n","\n","Start of epoch 400\n","loss: 0.0105\n","Time taken: 0.00s\n","\n","Start of epoch 600\n","loss: 0.0087\n","Time taken: 0.00s\n","\n","Start of epoch 800\n","loss: 0.0084\n","Time taken: 0.00s\n"]}]},{"cell_type":"code","metadata":{"id":"lVrviRbLluyH","executionInfo":{"status":"ok","timestamp":1663168553799,"user_tz":300,"elapsed":18,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["a,b,c = var_list"],"execution_count":19,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vihsHzlVpCUb","executionInfo":{"status":"ok","timestamp":1663168553800,"user_tz":300,"elapsed":18,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"fec09294-2569-456e-b3fc-37864c777777"},"source":["g_x = softmax_space(a)\n","tf.cumsum(g_x)"],"execution_count":20,"outputs":[{"output_type":"execute_result","data":{"text/plain":["<tf.Tensor: shape=(11,), dtype=float32, numpy=\n","array([0.00253566, 0.01074654, 0.02395665, 0.04324616, 0.07001638,\n","       0.10607748, 0.15555152, 0.22608902, 0.33391136, 0.52501684,\n","       1.        ], dtype=float32)>"]},"metadata":{},"execution_count":20}]},{"cell_type":"code","source":["# plt.plot(a.numpy(),'.')\n","# plt.plot(softmax_space(a).numpy(),'.')\n","plt.plot(tf.cumsum(softmax_space(a)).numpy(),'.')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":458},"id":"qVTUl4q5Imax","executionInfo":{"status":"ok","timestamp":1663168553994,"user_tz":300,"elapsed":210,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"0076b891-f3af-44eb-db78-725c216e943f"},"execution_count":21,"outputs":[{"output_type":"execute_result","data":{"text/plain":["[<matplotlib.lines.Line2D at 0x7f38c619fad0>]"]},"metadata":{},"execution_count":21},{"output_type":"display_data","data":{"text/plain":["<Figure size 748.8x514.8 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"Si6wD3Pyrnen","executionInfo":{"status":"ok","timestamp":1663168553994,"user_tz":300,"elapsed":6,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["def create_irregular_grid_kernel(resolution, radius,a,b,c):\n","\n","    g_x = tf.cumsum(softmax_space(a))\n","    g_y = tf.cumsum(softmax_space(b))\n","    g_z = tf.cumsum(softmax_space(c))\n","\n","    g2_x = tf.concat((-g_x[::-1], g_x),axis=0) * radius[0]\n","    g2_y = tf.concat((-g_y[::-1], g_y),axis=0) * radius[1]\n","    g2_z =  (tf.concat(([0], g_z),axis=0) + 0.005) * - radius[2]\n","\n","    x_center = (g2_x[:-1]+g2_x[1:])/2 \n","    y_center = (g2_y[:-1]+g2_y[1:])/2\n","    z_center = (g2_z[:-1]+g2_z[1:])/2\n","\n","    g = tf.meshgrid(x_center,y_center,z_center)\n","\n","    d_left_x = tf.math.abs(g2_x[:-1] - x_center)\n","    d_left_y = tf.math.abs(g2_y[:-1] - y_center)\n","    d_right_x = tf.math.abs(g2_x[1:] - x_center)\n","    d_right_y = tf.math.abs(g2_y[1:] - y_center)\n","    d_z = z_center - g2_z[:-1]\n","\n","    d_left = tf.meshgrid(d_left_x,d_left_y,d_z)\n","    d_right = tf.meshgrid(d_right_x,d_right_y,d_z)\n","\n","    kernel_g = tf.concat([tf.reshape(g[0],[-1,1]),tf.reshape(g[1],[-1,1]),tf.reshape(g[2],[-1,1])],axis=1)\n","    kernel_d_left = tf.concat([tf.reshape(d_left[0],[-1,1]),tf.reshape(d_left[1],[-1,1]),tf.reshape(d_left[2],[-1,1])],axis=1)\n","    kernel_d_right = tf.concat([tf.reshape(d_right[0],[-1,1]),tf.reshape(d_right[1],[-1,1]),tf.reshape(d_right[2],[-1,1])],axis=1)\n","\n","    return kernel_g, kernel_d_left, kernel_d_right\n"],"execution_count":22,"outputs":[]},{"cell_type":"code","metadata":{"id":"O5OwH4Qnsv6x","executionInfo":{"status":"ok","timestamp":1663168923891,"user_tz":300,"elapsed":179,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["def plot_ml_kernel(res,radius,a,b,c,direction = 'y',n_section = 5,ax = None,tz=None):\n","  if ax is None:\n","    fig,ax = plt.subplots(1,1)\n","  # res_ =copy.deepcopy(res.numpy()).astype(int)\n","  res_ =copy.deepcopy(res).astype(int)\n","  if direction == 'y': i = 0 \n","  else: i = 1\n","  \n","  kernel_g, kernel_d_left, kernel_d_right =create_irregular_grid_kernel(resolution,radius,a,b,c)\n","  kernel_g, kernel_d_left, kernel_d_right = kernel_g.numpy(), kernel_d_left.numpy(), kernel_d_right.numpy()\n","\n","  Slice = n_section\n","  # Trick just for plotting\n","  # the resolution is transposed in meshgrid\n","  if res_[0]%2 == 0:\n","    res_[0]+=1\n","  if res_[1]%2 == 0:\n","    res_[1]+=1\n","  # res_[2]+=1\n","  res_[0],res_[1] =res_[1], res_[0]\n","  # plotting the centers\n","  if i == 0: # y direction    \n","    center_xy_coord = kernel_g[:,i].reshape(res_)[Slice,:,:]\n","    center_z_coord = kernel_g[:,2].reshape(res_)[Slice,:,:]\n","    if tz is not None:\n","      tz_ = tz.reshape(res_)[Slice,:,:]\n","    # plt.scatter(kernel_g[:,i].reshape(res_)[Slice,:,:],kernel_g[:,2].reshape(res_)[Slice,:,:],c = 'b') # center\n","    # plt.scatter((kernel_g[:,i]-kernel_d_left[:,i]).reshape(res_)[Slice,:,:],kernel_g[:,2].reshape(res_)[Slice,:,:],'r')\n","    ax.set_xlabel('x')\n","  if i == 1: # x direction\n","    center_xy_coord = kernel_g[:,i].reshape(res_)[:,Slice,:]\n","    center_z_coord = kernel_g[:,2].reshape(res_)[:,Slice,:]\n","    if tz is not None:\n","      tz_ = tz.reshape(res_)[:,Slice,:]\n","\n","  if tz is not None:\n","    ax.scatter(center_xy_coord,center_z_coord,s  =tz_,c = 'cornflowerblue') # center\n","    print(tz.max(),tz.min())\n","  else:\n","    ax.scatter(center_xy_coord,center_z_coord,s  =19,c = 'cornflowerblue') # center\n","\n","  left_x = (kernel_g[:,i]-kernel_d_left[:,i]).reshape(res_)[:,Slice,:].flatten()\n","  right_x = (kernel_g[:,i]+kernel_d_right[:,i]).reshape(res_)[:,Slice,:].flatten()\n","  top_z = (kernel_g[:,2]-kernel_d_left[:,2]).reshape(res_)[:,Slice,:].flatten()\n","  bot_z = (kernel_g[:,2]+kernel_d_left[:,2]).reshape(res_)[:,Slice,:].flatten()\n","  \n","  ax.vlines(x = left_x[::res_[-1]],ymax = np.min(bot_z),ymin = np.max(top_z),linewidth=0.3,alpha=1,colors='black')\n","  ax.vlines(x = right_x[-1],ymax = np.min(bot_z),ymin = np.max(top_z),linewidth=0.3,alpha=1,colors='black')\n","\n","  ax.hlines(y = bot_z[:res_[-1]],xmax = np.min(left_x),xmin = np.max(right_x),linewidth=0.3,alpha=1,colors='black')\n","  ax.hlines(y = top_z[0],xmax = np.min(left_x),xmin = np.max(right_x),linewidth=0.3,alpha=1,colors='black')\n","  ax.plot(0,0,marker = 7,c='r',markersize = 15,label = 'Receiver')\n","\n","  # revert ticks to allow plotting possitive value downwards in matplotlib\n","  # a= ax.get_yticks().tolist()\n","  # ax.set_yticklabels([int(abs(tick)) for tick in a], minor=False)\n","# plot_kernel(resolution,[3000,3000,1000],a,b,c,direction='x',n_section = 25)"],"execution_count":30,"outputs":[]},{"cell_type":"code","metadata":{"id":"PUc7-aQvpxGU","executionInfo":{"status":"ok","timestamp":1663168554140,"user_tz":300,"elapsed":151,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["tz = compute_tz(a,b,c).numpy()"],"execution_count":24,"outputs":[]},{"cell_type":"code","metadata":{"id":"O-nsVMC1km8t","executionInfo":{"status":"ok","timestamp":1663168554141,"user_tz":300,"elapsed":3,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"source":["# plot_kernel(resolution,[3000,3000,1000],a,b,c,direction='x',n_section = 26,tz=-tz*10000)"],"execution_count":25,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":378},"id":"AMtCZZgtpvXQ","executionInfo":{"status":"ok","timestamp":1663168554951,"user_tz":300,"elapsed":812,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"dda3c08a-c2d4-451d-c1b2-a9edbaa6a1ab"},"source":["import math\n","w = 0.001\n","n_center_regulargrid = math.ceil((tz.max() - tz.min())/w)\n","fig, ax = plt.subplots(figsize=(10,6))\n","sns.histplot(data=tz,color='green',bins = n_center_regulargrid)\n","ax.set_yscale('symlog')"],"execution_count":26,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 720x432 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"fUmdem_p6n8K","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1663168554951,"user_tz":300,"elapsed":8,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"d027c7ca-2d1c-475e-8e71-39d891b8cbf3"},"source":["print('machine learning grid', 'std:',np.std(tz),'mean',np.mean(tz),'sum',np.sum(tz))"],"execution_count":27,"outputs":[{"output_type":"stream","name":"stdout","text":["machine learning grid std: 0.008293749 mean -0.008099896 sum -35.720543\n"]}]},{"cell_type":"markdown","metadata":{"id":"d8AJuSMbwqG5"},"source":["# Plotting"]},{"cell_type":"code","source":["# model.activate_centered_grid()"],"metadata":{"id":"hCi1bQawG0U5","executionInfo":{"status":"ok","timestamp":1663168554952,"user_tz":300,"elapsed":6,"user":{"displayName":"george liang","userId":"13911471454046444619"}}},"execution_count":28,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":387},"id":"Lk9uHkNDwpYR","executionInfo":{"status":"ok","timestamp":1663169038668,"user_tz":300,"elapsed":1928,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"a36983d3-8ea4-4bac-cc90-7d4ccdef9ba7"},"source":["fig,axes = plt.subplots(1,3,figsize = (20,5))\n","plot_centered_kernel(res,radius,centerReg,'x',n_section = 2,ax = axes[0])\n","plot_centered_kernel(center_grid_resolution,radius,model.grid.centered_grid,direction='x',n_section = 2,ax = axes[1])\n","plot_ml_kernel(np.array(center_grid_resolution),radius,a,b,c,direction='x',n_section = 2,ax = axes[2])\n","for ax in axes:\n","  ax.set_xlabel('x',fontsize = 25)\n","  ax.set_ylabel('z',fontsize = 25)\n","fig.tight_layout()\n","plt.savefig('/content/drive/MyDrive/YJ/Gravity_valid/Figures/tz_plot_202010_R1_elevation.png',dpi = 300)"],"execution_count":34,"outputs":[{"output_type":"stream","name":"stdout","text":["(4410, 3)\n","(4410, 3)\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1440x360 with 3 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["g_center_regulargrid = GravityPreprocessing(centerReg)\n","tz_center_regulargrid = g_center_regulargrid.set_tz_kernel()"],"metadata":{"id":"d0VTk-6uLQjj"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["g_center_geom = GravityPreprocessing(model.grid.centered_grid)\n","tz_center_geom = g_center_geom.set_tz_kernel()"],"metadata":{"id":"-ey9thjdOXEx"},"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":352},"id":"YPfQvoLYxBxP","executionInfo":{"status":"ok","timestamp":1662946087679,"user_tz":300,"elapsed":7857,"user":{"displayName":"george liang","userId":"13911471454046444619"}},"outputId":"9e8a4bf9-3221-4541-af0c-4a556d88c4ca"},"source":["fig,axes = plt.subplots(1,3,figsize = (20,5),sharex=True,sharey=True)\n","\n","w = 0.01\n","n_center_regulargrid = math.ceil((tz_center_regulargrid.max() - tz_center_regulargrid.min())/w)\n","sns.histplot(data=tz_center_regulargrid,bins = n_center_regulargrid,ax = axes[0])\n","# sns.kdeplot(data = tz_center_regulargrid,ax = axes [0],color = 'red')\n","\n","n_centered_exp = math.ceil((tz_center_geom.max() - tz_center_geom.min())/w)\n","sns.histplot(data=tz_center_geom,bins =n_centered_exp,ax = axes[1])\n","# sns.kdeplot(data = tz_centered,ax = axes [1],color = 'red')\n","\n","n_center_optimized = math.ceil((tz.max() - tz.min())/w)\n","sns.histplot(data=tz,bins = n_center_optimized,ax = axes[2])\n","# sns.kdeplot(data = tz,ax = axes [2],color = 'red')\n","\n","for ax in axes:\n","  ax.set_ylim(top = 1e5) \n","  ax.set_yscale('symlog')\n","  ax.set_ylabel('Count',fontsize = 25)\n","  ax.set_xlabel('$t_z$',fontsize = 25)\n","\n","  a= ax.get_xticks().tolist()\n","  ax.set_xticklabels([\"{0:.1f}\".format(abs(tick)) for tick in a], minor=False)\n","# \"{:.2f}\".format(z)\n","# text_x = -2.8\n","# text_y = 3000\n","text_x = -.93\n","text_y = 30000\n","axes[0].text(text_x,text_y,'Regular grid',weight='bold')\n","axes[1].text(text_x,text_y,'Exponential grid',weight='bold')\n","axes[2].text(text_x,text_y,'Optimized grid',weight='bold')\n","fig.tight_layout()\n","plt.savefig('/content/drive/MyDrive/YJ/Gravity_valid/Figures/tz_hist_202010_R1.png',dpi = 300)"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 1440x360 with 3 Axes>"],"image/png":"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\n"},"metadata":{}}]}]}