SOFI2D-v2016.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3864dd3b",
   "metadata": {},
   "source": [
    "## SOFI 2D Model Builder - v2016 Script\n",
    "### Beta version\n",
    "- This code shows an interactive and step-by-step code to generate 2D models ready to run in SOFI2D\n",
    "- It works only with 2016 version (json file cannot be read by v2023)\n",
    "- Structures and examples are focused on acoustic well-logging applications\n",
    "- Code stability: Design and QC tested and working for elastic models. QC for viscoelastic models is ongoing work.\n",
    "\n",
    "##### Reference:\n",
    "I used - SOFI 2D - User Guide written by Thomas Bohlen, Denise De Nil, Daniel Kohn and Stefan Jetschny\n",
    "\n",
    "Link: https://git.scc.kit.edu/GPIAG-Software/SOFI2D/-/wikis/home\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe7b1fdf",
   "metadata": {},
   "source": [
    "#### Imported Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "be94f280",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os                                                 # to set current working directory \n",
    "import math                                               # basic calculations like square root\n",
    "import numpy as np                                        # arrays and matrix math\n",
    "import pandas as pd                                       # DataFrames for tabular data\n",
    "import matplotlib.pyplot as plt                           # plotting\n",
    "import json\n",
    "import struct\n",
    "import sympy\n",
    "from scipy.fft import fft, fftfreq, fftshift"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25f34d4f",
   "metadata": {},
   "source": [
    "#### Imported datafames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2c33d17e",
   "metadata": {},
   "outputs": [],
   "source": [
    "TaylorCoeffs=pd.read_csv('https://github.com/GGGiozzaG/SOFI2D-3D/blob/main/import/Taylor.csv',delimiter=',',index_col=0)\n",
    "Holberg01Coeffs=pd.read_csv('https://github.com/GGGiozzaG/SOFI2D-3D/blob/main/import/Holberg_01.csv',delimiter=',',index_col=0)\n",
    "Holberg03Coeffs=pd.read_csv('https://github.com/GGGiozzaG/SOFI2D-3D/blob/main/import/Holberg_03.csv',delimiter=',',index_col=0)\n",
    "Holberg10Coeffs=pd.read_csv('https://github.com/GGGiozzaG/SOFI2D-3D/blob/main/import/Holberg_10.csv',delimiter=',',index_col=0)\n",
    "Holberg30Coeffs=pd.read_csv('https://github.com/GGGiozzaG/SOFI2D-3D/blob/main/import/Holberg_30.csv',delimiter=',',index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88afc963",
   "metadata": {},
   "source": [
    "#### Functions - Model Generation (Long section, soon I may build a repository...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9e91ca84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Layer placement libraries (Needs performance improvement)\n",
    "\n",
    "# Horizontal layers\n",
    "# Base Layer Generation Function\n",
    "def HorizontalLayer(NX,NY,dh,zz_base,Top,Thickness,zz_new):\n",
    "    xx_grid, yy_grid = np.meshgrid(np.linspace(0,NX-1,NX),np.linspace(0,NY-1,NY))\n",
    "    xx_m=xx_grid*dh\n",
    "    yy_m=yy_grid*dh\n",
    "    for x in range(NY):\n",
    "        for y in range(NX):\n",
    "            if yy_m[x,y]>=Top and yy_m[x,y]<=(Top+Thickness):\n",
    "                zz_base[y,x]=zz_new\n",
    "    return zz_base\n",
    "\n",
    "# Viscoelastic\n",
    "def Placement_HorizontalLayer_Visco(zz_Vp,zz_Vs,zz_Rho,zz_Qp,zz_Qs,NX,NY,dh,Top,Thickness,Vp,Vs,Rho,Qp,Qs):\n",
    "    zz_Vp=HorizontalLayer(NX,NY,dh,zz_Vp,Top,Thickness,Vp)\n",
    "    zz_Vs=HorizontalLayer(NX,NY,dh,zz_Vs,Top,Thickness,Vs)\n",
    "    zz_Rho=HorizontalLayer(NX,NY,dh,zz_Rho,Top,Thickness,Rho)\n",
    "    zz_Qp=HorizontalLayer(NX,NY,dh,zz_Qp,Top,Thickness,Qp)\n",
    "    zz_Qs=HorizontalLayer(NX,NY,dh,zz_Qs,Top,Thickness,Qs)\n",
    "    return zz_Vp, zz_Vs, zz_Rho, zz_Qp, zz_Qs\n",
    "\n",
    "# Elastic\n",
    "def Placement_HorizontalLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,dh,Top,Thickness,Vp,Vs,Rho):\n",
    "    xx_grid, yy_grid = np.meshgrid(np.linspace(0,NX-1,NX),np.linspace(0,NY-1,NY))\n",
    "    xx_m=xx_grid*dh\n",
    "    yy_m=yy_grid*dh\n",
    "    for x in range(NY):\n",
    "        for y in range(NX):\n",
    "            if yy_m[x,y]>=Top and yy_m[x,y]<=(Top+Thickness):\n",
    "                zz_Vp[y,x]=Vp\n",
    "                zz_Vs[y,x]=Vs\n",
    "                zz_Rho[y,x]=Rho\n",
    "    return zz_Vp, zz_Vs, zz_Rho\n",
    "\n",
    "# Horizontal layers\n",
    "# Base Layer Generation Function\n",
    "def VerticalLayer(NX,NY,dh,zz_base,From,To,zz_new):\n",
    "    xx_grid, yy_grid = np.meshgrid(np.linspace(0,NX-1,NX),np.linspace(0,NY-1,NY))\n",
    "    xx_m=xx_grid*dh\n",
    "    yy_m=yy_grid*dh\n",
    "    for x in range(NY):\n",
    "        for y in range(NX):\n",
    "            if xx_m[x,y]>=From and xx_m[x,y]<=(To):\n",
    "                zz_base[y,x]=zz_new\n",
    "    return zz_base\n",
    "\n",
    "# Viscoelastic\n",
    "def Placement_VerticallLayer_Visco(zz_Vp,zz_Vs,zz_Rho,zz_Qp,zz_Qs,NX,NY,dh,From,To,Vp,Vs,Rho,Qp,Qs):\n",
    "    zz_Vp=VerticalLayer(NX,NY,dh,zz_Vp,From,To,Vp)\n",
    "    zz_Vs=VerticalLayer(NX,NY,dh,zz_Vs,From,To,Vs)\n",
    "    zz_Rho=VerticalLayer(NX,NY,dh,zz_Rho,From,To,Rho)\n",
    "    zz_Qp=VerticalLayer(NX,NY,dh,zz_Qp,From,To,Qp)\n",
    "    zz_Qs=VerticalLayer(NX,NY,dh,zz_Qs,From,To,Qs)\n",
    "    return zz_Vp, zz_Vs, zz_Rho, zz_Qp, zz_Qs\n",
    "\n",
    "# Elastic\n",
    "def Placement_VerticallLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,dh,From,To,Vp,Vs,Rho):\n",
    "    zz_Vp=VerticalLayer(NX,NY,dh,zz_Vp,From,To,Vp)\n",
    "    zz_Vs=VerticalLayer(NX,NY,dh,zz_Vs,From,To,Vs)\n",
    "    zz_Rho=VerticalLayer(NX,NY,dh,zz_Rho,From,To,Rho)\n",
    "    return zz_Vp, zz_Vs, zz_Rho\n",
    "\n",
    "# Dipping layers\n",
    "# Rotation script\n",
    "# Source:\n",
    "# https://gist.github.com/LyleScott/e36e08bfb23b1f87af68c9051f985302#:~:text=Rotate%20X%2CY%20%282D%29%20coordinates%20around%20a%20point%20or,0%29.%22%22%22.%20%22%22%22Rotate%20a%20point%20around%20a%20given%20point.\n",
    "def rotate_around_point_highperf(xy, radians, origin=(0, 0)):\n",
    "    \"\"\"Rotate a point around a given point.\n",
    "    \n",
    "    I call this the \"high performance\" version since we're caching some\n",
    "    values that are needed >1 time. It's less readable than the previous\n",
    "    function but it's faster.\n",
    "    \"\"\"\n",
    "    x, y = xy\n",
    "    offset_x, offset_y = origin\n",
    "    adjusted_x = (x - offset_x)\n",
    "    adjusted_y = (y - offset_y)\n",
    "    cos_rad = math.cos(radians)\n",
    "    sin_rad = math.sin(radians)\n",
    "    qx = offset_x + cos_rad * adjusted_x + sin_rad * adjusted_y\n",
    "    qy = offset_y + -sin_rad * adjusted_x + cos_rad * adjusted_y\n",
    "\n",
    "    return qx, qy\n",
    "\n",
    "# Base layer generation function\n",
    "def DippingLayer(NX,NY,dh,zz_base,Top,Top_x_reference,Angle_deg,Thickness,zz_new):\n",
    "    xx_grid, yy_grid = np.meshgrid(np.linspace(0,NX-1,NX),np.linspace(0,NY-1,NY))\n",
    "    xx_m=xx_grid*dh\n",
    "    yy_m=yy_grid*dh\n",
    "    for x in range(NY):\n",
    "        for y in range(NX):\n",
    "            xy=(xx_m[x,y],yy_m[x,y])\n",
    "            origin=(Top_x_reference,Top)\n",
    "            radians=Angle_deg*math.pi/180\n",
    "            [xx_m[x,y],yy_m[x,y]]=rotate_around_point_highperf(xy, radians, origin)\n",
    "            if yy_m[x,y]>=Top and yy_m[x,y]<=(Top+Thickness):\n",
    "                zz_base[y,x]=zz_new\n",
    "    return zz_base\n",
    "\n",
    "# Viscoelastic\n",
    "def Placement_DippingLayer_Visco(zz_Vp,zz_Vs,zz_Rho,zz_Qp,zz_Qs,NX,NY,dh,Top,Top_x_reference,Angle_deg,Thickness,Vp,Vs,Rho,Qp,Qs):\n",
    "    zz_Vp=DippingLayer(NX,NY,dh,zz_Vp,Top,Top_x_reference,Angle_deg,Thickness,Vp)\n",
    "    zz_Vs=DippingLayer(NX,NY,dh,zz_Vs,Top,Top_x_reference,Angle_deg,Thickness,Vs)\n",
    "    zz_Rho=DippingLayer(NX,NY,dh,zz_Rho,Top,Top_x_reference,Angle_deg,Thickness,Rho)\n",
    "    zz_Qp=DippingLayer(NX,NY,dh,zz_Qp,Top,Top_x_reference,Angle_deg,Thickness,Qp)\n",
    "    zz_Qs=DippingLayer(NX,NY,dh,zz_Qs,Top,Top_x_reference,Angle_deg,Thickness,Qs)\n",
    "    return zz_Vp, zz_Vs, zz_Rho, zz_Qp, zz_Qs\n",
    "\n",
    "# Elastic\n",
    "def Placement_DippingLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,dh,Top,Top_x_reference,Angle_deg,Thickness,Vp,Vs,Rho):\n",
    "    zz_Vp=DippingLayer(NX,NY,dh,zz_Vp,Top,Top_x_reference,Angle_deg,Thickness,Vp)\n",
    "    zz_Vs=DippingLayer(NX,NY,dh,zz_Vs,Top,Top_x_reference,Angle_deg,Thickness,Vs)\n",
    "    zz_Rho=DippingLayer(NX,NY,dh,zz_Rho,Top,Top_x_reference,Angle_deg,Thickness,Rho)\n",
    "    return zz_Vp, zz_Vs, zz_Rho\n",
    "         "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2263550",
   "metadata": {},
   "source": [
    "#### Functions - Saving/Loading files\n",
    "References used binary-float32 data transformations:\n",
    "https://docs.python.org/3/library/struct.html#examples\n",
    "https://www.stackvidhya.com/python-read-binary-file/\n",
    "https://pythonguides.com/python-read-a-binary-file/\n",
    "https://www.bestprog.net/en/2020/04/30/python-binary-files-examples-of-working-with-binary-files/#:~:text=Python%20has%20tools%20for%20working%20with%20binary%20files.,function%2C%20whose%20mode%20parameter%20contains%20the%20character%20%E2%80%98b%E2%80%99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b5d6e7f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def openfile_frombinarytofloat32array(filename,nx_file,ny_file):\n",
    "    newfile=open(filename,\"rb\")\n",
    "    filecontent=newfile.readline()\n",
    "    datasize=struct.calcsize('f')\n",
    "    contentsize=len(filecontent)/datasize\n",
    "    if nx_file*ny_file==contentsize:\n",
    "        print('File size is correct')\n",
    "        data = np.zeros([nx_file,ny_file])\n",
    "        count=0\n",
    "        for n in range(nx_file):\n",
    "            for m in range(ny_file):\n",
    "                data[n,m] = struct.unpack('f',filecontent[count:count+4])[0]\n",
    "                count=count+4\n",
    "    else:\n",
    "        data=[]\n",
    "        print('File size is NOT correct')\n",
    "        print(nx_file*ny_file)\n",
    "        print(contentsize)\n",
    "    return data\n",
    "\n",
    "def savefile_fromfloat32arraytobinary(filename,nx_file,ny_file,array):\n",
    "    newfile=open(filename,\"wb\")\n",
    "    for n in range(nx_file):\n",
    "        for m in range(ny_file):\n",
    "            output_binary=struct.pack('f',array[n,m])\n",
    "            newfile.write(output_binary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e39246a",
   "metadata": {},
   "source": [
    "#### Functions - Array Placement (Source and Receivers Placement)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "908fe3e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LinearArray(x_start,x_end,y_start,y_end,spacing):\n",
    "    ArrayLength=np.sqrt((x_end-x_start)**2+(y_end-y_start)**2)\n",
    "    if x_end==x_start:\n",
    "        ArrayAngle=np.pi/2\n",
    "    else:\n",
    "        ArrayAngle=math.atan((y_end-y_start)/(x_end-x_start))\n",
    "    ArraySize=int(ArrayLength/spacing)\n",
    "    if ArraySize<=1:\n",
    "        Array=np.zeros([1,2])\n",
    "        Array[0,0]=x_start\n",
    "        Array[0,1]=y_start\n",
    "    else:\n",
    "        Array=np.zeros([ArraySize,2])\n",
    "        for n in range(ArraySize):\n",
    "            Array[n,0]=x_start+n*spacing*np.cos(ArrayAngle)\n",
    "            Array[n,1]=y_start+n*spacing*np.sin(ArrayAngle)\n",
    "    return Array\n",
    "\n",
    "def TRplacement(GridSize,Gridref_x,Gridref_y,Input):               #this function transforms a set of coordinates into an array of coordinates for source/receiver placement\n",
    "    function_grid=np.zeros([len(Input),2])\n",
    "    for n in range(len(Input)):                                     #transform from coordinate to grid points\n",
    "        function_grid[n,0]=int((Input[n,0]-Gridref_x)/GridSize)\n",
    "        function_grid[n,1]=int((Input[n,1]-Gridref_y)/GridSize)\n",
    "    #Clean duplicate values\n",
    "    temp=np.ones(np.shape(function_grid))*np.nan                   #Create a vector the same size as the input, this is the non-duplicate list\n",
    "    temp[0,:]=function_grid[0,:]\n",
    "    count=1\n",
    "    index=0\n",
    "    for n in range(len(function_grid)):                            #Take one by one the transformed values...\n",
    "        flag=0\n",
    "        for m in range(count):                                     #...and compare them against the non-duplicate list\n",
    "            if flag==0:\n",
    "                if function_grid[n,0]==temp[m,0] and function_grid[n,1]==temp[m,1]:\n",
    "                    flag=1\n",
    "        if flag==0:                                                #if an 'n' value wasnt found in the non-duplicate vector list...\n",
    "            count=count+1                                          #...then it is added as a new component\n",
    "            temp[count-1,:]=function_grid[n,:]\n",
    "    function_gridded=temp[0:count,:]                               #we uppdate the size of the output to the total of non-duplicated values\n",
    "    function_gridded_m=function_gridded*0\n",
    "    for n in range(len(function_gridded_m)):\n",
    "        function_gridded_m[n,0]=(function_gridded[n,0]*GridSize+Gridref_x)\n",
    "        function_gridded_m[n,1]=(function_gridded[n,1]*GridSize+Gridref_y)    \n",
    "    return function_gridded_m\n",
    "\n",
    "def TRcornercleaning(function_gridded):                            #this function cleans up corners generated by the TRPlacement function\n",
    "    temp=np.ones(np.shape(function_gridded))*np.nan\n",
    "    temp[0,:]=function_gridded[0,:]\n",
    "    count=1\n",
    "    for n in range(1,len(function_gridded)-1):\n",
    "        if function_gridded[n,0]==function_gridded[n-1,0] and function_gridded[n,1]==function_gridded[n+1,1]:\n",
    "            count=count\n",
    "        else:\n",
    "            count=count+1\n",
    "            temp[count-1,:]=function_gridded[n,:]\n",
    "    temp[count,:]=function_gridded[len(function_gridded)-1,:]\n",
    "    function_gridded_clean=temp[0:count+1,:]\n",
    "    return function_gridded_clean\n",
    "\n",
    "# For reflection\n",
    "def SourceArray_Angle(ref_x,ref_y,radius,angle,length,spacing):\n",
    "    center_x=ref_x+np.cos(np.pi/180*angle)*radius\n",
    "    center_y=ref_y+np.sin(np.pi/180*angle)*radius\n",
    "    x_start=center_x-np.cos(np.pi/180*angle)*length/2\n",
    "    y_start=center_y-np.sin(np.pi/180*angle)*length/2\n",
    "    x_end=center_x+np.cos(np.pi/180*angle)*length/2\n",
    "    y_end=center_y+np.sin(np.pi/180*angle)*length/2\n",
    "    Array_raw=LinearArray(x_start,x_end,y_start,y_end,spacing)\n",
    "    return Array_raw\n",
    "def ReceiverArray_Angle(ref_x,ref_y,radius,angle,length,spacing):\n",
    "    center_x=ref_x-np.cos(np.pi/180*angle)*radius\n",
    "    center_y=ref_y+np.sin(np.pi/180*angle)*radius\n",
    "    x_start=center_x-np.cos(np.pi/180*angle)*length/2\n",
    "    y_start=center_y+np.sin(np.pi/180*angle)*length/2\n",
    "    x_end=center_x+np.cos(np.pi/180*angle)*length/2\n",
    "    y_end=center_y-np.sin(np.pi/180*angle)*length/2\n",
    "    Array_raw=LinearArray(x_start,x_end,y_start,y_end,spacing)\n",
    "    return Array_raw\n",
    "def ReceiverArrayOpposite_Angle(ref_x,ref_y,radius,angle,length,spacing):\n",
    "    center_x=ref_x-np.cos(np.pi/180*angle)*radius\n",
    "    center_y=ref_y-np.sin(np.pi/180*angle)*radius\n",
    "    x_start=center_x-np.cos(np.pi/180*angle)*length/2\n",
    "    y_start=center_y-np.sin(np.pi/180*angle)*length/2\n",
    "    x_end=center_x+np.cos(np.pi/180*angle)*length/2\n",
    "    y_end=center_y+np.sin(np.pi/180*angle)*length/2\n",
    "    Array_raw=LinearArray(x_start,x_end,y_start,y_end,spacing)\n",
    "    return Array_raw\n",
    "\n",
    "# Legacy\n",
    "def SRPlacement(dh_model,x_start,x_end,y_start,y_end):\n",
    "    xgrid_start=int(np.round(x_start/dh_model))\n",
    "    xgrid_end=int(np.round(x_end/dh_model))\n",
    "    ygrid_start=int(np.round(y_start/dh_model))\n",
    "    ygrid_end=int(np.round(y_end/dh_model))\n",
    "    if xgrid_end-xgrid_start==0:\n",
    "        if ygrid_end-ygrid_start==0:\n",
    "            XSRC_grid=xgrid_start\n",
    "            YSRC_grid=ygrid_start\n",
    "        else:\n",
    "            XSRC_grid=np.ones(ygrid_end-ygrid_start)*xgrid_start\n",
    "            YSRC_grid=np.arange(ygrid_start,ygrid_end,1)\n",
    "    else:\n",
    "        if ygrid_end-ygrid_start==0:\n",
    "            YSRC_grid=np.ones(xgrid_end-xgrid_start)*ygrid_start\n",
    "            XSRC_grid=np.arange(xgrid_start,xgrid_end,1)\n",
    "        else:\n",
    "            b=(ygrid_end-ygrid_start)/(xgrid_end-xgrid_start)\n",
    "            a=ygrid_start-b*xgrid_start\n",
    "            if xgrid_end-xgrid_start>ygrid_end-ygrid_start:\n",
    "                YSRC_grid=np.ones(xgrid_end-xgrid_start)\n",
    "                XSRC_grid=np.arange(xgrid_start,xgrid_end,1)\n",
    "                for n in range(len(YSRC_grid)):\n",
    "                    YSRC_grid[n]=int(round(a+b*XSRC_grid[n]))\n",
    "            else:\n",
    "                XSRC_grid=np.ones(ygrid_end-ygrid_start)\n",
    "                YSRC_grid=np.arange(ygrid_start,ygrid_end,1)\n",
    "                for n in range(len(YSRC_grid)):\n",
    "                    XSRC_grid[n]=int(round((YSRC_grid[n]-a)/b))\n",
    "    return XSRC_grid, YSRC_grid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4895b03",
   "metadata": {},
   "source": [
    "#### Functions - Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a5aa419f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting libraries\n",
    "def plotmodels_elastic(xx_grid,yy_grid,zz_Vp,zz_Vs,zz_Rho):\n",
    "    plt.subplot(1,3,1)\n",
    "    im1 = plt.contourf(xx_grid, yy_grid, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('P-wave model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "    cbar.set_label(\"P-wave velocity (m/s)\")\n",
    "\n",
    "    plt.subplot(1,3,2)\n",
    "    im2 = plt.contourf(xx_grid, yy_grid, zz_Vs,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('S-wave model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im2, orientation = 'vertical')\n",
    "    cbar.set_label(\"S-wave velocity (m/s)\")\n",
    "\n",
    "    plt.subplot(1,3,3)\n",
    "    im3 = plt.contourf(xx_grid, yy_grid, zz_Rho,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('Density model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im3, orientation = 'vertical')\n",
    "    cbar.set_label(\"Density (kg/m^3)\")\n",
    "\n",
    "    plt.subplots_adjust(left=0.0, bottom=0.0, right=3.0, top=2, wspace=0.2, hspace=0.2)\n",
    "    \n",
    "def plotmodels_visco(xx_grid,yy_grid,zz_Vp,zz_Vs,zz_Rho,zz_Qp,zz_Qs):\n",
    "    plt.subplot(2,3,1)\n",
    "    im1 = plt.contourf(xx_grid, yy_grid, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('P-wave model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "    cbar.set_label(\"P-wave velocity (m/s)\")\n",
    "\n",
    "    plt.subplot(2,3,2)\n",
    "    im2 = plt.contourf(xx_grid, yy_grid, zz_Vs,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('S-wave model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im2, orientation = 'vertical')\n",
    "    cbar.set_label(\"S-wave velocity (m/s)\")\n",
    "\n",
    "    plt.subplot(2,3,3)\n",
    "    im3 = plt.contourf(xx_grid, yy_grid, zz_Rho,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('Density model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im3, orientation = 'vertical')\n",
    "    cbar.set_label(\"Density (kg/m^3)\")\n",
    "\n",
    "    plt.subplot(2,3,4)\n",
    "    im4 = plt.contourf(xx_grid, yy_grid, zz_Qp,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('P-wave attenuation model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im4, orientation = 'vertical')\n",
    "    cbar.set_label(\"P-wave attenuation\")\n",
    "\n",
    "    plt.subplot(2,3,5)\n",
    "    im5 = plt.contourf(xx_grid, yy_grid, zz_Qs,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.title('S-wave attenuation model')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im5, orientation = 'vertical')\n",
    "    cbar.set_label(\"S-wave attenuation\")\n",
    "\n",
    "    plt.subplots_adjust(left=0.0, bottom=0.0, right=3.0, top=3, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "499673f5",
   "metadata": {},
   "source": [
    "#### Functions - Other Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d3c826e3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def MEM_Allocation_Estimate(NX,NY,TIME,DT,FDORDER,FDORDER_TIME,L,SEISMO,nreceivers,NDT,ABS_TYPE,FW,sizeofMPIFloat):\n",
    "    # Calculating total time steps\n",
    "    TSteps=int(np.round(TIME/DT))\n",
    "    # Model Order\n",
    "    nd=FDORDER/2\n",
    "    fdo3=2*nd\n",
    "    fac1=(NX+fdo3)*(NY+fdo3)\n",
    "    fac2 = np.finfo(np.float32).eps * pow(2.0, -20.0)\n",
    "    # Checking viscoelastic model (and Time Order)\n",
    "    if FDORDER_TIME==2:\n",
    "        memadd=0\n",
    "        memadd_L=0\n",
    "    elif FDORDER_TIME==4:\n",
    "        memadd=24\n",
    "        memadd_L=9\n",
    "    if L>0:\n",
    "        memdyn = ( memadd+ 5.0 + (3.0+memadd_L) * L ) * fac1 * fac2\n",
    "        memmodel = ( 12.0 + 3.0 * L ) * fac1 * fac2 + NX * NY * fac2\n",
    "    else:\n",
    "        memdyn = (memadd+5.0) * fac1 * fac2\n",
    "        memmodel = 6.0 * fac1 * fac2 + NX * NY * fac2\n",
    "    # Memory from Seismograms\n",
    "    ns=int(np.round(TSteps/NDT))\n",
    "    if SEISMO==1:\n",
    "        nseismograms=3\n",
    "    if SEISMO==2:\n",
    "        nseismograms=1\n",
    "    if SEISMO==3:\n",
    "        nseismograms=2\n",
    "    if SEISMO==4:\n",
    "        nseismograms=6\n",
    "    memseismograms = nseismograms * nreceivers * ns * fac2\n",
    "    # Buffer memory\n",
    "    membuffer = 2.0 * fdo3 * ( NY + NX ) * fac2\n",
    "    buffsize = 2.0 * 2.0 * fdo3 * ( NX + NY ) * sizeofMPIFloat\n",
    "    # Memory for CMPL\n",
    "    if ABS_TYPE==1:\n",
    "        memcpml=2.0*FW*4.0* ( NY+NX ) *fac2+20.0*2.0*FW*fac2\n",
    "    else:\n",
    "        memcpml=0\n",
    "    # Total Memory\n",
    "    memtotal = memdyn + memmodel + memseismograms + membuffer +memcpml + ( buffsize * pow ( 2.0, -20.0 ) )\n",
    "    MemoryArray=[memtotal, memdyn, memmodel, memseismograms,membuffer,buffsize,memcpml]\n",
    "    return MemoryArray"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a471831",
   "metadata": {},
   "source": [
    "### 1. Predefining the grid\n",
    "\n",
    "#### 1.1 Grid Stability\n",
    "\n",
    "Optimal grid dimensions definition for a stable grid requires preliminary knowledge of:\n",
    "- Maximum and minimum velocities\n",
    "- Maximum frequency\n",
    "- X-Y Dimensions\n",
    "- Modeling time span\n",
    "\n",
    "We can use specific sets of Finite Difference (FD) model errors to ensure stability in space and time domain.\n",
    "\n",
    "##### 1.1-a Unit and total grid size\n",
    "First, we analize, based on expected frequencies and velocities the expected maximum unit grid size for all available FD model error and orders.\n",
    "Error models are\n",
    "- Taylor\n",
    "- Holberg (0.1%)\n",
    "- Holberg (0.3%)\n",
    "- Holberg (1.0%)\n",
    "- Holberg (3.0%)\n",
    "Error orders have unique values: 2, 4, 6, 8, 10, 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ed06e7f0",
   "metadata": {},
   "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": [
    "# Model Parameters\n",
    "ModelMinVel=1524                    #[m/s] Expected minimum velocity\n",
    "# Model Frequency\n",
    "CenterFrequency=4000                     #[Hz] Expected center frequency\n",
    "MaxFrequency=2*CenterFrequency         #[Hz] Expected max frequency\n",
    "# Model Steps\n",
    "Modelsize=0.001                                      # [m] unit grid size (DH parameter)\n",
    "\n",
    "Model_dict={'Taylor':TaylorCoeffs,'Holberg01':Holberg01Coeffs,'Holberg03':Holberg03Coeffs,'Holberg10':Holberg10Coeffs,'Holberg30':Holberg30Coeffs}\n",
    "Model_list=['Taylor','Holberg01','Holberg03','Holberg10','Holberg30']\n",
    "\n",
    "dhstab=np.zeros((len(Model_list),len(Model_dict['Taylor'].index.values)))\n",
    "for n, modelname in enumerate(Model_list):\n",
    "    model=Model_dict[modelname]\n",
    "    for m, fdorder in enumerate(model.index.values):\n",
    "        unitgridsize=model[model.index==fdorder]['MinGridsperWavelength'].values[0]\n",
    "        dhstab[n,m]=ModelMinVel/(unitgridsize*MaxFrequency)\n",
    "    plt.plot(model.index.values,dhstab[n,:],label=modelname)\n",
    "plt.plot([2,12],[Modelsize,Modelsize],'k',ls='-.',label='Model Size')\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.xlim(2,12)\n",
    "plt.xlabel('FD Order')\n",
    "plt.ylabel('Maximum Unit Grid Size (m)')\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=1, top=1.0, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f7dea69",
   "metadata": {},
   "source": [
    "##### 1.1-a Time step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bcd815f9",
   "metadata": {},
   "outputs": [
    {
     "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": [
    "# Model Parameters:\n",
    "# Model Size:\n",
    "\n",
    "# Model Velocities:\n",
    "ModelMaxVel=3500                    #[m/s] Expected maximum velocity \n",
    "# Model Frequency\n",
    "CenterFrequency=CenterFrequency                     #[Hz] Expected center frequency\n",
    "MaxFrequency=2*CenterFrequency         #[Hz] Expected max frequency\n",
    "# Model Steps\n",
    "Modelsize=Modelsize                                      # [m] unit grid size (DH parameter)\n",
    "Modeltimestep=2.5e-8                                 # [s] unit step size (DT parameter)\n",
    "\n",
    "timeorder=[2,4]\n",
    "temporal=np.array([1,3/2])\n",
    "dtstab=np.zeros((2,len(Model_list),len(Model_dict['Taylor'].index.values)))\n",
    "dtstab_model=np.zeros((2,len(Model_list),len(Model_dict['Taylor'].index.values)))\n",
    "for k in range(2):\n",
    "    plt.subplot(1,2,k+1)\n",
    "    for n, modelname in enumerate(Model_list):\n",
    "        model=Model_dict[modelname]\n",
    "        for m, fdorder in enumerate(model.index.values):\n",
    "            size=dhstab[n,m]\n",
    "            gamma=model[model.index==fdorder]['H1'].values[0]+model[model.index==fdorder]['H2'].values[0]+model[model.index==fdorder]['H3'].values[0]+model[model.index==fdorder]['H4'].values[0]+model[model.index==fdorder]['H5'].values[0]+model[model.index==fdorder]['H6'].values[0]\n",
    "            dtstab[k,n,m]=size/(np.sqrt(2)*gamma*ModelMaxVel*temporal[k])\n",
    "            dtstab_model[k,n,m]=Modelsize/(np.sqrt(2)*gamma*ModelMaxVel*temporal[k])\n",
    "        plt.plot(model.index.values,dtstab[k,n,:])\n",
    "        plt.scatter(model.index.values,dtstab_model[k,n,:],label=modelname)\n",
    "    plt.plot([2,12],[Modeltimestep,Modeltimestep],'k',ls='-.',label='Model Size')\n",
    "    plt.title('Time Order='+str(timeorder[k]))\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.xlabel('FD Order')\n",
    "    plt.ylabel('Minimum Time Step (s)')\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2, top=1.0, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c1b68003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model geometry\n",
      "  Model frequency: 4.00E+03 Hz\n",
      "  Expected velocities are: 1.52E+03 m/s (Min) and 3.50E+03 m/s (Max)\n",
      "  Curren unit grid size is: 1.00E-03 m\n",
      "  Model size is X direction: 3.00E-01 m and in Y direction: 7.00E+00 m\n",
      "  Expected grid number in X direction: 300 and in Y direction: 7000\n",
      "  Minimum required time step is: 2.50000E-08 s\n",
      "  Expected time steps: 220000\n",
      "  Expected output steps: 220000\n",
      "Memory allocation estimation\n",
      "   Dynamic variables:  3.2094E-07  MB\n",
      "   Static variables:  7.6632E-08  MB\n",
      "   Seismograms:  7.5033E-07  MB\n",
      "   Buffer arrays for grid exchange:  1.6371E-09  MB\n",
      "   Network Buffer for MPI_Bsend:  1.0986E-01  MB\n",
      "   CPML variables:  5.5024E-09  MB\n",
      " Total memory required:  1.0986E-01  MB\n"
     ]
    },
    {
     "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": [
    "#Parameters\n",
    "# Model Size:\n",
    "X_length=0.3                                     # [m] grid length along X-direction\n",
    "Y_length=7                                     # [m] grid length along Y-direction\n",
    "T_length=5.5/1000                                        # [s] simulation time (TIME parameter)\n",
    "CenterFrequency=CenterFrequency                     #[Hz] Expected center frequency\n",
    "# Model Steps\n",
    "Modelsize=Modelsize                                      # [m] unit grid size (DH parameter)\n",
    "Modeltimestep=Modeltimestep                                 # [s] unit step size (DT parameter)\n",
    "# Preliminary error parameters\n",
    "FDmodel=1                                         # [-] FD Error model (1: Taylor, 2: Holberg(0.1%), 3: Holberg(0.1%), 4: Holberg(0.1%), 5: Holberg(0.1%) - MAXRELERROR parameter)\n",
    "FD_order=12                                        # [-] FD Error order (2, 4, 6, 8, 10, 12 - FDERROR parameter)\n",
    "FD_ordertime=4                                    # [-] FD Time Error order (2, 4 - FDERROR_TIME parameter)\n",
    "# Boundary Conditions\n",
    "abstype=1                                         # [-] 1 if using a PML (ABS_TYPE parameter)\n",
    "abswidth=10                                       # [-] number of grids used for boundary (FW parameter)\n",
    "# Viscoelastic (Q-approximation)\n",
    "L=0                                               # [-] number of viscoelastic modes (L parameter)\n",
    "# Output data\n",
    "outputtype=1                                      # [-] seismogram output (1:vxx,vyy,vxy; 2:p; 3:div,curl; 4:all - parameter SEISMO)\n",
    "expected_recs=10                                  # [-] expected total receivers               \n",
    "samplestepping=1                                  # [-] interval between time steps to sample data (NDT parameter)\n",
    "# Others\n",
    "sizeofMPIFloat=4                                  # [-] size of MPIfloat in bytes (assumed)\n",
    "\n",
    "PreliminaryMEM = MEM_Allocation_Estimate(int(np.round(X_length/Modelsize)),int(np.round(X_length/Modelsize)),T_length,Modeltimestep,FD_order,FD_ordertime,L,outputtype,expected_recs,samplestepping,abstype,abswidth,sizeofMPIFloat)\n",
    "\n",
    "memtotal=np.zeros((2,len(Model_list),len(Model_dict['Taylor'].index.values)))\n",
    "for k in range(2):\n",
    "    plt.subplot(1,2,k+1)\n",
    "    if k==FD_ordertime/2-1:\n",
    "        plt.scatter(FD_order,PreliminaryMEM[0],c='k')\n",
    "    for n, modelname in enumerate(Model_list):\n",
    "        model=Model_dict[modelname]\n",
    "        for m, fdorder in enumerate(model.index.values):\n",
    "            modelsize=dhstab[n,m]\n",
    "            modeltimestep=dtstab_model[k,n,m]\n",
    "            # Calculating total grid size in x and y direction\n",
    "            TotalX=int(np.round(X_length/modelsize))\n",
    "            TotalY=int(np.round(Y_length/modelsize))\n",
    "            memtotal[k,n,m] = MEM_Allocation_Estimate(TotalX,TotalY,T_length,modeltimestep,fdorder,timeorder[k],L,outputtype,expected_recs,samplestepping,abstype,abswidth,sizeofMPIFloat)[0]\n",
    "        plt.plot(model.index.values,memtotal[k,n,:],label=modelname)\n",
    "#         plt.scatter(model.index.values,dtstab_model[k,n,:],label=modelname)\n",
    "    plt.title('Time Order='+str(timeorder[k]))\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.xlabel('FD Order')\n",
    "    plt.ylabel('Memory Allocation Requirement (MB)')\n",
    "\n",
    "print('Model geometry')\n",
    "print('  Model frequency: '+str('{:.2E}'.format(CenterFrequency))+' Hz')\n",
    "print('  Expected velocities are: '+str('{:.2E}'.format(ModelMinVel))+' m/s (Min) and '+str('{:.2E}'.format(ModelMaxVel))+' m/s (Max)')\n",
    "print('  Curren unit grid size is: '+str('{:.2E}'.format(Modelsize))+' m')\n",
    "print('  Model size is X direction: '+str('{:.2E}'.format(X_length))+' m and in Y direction: '+str('{:.2E}'.format(Y_length))+' m')\n",
    "print('  Expected grid number in X direction: '+str(int(np.round(X_length/Modelsize)))+' and in Y direction: '+str(int(np.round(Y_length/Modelsize))))\n",
    "print('  Minimum required time step is: '+str('{:.5E}'.format(Modeltimestep))+' s')\n",
    "print('  Expected time steps: '+str(int(np.round(T_length/Modeltimestep))))\n",
    "print('  Expected output steps: '+str(int(np.round(T_length/Modeltimestep/samplestepping))))\n",
    "print(\"Memory allocation estimation\")\n",
    "print(\"   Dynamic variables: \", str('{:.4E}'.format(PreliminaryMEM[1])), \" MB\")\n",
    "print(\"   Static variables: \", str('{:.4E}'.format(PreliminaryMEM[2])), \" MB\")\n",
    "print(\"   Seismograms: \", str('{:.4E}'.format(PreliminaryMEM[3])), \" MB\" )\n",
    "print(\"   Buffer arrays for grid exchange: \", str('{:.4E}'.format(PreliminaryMEM[4])), \" MB\" )\n",
    "print(\"   Network Buffer for MPI_Bsend: \", str('{:.4E}'.format(PreliminaryMEM[5] * pow ( 2.0, -20.0 ))),\" MB\" );\n",
    "if ( abstype==1 ):\n",
    "    print(\"   CPML variables: \", str('{:.4E}'.format(PreliminaryMEM[6])),\" MB\" )\n",
    "print(\" Total memory required: \", str('{:.4E}'.format(PreliminaryMEM[0])),\" MB\" )\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2, top=1.0, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a48cd19",
   "metadata": {},
   "source": [
    "### 2. Defining the model\n",
    "Once I generate the grid, I generate a base model using a single layer with the initial parametrical values: P-wave model, S-wave model, Density model, P-wave attenuation model and S-wave attenuation model.\n",
    "- Each layer has a constant value for each parameter\n",
    "- Every subsequent layer replaces the preexisting value of parameter within the layer grid\n",
    "- Layer input is done through grid coordinates range and parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1f5f5f17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preliminary values: DH = 0.001 m, DT = 2.5e-08 s\n",
      "Preliminary dimensions: NX = 300 grid points, NY = 7000 grid points\n",
      "Preliminary time length TIME = 0.0055 s\n"
     ]
    }
   ],
   "source": [
    "# Model allocation during generation\n",
    "print('Preliminary values: DH = '+str(Modelsize)+' m, DT = '+str(Modeltimestep)+' s')\n",
    "print('Preliminary dimensions: NX = '+str(int(np.round(X_length/Modelsize)))+' grid points, NY = '+str(int(np.round(Y_length/Modelsize)))+' grid points')\n",
    "print('Preliminary time length TIME = '+str(T_length)+' s')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b645aa57",
   "metadata": {},
   "source": [
    "##### Notes before choosing NX, NY\n",
    "- Try to use NX and NY with multiple prime factors to improve flexibility on parametrization\n",
    "- Other parameters related to NX, NY values are:\n",
    "    - NPROCX, NPROCY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e53b728a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model dimensions: X = 0.3 m, Y = 7.0 m\n",
      "Model will require a total of 220000 time steps\n"
     ]
    }
   ],
   "source": [
    "# Model parameters\n",
    "DH=0.001                    #[m]\n",
    "DT=2.5e-8                   #[s]\n",
    "NX=300                      #[-]\n",
    "NY=7000                     #[-]\n",
    "TIME=0.0055                 #[s]\n",
    "\n",
    "print('Model dimensions: X = '+str(NX*DH)+' m, Y = '+str(NY*DH)+' m')\n",
    "print('Model will require a total of '+str(int(TIME/DT))+' time steps')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e9a6967a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prime factors for NX: [2, 3, 5]\n",
      "Prime factors for NY: [2, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print('Prime factors for NX: '+ str(sympy.primefactors(NX)))\n",
    "print('Prime factors for NY: '+ str(sympy.primefactors(NY)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e2699052",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total memory required for model generation: 25.2 MB\n"
     ]
    }
   ],
   "source": [
    "# Memory allocation\n",
    "# Is model elastic or viscoelastic?\n",
    "L=0                              # [-] number of modes (= 0: elastic; >0: viscoelastic)\n",
    "if L==0:\n",
    "    ModelMemory=3*NX*NY*4\n",
    "else:\n",
    "    ModelMemory=5*NX*NY*4\n",
    "print('Total memory required for model generation: '+str(ModelMemory/1000000)+' MB')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f3501d45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Base layer\n",
    "#Define parameters:\n",
    "#P-wave velocity (m/s)\n",
    "Vp=3500\n",
    "#S-wave velocity (m/s)\n",
    "Vs=2000\n",
    "#Density (kg/m^3)\n",
    "Rho=2000\n",
    "#Vp-wave attenuation (unitless)\n",
    "Qp=0\n",
    "#Vs-wave attenuation (unitless)\n",
    "Qs=0\n",
    "\n",
    "#Grid generation and population\n",
    "xx_grid, yy_grid = np.meshgrid(np.linspace(0,NX-1,NX),np.linspace(0,NY-1,NY))\n",
    "zz_Vp=np.ones([NX,NY])*Vp\n",
    "zz_Vs=np.ones([NX,NY])*Vs\n",
    "zz_Rho=np.ones([NX,NY])*Rho\n",
    "if L>0:\n",
    "    zz_Qp=np.ones([NX,NY])*Qp\n",
    "    zz_Qs=np.ones([NX,NY])*Qs\n",
    "if L==0:\n",
    "    plotmodels_elastic(xx_grid.T,yy_grid.T,zz_Vp,zz_Vs,zz_Rho)\n",
    "else:\n",
    "    plotmodels_visco(xx_grid.T,yy_grid.T,zz_Vp,zz_Vs,zz_Rho,zz_Qp,zz_Qs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5073dd59",
   "metadata": {},
   "source": [
    "Time to add layers \\\n",
    "For every layer is added, the code below can be edited/copied/pasted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "378176d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Cement\n",
    "# From=0\n",
    "# To=0.13795\n",
    "# Vp=2300\n",
    "# Vs=1000\n",
    "# Rho=2000\n",
    "# Qp=0.01\n",
    "# Qs=0.01\n",
    "# [zz_Vp,zz_Vs,zz_Rho] = Placement_VerticallLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,DH,From,To,Vp,Vs,Rho)\n",
    "\n",
    "# # Casing\n",
    "# From=0\n",
    "# To=0.11795\n",
    "# Vp=5860\n",
    "# Vs=3130\n",
    "# Rho=7800\n",
    "# Qp=0.01\n",
    "# Qs=0.01\n",
    "# [zz_Vp,zz_Vs,zz_Rho] = Placement_VerticallLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,DH,From,To,Vp,Vs,Rho)\n",
    "\n",
    "# Borehole\n",
    "From=0\n",
    "To=0.10795\n",
    "Vp=1524\n",
    "Vs=0\n",
    "Rho=1100\n",
    "Qp=0.01\n",
    "Qs=0.01\n",
    "[zz_Vp,zz_Vs,zz_Rho] = Placement_VerticallLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,DH,From,To,Vp,Vs,Rho)\n",
    "\n",
    "# # Tool\n",
    "# From=0\n",
    "# To=0.046\n",
    "# Vp=1650\n",
    "# Vs=400\n",
    "# Rho=4451.7\n",
    "# Qp=0.2\n",
    "# Qs=1\n",
    "# [zz_Vp,zz_Vs,zz_Rho] = Placement_VerticallLayer_Elastic(zz_Vp,zz_Vs,zz_Rho,NX,NY,DH,From,To,Vp,Vs,Rho)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "91e2bed7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if L==0:\n",
    "    plotmodels_elastic(xx_grid.T,yy_grid.T,zz_Vp,zz_Vs,zz_Rho)\n",
    "else:\n",
    "    plotmodels_visco(xx_grid.T,yy_grid.T,zz_Vp,zz_Vs,zz_Rho,zz_Qp,zz_Qs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "270b7966",
   "metadata": {},
   "source": [
    "### 3. Exporting the models\n",
    "Each model is imported as a different file with extension .vp, .vs, .rho, .qp, and .qs for P-wave velocity, S-wave velocity, Density, P-wave attenuation, and S-wave attenuation, respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a3b27a61",
   "metadata": {},
   "outputs": [],
   "source": [
    "# os.chdir(\"C:/\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e1fd0587",
   "metadata": {},
   "outputs": [],
   "source": [
    "savefile_fromfloat32arraytobinary('test.vp',NX,NY,zz_Vp.astype('float32'))\n",
    "savefile_fromfloat32arraytobinary('test.vs',NX,NY,zz_Vs.astype('float32'))\n",
    "savefile_fromfloat32arraytobinary('test.rho',NX,NY,zz_Rho.astype('float32'))\n",
    "if L>0:\n",
    "    savefile_fromfloat32arraytobinary('test.qp',NX,NY,zz_Qp.astype('float32'))\n",
    "    savefile_fromfloat32arraytobinary('test.qs',NX,NY,zz_Qs.astype('float32'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fce66de",
   "metadata": {},
   "source": [
    "### 4. Designing of JSON parameter file\n",
    "Along this section I interactively set up json file parameters, as described in the SOFI2D guide.\n",
    "\n",
    "#### 4.1 Domain\n",
    "\n",
    "SOFI2D allows for multiprocessor processing by dividing the domain into subgrids.\n",
    "The total number of processors must be specified when starting the program, defining NP:\n",
    "\n",
    "mpirun - np <NP> ../bin/sofi2D < sofi2D.json\n",
    "                                            \n",
    "Parameters are:\n",
    "- NPROCX : number of processors in x-direction\n",
    "- NPROCY : number of processors in y-direction\n",
    "\n",
    "If the total number of processors in sofi2D.json (calculated as NPROCX*NPROCY) and the command line differ the program will terminate with an error message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f2a1c763",
   "metadata": {},
   "outputs": [
    {
     "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": [
    "NPROCX=4\n",
    "NPROCY=5\n",
    "\n",
    "stepx=NX/NPROCX\n",
    "stepy=NY/NPROCY\n",
    "\n",
    "im1 = plt.contourf(xx_grid.T, yy_grid.T, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "plt.title('Domain decomposition')\n",
    "plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "cbar.set_label(\"P-wave velocity (m/s)\")\n",
    "for n in range(NPROCX):\n",
    "    plt.plot([n*stepx,n*stepx],[0,NY-1],'black',linestyle='dashed')\n",
    "for m in range(NPROCY):\n",
    "    plt.plot([0,NX-1],[m*stepy,m*stepy],'black',linestyle='dashed')\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=0.5, top=1.5, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63eaa26a",
   "metadata": {},
   "source": [
    "#### Parameter QC\n",
    "NX/NPROCX and NY/NPROCY should be integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a06acf21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NX/NPROCX: 75.0\n",
      "NY/NPROCY: 1400.0\n",
      "If NX/NPROCX or NY/NPROCY are not integer, these are available prime factors for NX and NY to define NPROX, NPROXY:\n",
      "Prime factors for NX: [2, 3, 5]\n",
      "Prime factors for NY: [2, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print('NX/NPROCX: '+str(stepx))\n",
    "print('NY/NPROCY: '+str(stepy))\n",
    "print('If NX/NPROCX or NY/NPROCY are not integer, these are available prime factors for NX and NY to define NPROX, NPROXY:')\n",
    "print('Prime factors for NX: '+ str(sympy.primefactors(NX)))\n",
    "print('Prime factors for NY: '+ str(sympy.primefactors(NY)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61a8a357",
   "metadata": {},
   "source": [
    "##### JSON File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "34a4d6e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output={\"Domain Decomposition\":\"comment\"}\n",
    "jsonfile_output[\"NPROCX\"]=str(NPROCX)\n",
    "jsonfile_output[\"NPROCY\"]=str(NPROCY)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06f0474a",
   "metadata": {},
   "source": [
    "#### 4.2 Order of the FD Operator\n",
    "In this step I define the order of the FD operator.\n",
    "This section is related to section 1., where I defined the grid based on Taylor and Holberg operators.\n",
    "Parameters are:\n",
    "- FDORDER:Order of ssg FD coefficients (values: 2, 4, ..., 12)\n",
    "- FDORDER_TIME: Order of temporal FD coefficients (values: 2 and 4)\n",
    "- MAXRELERROR: Maximum relative group velocity error E and minimum number of grid points per shortest wavelengths where:\n",
    "      - 0 --> Taylor coefficients\n",
    "      - 1 --> Holberg coefficients\n",
    "      - E=0.5%\n",
    "      - E=1.0%\n",
    "      - E=3.0%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b434903a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preliminary values MAXRELERROR: = 1 (Holberg01)\n",
      "Preliminary FDORDER = 12\n",
      "Preliminary FDORDER_TIME = 4\n"
     ]
    }
   ],
   "source": [
    "# Previous values\n",
    "print('Preliminary values MAXRELERROR: = '+str(FDmodel)+' ('+str(Model_list[FDmodel])+')')\n",
    "print('Preliminary FDORDER = '+str(FD_order))\n",
    "print('Preliminary FDORDER_TIME = '+str(FD_ordertime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f2364b4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "FDORDER=FD_order\n",
    "FDORDER_TIME=FD_ordertime\n",
    "MAXRELERROR=FDmodel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b98f8f",
   "metadata": {},
   "source": [
    "##### JSON File Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5af0dee5",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"FD order\"]=\"comment\"\n",
    "jsonfile_output[\"FDORDER\"]=str(FDORDER)\n",
    "jsonfile_output[\"FDORDER_TIME\"]=str(FDORDER_TIME)\n",
    "jsonfile_output[\"MAXRELERROR\"]=str(MAXRELERROR)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09f46b53",
   "metadata": {},
   "source": [
    "#### 4.3 Discretization\n",
    "This step import parameters from sections 1 and 2 and checks stability.\n",
    "Outputs are the initial parameters we defined first:\n",
    "- NX: number of grid points in the x-direction\n",
    "- NY: number of grid points in the y-direction\n",
    "- DH: distance between grid points\n",
    "\n",
    "I repeat the same stability check than the one performed by the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "22100a1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grid has the following dimensions. X:300,Y:7000 with a grid distance 0.0\n",
      "Minimum grid size required for stability: 0.015875 vs 0.001\n"
     ]
    }
   ],
   "source": [
    "print('Grid has the following dimensions. X:'+str(np.round(NX))+',Y:'+str(np.round(NY))+' with a grid distance '+str(np.round(DH)))\n",
    "vmin=ModelMinVel\n",
    "fc=CenterFrequency\n",
    "N=FD_order\n",
    "dh_min=vmin/(2*fc*N)\n",
    "print('Minimum grid size required for stability: '+str(dh_min)+' vs '+str(DH))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98712290",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "377a0987",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"2-D Grid\"]=\"comment\"\n",
    "jsonfile_output[\"NX\"]=str(NX)\n",
    "jsonfile_output[\"NY\"]=str(NY)\n",
    "jsonfile_output[\"DH\"]=str(DH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08a53783",
   "metadata": {},
   "source": [
    "#### 4.4 Time stepping\n",
    "This step I double check that my time stepping is compliant with the minimum value \\\n",
    "Parameters are:\n",
    "- TIME: Experiment time\n",
    "- DT: Time stepping interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7775c386",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum step size required for stability: 0.00020203050891044212 vs 2.5e-08\n"
     ]
    }
   ],
   "source": [
    "h_value=DH\n",
    "vmax=ModelMaxVel\n",
    "dt_min=DH/(h_value*np.sqrt(2)*vmax)\n",
    "print('Minimum step size required for stability: '+str(dt_min)+' vs '+str(DT))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ade8da",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1946b9a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Time Stepping\"]=\"comment\"\n",
    "jsonfile_output[\"TIME\"]=str(TIME)\n",
    "jsonfile_output[\"DT\"]=str(DT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29beace4",
   "metadata": {},
   "source": [
    "#### 4.5 Source\n",
    "In this section I define the shape, source type and location of sources.\n",
    "Parameters are:\n",
    "- SOURCE_SHAPE: Shape of source signal (Ricker=1, Fumue=2, using SIGNAL_FILE=3, sinus^3=4)\n",
    "- SOURCE_TYPE: Point source (explosive=1, force in x=2, force in y=3)\n",
    "- PLANE_WAVE_DEPTH: Depth of plane wave excitation in meters (if no=0)\n",
    "- PLANE_WAVE_ANGLE: Dip of plane wave from vertical (in deg)\n",
    "- TS: Duration of source signal\n",
    "- SIGNAL_FILE: External signal file name\n",
    "- SRCREC: Read source positions from external SOURCE_FILE (yes=1)\n",
    "- SOURCE_FILE: File with source locations\n",
    "- RUN_MULTIPLE_SHOTS: Multiple shots modeled simultaneously (0) or individually (1)\n",
    "\n",
    "I subdivide this interval into Source Shape and Source Type/Location sections\n",
    "\n",
    "##### Source Shape\n",
    "Along this section I define the source shape. In case I use a plane wave, then SOURCE_SHAPE applies to the experiment, otherwise it is defined for each source in the source file.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0db2dba8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40000\n",
      "2.5e-08 2.5e-08\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Source shapes\n",
    "TS=1/1000                #Duration of source signal (s)\n",
    "FC=CenterFrequency                #Central frequency (Hz)\n",
    "TD=0/1000                #Time delay (s)\n",
    "#Defining the time vector\n",
    "t=np.arange(0,TS,DT)\n",
    "DT=DT\n",
    "# t=np.linspace(0,(2**8-1)*DT,2**8)\n",
    "print(len(t))\n",
    "print(DT,(t[1]-t[0]))\n",
    "#Ricker wavelet\n",
    "tau=np.pi*(t-1.5/FC-TD)/(1/FC)\n",
    "r=(1-2*tau**2)*np.exp(-tau**2)\n",
    "#Fuchs-Muller wavelet\n",
    "fm=np.zeros(len(t))\n",
    "scube=np.zeros(len(t))\n",
    "for n in range(len(t)):\n",
    "    if n*DT>=TD and n*DT<=TD+1/FC:\n",
    "        fm[n]=np.sin(2*np.pi*(n*DT-TD)*FC)-0.5*np.sin(4*np.pi*(n*DT-TD)*FC)\n",
    "    else:\n",
    "        fm[n]=0\n",
    "#Sin^3 wavelet\n",
    "for n in range(len(t)):\n",
    "    if n*DT>=TD and n*DT<=TD+1/FC:\n",
    "        scube[n]=0.00005*np.pi*FC*(np.sin(np.pi*(n*DT-TD)*FC))**3\n",
    "    else:\n",
    "        scube[n]=0\n",
    "\n",
    "f_x=fftshift(fftfreq(len(t),d=DT))\n",
    "fft_r=fftshift(fft(r))\n",
    "f_r_amp=np.abs(fft_r)\n",
    "f_r_phase=np.angle(fft_r)\n",
    "fft_fm=fftshift(fft(fm))\n",
    "f_fm_amp=np.abs(fft_fm)\n",
    "f_fm_phase=np.angle(fft_fm)\n",
    "fft_scube=fftshift(fft(scube))\n",
    "f_scube_amp=np.abs(fft_scube)\n",
    "f_scube_phase=np.angle(fft_scube)\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.plot(t,r,'black',label='Ricker')\n",
    "plt.plot(t,fm,'blue',label='Fuchs-Muller')\n",
    "# plt.plot(t,scube,'red',label='Sin^3')\n",
    "plt.legend(); plt.grid()\n",
    "plt.title('Source Shapes')\n",
    "plt.xlabel('Time (s)'); plt.ylabel('Amplitude (-)')\n",
    "plt.subplot(223)\n",
    "plt.plot(f_x,f_r_amp,'black',label='Ricker')\n",
    "plt.plot(f_x,f_fm_amp,'blue',label='Fuchs-Muller')\n",
    "# plt.plot(f_x,f_scube_amp,'red',label='Sin^3')\n",
    "plt.legend(); plt.grid()\n",
    "plt.title('Source Frequency')\n",
    "plt.xlabel('Time (s)'); plt.ylabel('Amplitude (-)')\n",
    "plt.xlim(0,MaxFrequency)\n",
    "plt.subplot(224)\n",
    "plt.plot(f_x,f_r_phase,'black',label='Ricker')\n",
    "plt.plot(f_x,f_fm_phase,'blue',label='Fuchs-Muller')\n",
    "# plt.plot(f_x,f_scube_phase,'red',label='Sin^3')\n",
    "plt.legend(); plt.grid()\n",
    "plt.title('Source Phase')\n",
    "plt.xlabel('Time (s)'); plt.ylabel('Phase (rad)')\n",
    "plt.xlim(0,MaxFrequency)\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2, top=2, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "315ddd23",
   "metadata": {},
   "outputs": [],
   "source": [
    "SOURCE_SHAPE=1\n",
    "SIGNAL_FILE='signal_mseis.tz'\n",
    "SRCREC=1\n",
    "SOURCE_FILE='./sources/source.dat'\n",
    "RUN_MULTIPLE_SHOTS=0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79e46a06",
   "metadata": {},
   "source": [
    "##### Source Type/Location\n",
    "###### Plane wave\n",
    "\n",
    "Plane waves are generated from a line source defined all along the domain.\n",
    "In case a plane wave is used, the following parameters are required:\n",
    "- PLANE_WAVE_DEPTH: Depth of plane wave excitation in meters (if no=0)\n",
    "- PLANE_WAVE_ANGLE: Dip of plane wave from vertical (in deg)\n",
    "Also, we recommend to set this parameter:\n",
    "- SRCREC: Read source positions from external SOURCE_FILE (no=0)\n",
    "\n",
    "The following code allows to interactively see the location and propagation direction of the plane wave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5fce0802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No Plane Waveform\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "PLANE_WAVE_DEPTH=0                       #in m\n",
    "PLANE_WAVE_ANGLE=89                       #in deg\n",
    "TS=0.2\n",
    "if PLANE_WAVE_DEPTH==0:\n",
    "    print('No Plane Waveform')\n",
    "else:\n",
    "    #The line source is defined as a slope y=a+bx where a=PLANE_WAVE_DEPTH and b=tan(PLANE_WAVE_ANGLE)\n",
    "    x_bottom=(Y_length-PLANE_WAVE_DEPTH)/np.tan(PLANE_WAVE_ANGLE*np.pi/180)\n",
    "\n",
    "    plt.subplot(1,2,1)\n",
    "    im1 = plt.contourf(xx_grid, yy_grid, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.plot([0,int(np.round(x_bottom/dh_model))],[int(np.round(PLANE_WAVE_DEPTH/dh_model)),int(np.round(Y_length/dh_model))],'red',label='Plane wave source')\n",
    "    plt.xlim(0,NX-1) ; plt.ylim(0,NY-1)\n",
    "    plt.legend()\n",
    "    plt.title('Plane wave - Line')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "    cbar.set_label(\"P-wave velocity (m/s)\")\n",
    "\n",
    "    y_source=np.linspace(0,NY-1,NY-1)\n",
    "    x_source=np.linspace(0,NY-1,NY-1)\n",
    "    for n in range(NY-1):\n",
    "        x_source[n]=int(np.round((NY-int(np.round(PLANE_WAVE_DEPTH/dh_model)))/np.tan(PLANE_WAVE_ANGLE*np.pi/180)/dh_model))\n",
    "    plt.subplot(1,2,2)\n",
    "    im1 = plt.contourf(xx_grid, yy_grid, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "    plt.scatter(x_source,y_source, color='black',label='Source Location')\n",
    "    plt.xlim(0,NX-1) ; plt.ylim(0,NY-1)\n",
    "    plt.legend()\n",
    "    plt.title('Plane wave - Grid')\n",
    "    plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "    cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "    cbar.set_label(\"P-wave velocity (m/s)\")\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.0, top=1, wspace=0.2, hspace=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0440c13",
   "metadata": {},
   "source": [
    "##### Point sources\n",
    "In this section I generate a single set of point sources defined from a line vector.\n",
    "This definition requires the generation of an ASCII file (SOURCE_FILE). In the JSON file, the following parameters are required:\n",
    "- PLANE_WAVE_DEPTH: 0 (Recommended)\n",
    "- SRCREC: 1\n",
    "- SOURCE_FILE: './sources/source.dat'\n",
    "\n",
    "SOURCE_FILE parameters are:\n",
    "- XSRC: x-coordinate of a source point (in m)\n",
    "- YSRC: y-coordinate of a source point (in m)\n",
    "- TD: excitation time-delay for the source point (in s)\n",
    "- FC: center frequency of the source signal (in Hz)\n",
    "- AMP: maximum amplitude of the source signal\n",
    "- SOURCE_AZIMUTH (Optional): angle between y- and x- direction (activated if SOURCE_TYPE=4)\n",
    "- SOURCE_TYPE (Optional): source type (explosive=1, force in x=2, force in y=3, SOURCE_AZIMUTH=4). If this value is set, SOURCE_TYPE in here overrides SOURCE_TYPE from the JSON file\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "07ddf0a9",
   "metadata": {},
   "outputs": [
    {
     "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": [
    "#Define coordinates for source\n",
    "SourceFileinput=np.zeros([0,7])\n",
    "#Source set 1\n",
    "x_start=0.046\n",
    "x_end=0.046\n",
    "y_start=0.75\n",
    "y_end=0.75\n",
    "spacing=DH/10\n",
    "TD=0/10000\n",
    "FC=FC\n",
    "AMP=1\n",
    "SOURCE_AZIMUTH=0\n",
    "SOURCE_TYPE=1\n",
    "\n",
    "Array_raw=LinearArray(x_start,x_end,y_start,y_end,spacing)\n",
    "Array=TRplacement(DH,0,0,Array_raw)\n",
    "Source_addon=np.zeros([len(Array),7])\n",
    "for n in range(len(Array)):\n",
    "    Source_addon[n,0]=Array[n,0]\n",
    "    Source_addon[n,1]=Array[n,1]\n",
    "    Source_addon[n,2]=TD\n",
    "    Source_addon[n,3]=FC\n",
    "    Source_addon[n,4]=AMP\n",
    "    Source_addon[n,5]=SOURCE_AZIMUTH\n",
    "    Source_addon[n,6]=SOURCE_TYPE\n",
    "SourceFileinput=np.vstack((SourceFileinput,Source_addon))\n",
    "\n",
    "im1 = plt.contourf(xx_grid.T, yy_grid.T, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "plt.scatter(SourceFileinput[:,0]/DH,SourceFileinput[:,1]/DH, color='black',label='Source Location')\n",
    "plt.xlim(0,NX-1) ; plt.ylim(0,NY-1)\n",
    "plt.legend()\n",
    "plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "cbar.set_label(\"P-wave velocity (m/s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "404bb924",
   "metadata": {},
   "source": [
    "##### Writing SOURCEFILE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e632a32c",
   "metadata": {},
   "outputs": [],
   "source": [
    "Decimals=6\n",
    "file=open('source.dat','w')\n",
    "for n in range(len(SourceFileinput)):\n",
    "    file.write('{} {} {} {} {} {} {}\\n'.format(np.round(SourceFileinput[n,0],decimals=Decimals),np.round(SourceFileinput[n,1],decimals=Decimals),np.round(SourceFileinput[n,2],decimals=Decimals),np.round(SourceFileinput[n,3],decimals=Decimals),np.round(SourceFileinput[n,4],decimals=Decimals),np.round(SourceFileinput[n,5],decimals=Decimals),np.round(SourceFileinput[n,6],decimals=Decimals)))\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d8e699f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.046 0.75 0.0 4000.0 1.0 0.0 1.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file=open('source.dat','r')\n",
    "print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fed3e68d",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c72feeee",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Sources\"]=\"comment\"\n",
    "jsonfile_output[\"SOURCE_SHAPE\"]=str(SOURCE_SHAPE)\n",
    "jsonfile_output[\"SIGNAL_FILE\"]=str(SIGNAL_FILE)\n",
    "jsonfile_output[\"SOURCE_TYPE\"]=str(SOURCE_TYPE)\n",
    "jsonfile_output[\"SRCREC\"]=str(SRCREC)\n",
    "jsonfile_output[\"SOURCE_FILE\"]=str(SOURCE_FILE)\n",
    "jsonfile_output[\"RUN_MULTIPLE_SHOTS\"]=str(RUN_MULTIPLE_SHOTS)\n",
    "jsonfile_output[\"PLANE_WAVE_DEPTH\"]=str(PLANE_WAVE_DEPTH)\n",
    "jsonfile_output[\"PLANE_WAVE_ANGLE\"]=str(PLANE_WAVE_ANGLE)\n",
    "jsonfile_output[\"TS\"]=str(TS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73f5bcf2",
   "metadata": {},
   "source": [
    "#### 4.6 Generation of models\n",
    "In this section I choose the input models. In case I use the models designed before in Section 2, then READMOD=1\n",
    "Parameters are:\n",
    "- READMOD: read model parameter from MFILE (Yes=1)\n",
    "- MFILE: String for model file names\n",
    "- WRITE_MODELS: Switch to decide if models are written to file (No model=0, all models=1, only density=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "51e1775b",
   "metadata": {},
   "outputs": [],
   "source": [
    "READMOD=1\n",
    "MFILE='model/test'\n",
    "WRITE_MODELFILES=0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05ed2151",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ebd471a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Model Generation\"]=\"comment\"\n",
    "jsonfile_output[\"READMOD\"]=str(READMOD)\n",
    "jsonfile_output[\"MFILE\"]=str(MFILE)\n",
    "jsonfile_output[\"WRITE_MODELFILES\"]=str(WRITE_MODELFILES)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0253e3ab",
   "metadata": {},
   "source": [
    "#### 4.7 Q-approximation\n",
    "This section is to choose whether the model behaves as an elastic or viscoelastic model.\n",
    "Parameters are:\n",
    "- L: Number of relaxation mechanisms (elastic=0, >0 viscoelastic)\n",
    "- FLn: Relaxation frequency (one for each relaxation mechanism)\n",
    "- TAU: T-> check Bohlen 2002"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5bdf6e7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "L=0\n",
    "FL1=5\n",
    "TAU=0.00001"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40c129e4",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "19231907",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Q-Approximation\"]=\"comment\"\n",
    "jsonfile_output[\"L\"]=str(L)\n",
    "jsonfile_output[\"FL1\"]=str(FL1)\n",
    "jsonfile_output[\"TAU\"]=str(TAU)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2ecce62",
   "metadata": {},
   "source": [
    "#### 4.8 Boundary conditions\n",
    "In this section I update the set up for boundary conditions. There are two options: CPML-Boundary and Damping-Boundary, each one with its own set of parameters.\n",
    "Parameters are:\n",
    "- FREE-SURF: free surface at the top of the model (Yes=1)\n",
    "- BOUNDARY: apply periodic boundary condition at edges (no=0, left and right=1)\n",
    "- FW: width of absorbing frame (in gridpoints, no=0)\n",
    "- ABS_TYPE: Type of absorbing boundary (CPML-Boundary=1, Damping-Boundary=2)\n",
    "For CPML-Boundary (ABS_TYPE=1) --> recommended width: 10-20 grid points\n",
    "- NPOWER: Check references\n",
    "- K_MAX_CPML: Check references\n",
    "- VPPML: approximately propagation velocity near borders\n",
    "- FPML: aproximately dominant frequency at borders\n",
    "For Damping-Boundary (ABS_TYPE=2) --> recommended width: >20 grid points\n",
    "- DAMPING: percentual factor per grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "41a77f6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "FREE_SURF=0\n",
    "BOUNDARY=0\n",
    "FW=15\n",
    "ABS_TYPE=1\n",
    "NPOWER= 4\n",
    "K_MAX_CPML=1\n",
    "VPPML=3500\n",
    "FPML=4000\n",
    "DAMPING=8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "34ebb266",
   "metadata": {},
   "outputs": [
    {
     "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": [
    "im1 = plt.contourf(xx_grid.T, yy_grid.T, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "plt.scatter(SourceFileinput[:,0]/DH,SourceFileinput[:,1]/DH, color='black',label='Source Location')\n",
    "plt.plot([0,NX-1],[FW,FW],'black',linestyle='dashed')\n",
    "plt.plot([0,NX-1],[NY-FW-1,NY-FW-1],'black',linestyle='dashed')\n",
    "plt.plot([FW,FW],[0,NY-1],'black',linestyle='dashed')\n",
    "plt.plot([NX-FW-1,NX-FW-1],[0,NY-1],'black',linestyle='dashed')\n",
    "plt.xlim(0,NX-1) ; plt.ylim(0,NY-1)\n",
    "plt.legend()\n",
    "plt.title('Boundaries')\n",
    "plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "cbar.set_label(\"P-wave velocity (m/s)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e2cd0085",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QC for NX/NPROCX and NY/NPROCY values. FW should be smaller than these values\n",
      "FW: 15\n",
      "NX/NPROCX: 75.0\n",
      "NY/NPROCY: 1400.0\n"
     ]
    }
   ],
   "source": [
    "print('QC for NX/NPROCX and NY/NPROCY values. FW should be smaller than these values')\n",
    "print('FW: '+str(FW))\n",
    "print('NX/NPROCX: '+str(stepx))\n",
    "print('NY/NPROCY: '+str(stepy))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "794f1ae3",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d59b2ef1",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Boundary Conditions\"]=\"comment\"\n",
    "jsonfile_output[\"FREE_SURF\"]=str(FREE_SURF)\n",
    "jsonfile_output[\"BOUNDARY\"]=str(BOUNDARY)\n",
    "jsonfile_output[\"FW\"]=str(FW)\n",
    "jsonfile_output[\"ABS_TYPE\"]=str(ABS_TYPE)\n",
    "jsonfile_output[\"NPOWER\"]=str(NPOWER)\n",
    "jsonfile_output[\"K_MAX_CPML\"]=str(K_MAX_CPML)\n",
    "jsonfile_output[\"VPPML\"]=str(VPPML)\n",
    "jsonfile_output[\"FPML\"]=str(FPML)\n",
    "jsonfile_output[\"DAMPING\"]=str(DAMPING)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcbe3885",
   "metadata": {},
   "source": [
    "#### 4.9 Wavefield snapshots\n",
    "In this section I set up what snapshots I want.\n",
    "Parameters are:\n",
    "- SNAP: Output type (no seismograms=0, particle-velocities=1, pressure field=2, curl and divergence energy=3, velocities, pressure and energy=4)\n",
    "- TSNAP: first snapshot (in s)\n",
    "- TSNAP: last snapshot (in s)\n",
    "- TSNAPINC: increment (in s)\n",
    "- IDX: increment x-direction (in grid points) -> higher values smaller resolution\n",
    "- IDY: increment y-direction (in grid points) -> higher values smaller resolution\n",
    "- SNAP_FORMA: data format (ASCII=2, BINARY=3)\n",
    "- SNAP_FILE: snap filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "9fd2b7f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "SNAP=4\n",
    "TSNAP1=DT\n",
    "TSNAP2=TIME\n",
    "TSNAPINC=TIME/10\n",
    "IDX=1\n",
    "IDY=1\n",
    "SNAP_FORMAT=3\n",
    "SNAP_FILE='./snap/test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "e51ebbb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QC for IDX and IDY values. NX/NPROCX/IDX and NY/NPROCY/IDY should be integers\n",
      "NX/NPROCX/IDX: 75.0\n",
      "NY/NPROCY/IDY: 1400.0\n",
      "Prime factors for NX: [3, 5]\n",
      "Prime factors for NY: [2, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "print('QC for IDX and IDY values. NX/NPROCX/IDX and NY/NPROCY/IDY should be integers')\n",
    "print('NX/NPROCX/IDX: '+str(stepx/IDX))\n",
    "print('NY/NPROCY/IDY: '+str(stepy/IDY))\n",
    "print('Prime factors for NX: '+ str(sympy.primefactors(stepx)))\n",
    "print('Prime factors for NY: '+ str(sympy.primefactors(stepy)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a498d0",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "153341e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Wavefield Snapshots\"]=\"comment\"\n",
    "jsonfile_output[\"SNAP\"]=str(SNAP)\n",
    "jsonfile_output[\"TSNAP1\"]=str(TSNAP1)\n",
    "jsonfile_output[\"TSNAP2\"]=str(TSNAP2)\n",
    "jsonfile_output[\"TSNAPINC\"]=str(TSNAPINC)\n",
    "jsonfile_output[\"IDX\"]=str(IDX)\n",
    "jsonfile_output[\"IDY\"]=str(IDY)\n",
    "jsonfile_output[\"SNAP_FORMAT\"]=str(SNAP_FORMAT)\n",
    "jsonfile_output[\"SNAP_FILE\"]=str(SNAP_FILE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e98976c9",
   "metadata": {},
   "source": [
    "#### 4.10 Receivers\n",
    "I design the receivers set as an array of receivers. If I want to a 'single receiver', I put a continuous line of receivers placed from a start to an end. If I want multiple receivers, I used the x and y start points for the first receivers and then I add another receiver at a specific distance.\n",
    "Parameters are:\n",
    "- SEISMO: output of seismograms (no seismograms=0, particle-velocities=1, pressure (hydrphone)=2, curl and dive=3, everything= 4)\n",
    "- READREC: Read receiver positions from file (Yes=1). If Yes, then XREC1, YREC1, XREC2, YREC2, and NGEOPH are ignored\n",
    "- REC_FILE: External receiver file name\n",
    "- REFREC: Reference point for receiver coordinate system\n",
    "- XREC1, YREC1: position of first receiver (in m)\n",
    "- XREC2, YREC2: position of last receiver (in m)\n",
    "- NGEOPH: distance between two adjacent receivers (in gridpoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "4af8c1c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABFD0lEQVR4nO2de7zVU/7/n69O6lCSJtEFoWIUItdhTBPCEEYMGZOZ8XWZ4fdtMCimmUYYZjBjLpppvu6XkomZck/EMExKiYSiVEqESCjV+/fHWvu02+199j5n73322fu8n4/HeuzPZ33WWp/3Z5+9Pu+zLu/3W2aG4ziO49SXZqUWwHEcxylvXJE4juM4eeGKxHEcx8kLVySO4zhOXrgicRzHcfLCFYnjOI6TF65InJIiabakvqWWo7EgaQdJn0mqKrUsjpMrrkicGiQtkPRFfJG9J+k2Sa2LeU8z62lmU4p5j1Tic/0ww7URku5qQFkWSDo8cW5mC82stZmtaygZHCdfXJE4qQwws9ZAb2BvYFhpxak7kpqXWgbHaUq4InHSYmbvAY8RFAoAkg6U9B9JKyS9nDwlJamdpFslLZH0saR/Jl07VtLMWO8/kvZMurZA0uGSOsXRULuka3tLWi5ps3j+Y0lzYvuPSdoxqaxJOk/SXGCuAr+X9L6kTyTNktQrn+9E0nFxKm6FpCmSvp50bXtJ90v6QNKHkv4c83eR9GTMWy7pbklt47U7gR2AiXEUeImkrvFZmscynSRNkPSRpHmSzkq65whJ4yTdIWlllG3ffJ7RceqDKxInLZK6AEcD8+J5Z+Ah4EqgHfBzYLykbWKVO4EtgJ5AB+D3sd4+wC3AOcDXgL8BEyS1TL6fmS0BngcGJmWfBvzDzL6SdAJwGXAisA3wb2BMitgnAAcAuwP9gUOBHkBb4BTgw3ivH5rZbXX8PnrE+/0s3v9hggJoEdczHgTeAboCnYGxiarAb4BOwNeB7YERUY4fAAuJo0Az+22aW48BFsf6JwFXSzos6fpx8V5tgQnAn+vyXI5TEMzMkyfMDGAB8BmwEjBgMtA2XrsUuDOl/GPAGUBHYD2wdZo2RwEjU/LeAL6VdM/D4/H/AE/GYwGLgEPj+SPAmUltNAM+B3aM5wb0S7reD3gTOBBoVofvYARwV5r84cC4lPu/C/QFDgI+AJrn0P4JwIyU7/zwpPOu8VmaE5TOOmDLpOu/AW5LkvWJpGu7A1+U+nfkqeklH5E4qZxgZlsSXpC7Ae1j/o7AyXFaZ4WkFcAhBCWyPfCRmX2cpr0dgYtS6m1P+A87lX8AB0nqRBhNGGHkkWjnxqQ2PiIom85J9RclDszsScJ/538BlkkaLalNnb6JjelEGHEk2l8f79c5Ps87ZrY2tZKkDpLGSnpX0qfAXWz4TnO550dmtjIp7x02fub3ko4/B6p9jchpaFyROGkxs6eB24DrYtYiwoikbVJqZWbXxGvtEnP/KSwCrkqpt4WZpU5LYWYrgMeB7xGmtcaYmSW1c05KO5ub2X+Sm0hp749m1ocw3dYDuLheX0ZgCUGZASBJBAXybpRthwwv8N9EufY0szbA6QQFmFbmNPdsJ2nLpLwd4j0dp9HgisSpjT8AR0jqTfhPeoCkIyVVSaqW1FdSFzNbSph6uknS1pI2k3RobOPvwLmSDogL4K0kHZPyckzmHmAwYa3knqT8vwLDJPUEkLSVpJMzCS5pv3jPzYBVwJeEaaJcaBafL5FaAuOAYyQdFtu8CFgN/AeYCiwFronPVy3p4NjWloTpwhVxnSlVmS0Ddk4nhJktiu3/Jra5J3AmcHeOz+E4DYIrEicjZvYBcAcwPL7UjicseH9A+C/8Yjb8hn4AfAW8DrxPWJTGzKYBZxGmmT4mLN7/sJbbTgC6A8vM7OUkWR4ArgXGximiVwmbATLRhqDEPiZMB33IhtFVNgYBXySlt8zsDcJo4k/AcmAAYZF8jQWbjwFAN8Li+WLC4j7Ar4F9gE8ImxXuT7nXb4BfxCm7n2eQpSthdPIA8Cszm5TjczhOg6ANMweO4ziOU3d8ROI4juPkhSsSx3EcJy9ckTiO4zh54YrEcRzHyYuKNVySqmzTx6sGWhG27n+Ucu0rgl7tQDDSTmdb1yq2sQ5YkeZ6a6AlsJawSSfT9a+AT9Nc3xJoAawhGJen0gbYjLDr9LM017ciPHOm622BKsJO2FVprm/NBoPxL9Jcb0cwgUjspk3la+EpunzG6sUby69YmyjZ6pSazeLdITz5mpTrVVF6CN/cVynXmxOeHsI3n2oZuBnh24Pwl0vdB9yC8O1D+MuvT7nekvDXg/DLSd2iknz9Qzaltl8ewOYE/zL+y6v/L+9DwveT6n8/l9/el7DczLahnnST7PMcyy6Fx8zsqPreqzFSsYokPFrHlLyewP6E7pK6Ff89Qnc7h/BzHZemzf2AXoSumrqLE+AbwK6E3aET01w/FNiFYHLwaJrrhxHszRYSvJOkchThmd4CnklzfQDBaPoNgvlBKicSuvyrwItprn+P8MqaAcxMc/37hNfNVGB2mus/AuCAIc8w9+InN7qyGWHvLMDTwNspNbdgw37ZJ0gyUY+0YYMTrkfY2JwbwovkuHg8gU1f5tuxYa/weDZ9mW4PJHy530t4oSWzM/CteHwXmyqyHkDCcORWNqW2Xx5scLXsv7z6//JuJfxdU90X5PLbm5PktaA+fE54c+TCiNw9G5QNFbv9V+pkuf9pYUP3/1ExxGlSDLc1VOnqUovhNDHy6cEjYLqZ1dtzcmfJfppj2V/kea/GSAWPSOrKodmLOI7TaCllD25GmJ5sqrgiqWGXUgvgOE4elLIHizCF1lRxRVLD0viZuq7iOE45UMoeLJr2y9S3/9bwKOmXIR3HKQdK2YMTI5JcUiXSlJWo4zhOQfA1EsdxHCcvmvrUVlN+dsdxnILgi+2O4zhOXrgicSKHlVoAx3HyoNQ9uCm/TJvys6ewQ6kFcBwnD0rZg31E4kQWxk9XKI5TjpSyBzf1xXa3I6lhMund1TmOUw6Usge7HYnjOI6TF25H4jiO4+SFT205juM4eVHIqS1J1ZKmSnpZ0mxJv475IyXNkjRT0uOSOsX8IyRNl/RK/OyXps0Jkl4tyMOmwRWJ4zhOniRGJLmkHFgN9DOzvQgxz46SdCDwOzPb08x6Aw8Cv4zllwMDzGwP4Azgzo1kk04kfeDKgtGUR2MpVFTkS8dpcpSyBzcjRFosBBaiDSZe/ImBjJlZcmDPRORmzGxGUv5soFpSSzNbLak1cCFwNumDbxYEVyQ1uPt4xylnSt2D6/AybS9pWtL5aDMbnVxAUhUwHegG/MXM/hvzrwIGE6IufztN2wOBGWaWCE0/ErieTaNHFxSf2qrhrZgcxylHStmDBWzWPLcELDezfZPS6NT2zGxdnMLqAuwvqVfMv9zMtgfuBs7fSAapJ3AtMca4pN5ANzN7oGgPHnFFUsMzMTmOU46UsgdL0Lx5bqkumNkKYAqbztzdQxh9xPurC/AAMNjMEvr0IKCPpAXAs0APSVPq/nTZcUXiOI6TJxJsVpVbyt6WtpHUNh5vDhwOvC6pe1Kx44DXY5m2wEPAMDN7LlHAzEaZWScz6wocArxpZn0L8byp+BqJ4zhOniRGJAWiI3B7XCdpBowzswcljZe0K7AeeAc4N5Y/n7CWMlzS8JjX38zeL5hEWXBF4jiOkyeJNZJCYGazgL3T5A9MUxwzuxK4MkubC4BehZAvHa5IHMdx8qUZ0LLUQpQOVyQ1DCi1AI7j5EFJe3AT95FS1MV2SW0l/UPS65LmSDpIUjtJkyTNjZ9bJ5UfJmmepDckHZmU3yea/8+T9EdJKry07WNyHKccKXkPLqBpe7lR7F1bNwKPmtluwF7AHGAoMNnMuhO8Pg8FkLQ7cCrQk7DV7aa42AQwimCZ2T2mIhixvhGT4zjlSEl7sICqHFMFUjRFIqkNcChwM4CZrYl7oo8Hbo/FbgdOiMfHA2PNbLWZzQfmEQxxOgJtzOz56DrgjqQ6BeQ/MTmOU46UtAcX2NlWuVHMx9oZ+AC4VdJeBHP/IcC2ZrYUwMyWSuoQy3cGXkiqvzjmfRWPU/M3QdLZhJELsFWhnsNxHKd2RJNebC/m1FZzYB9glJntDawiTmNlIN26h9WSv2mm2eiE24HCuVBzHMfJQhMfkRRTkSwGFiecjQH/ICiWZXG6ivj5flL57ZPqdwGWxPwuafIdx3EaB65IioOZvQcsipaYAIcBrwETCD7ziZ//iscTgFMltZS0E2FRfWqcBlsp6cC4W2twUh3HcZzGQRNebC+2fvx/wN2SWgBvAz8imvxLOhNYCJwMYGazJY0jKJu1wHlmti628xPgNkJY5EdiKjAnFr5Jx3EajJL24CZuR1LURzezmcC+aS4dlqH8VcBVafKnUUTz/kDDLc4PGtSLq68+jB122IqFCz/hsssmM2ZM0aJgOk6ToKTba1yROIHEi7y4+mrQoF78/e8DaNWqBQBdu7bl738PNrmuTByn/jRMD86A79pyAi/GVFyuvvqwGiWSoFWrFlx9ddpBmuM4OdIwPTgDvtjuNCQ77JB+AJ4p33GcMqCAikRStaSpkl6WNFvSr2P+yfF8vaR9k8ofIWl6dCM1XVK/NG1OkFS0KY8K1Y+Nl4ULP6Fr17Zp8x3HKVMSLlIKw2qgn5l9Jmkz4FlJjxBm704E/pZSfjkwwMyWxJC8j5FktC3pROCzgkmXBh+RNDCXXTaZVavWbJS3atUaLrtscokkchwnbwo4IrFA4sW/WUxmZnPMbBN3YmY2w8wStnWzgWpJLQEktQYuJEu8knxxRdLAjBnzKmedNZEFC1awfr2xYMEKzjproi+0O065k7siaS9pWlI6O7UpSVWSZhIMticlGXZnYyAww8xWx/ORwPXA5/V9rFzwqa0avldqARzHyYOS9uC6BbZaHtw4ZSba0PWO8dgfkNTLzGr9b1NST+BaoH887w10M7MLJHXNWbp64IqkhlYNchff/us4xaFhenAGimRHYmYrJE0hhM7I+IKQ1AV4ABhsZm/F7IOAPpIWROk6SJpiZn0LLadPbdUwI6bi4tt/Hac4NEwProXC7draJo5EkLQ5cDjwei3l2wIPAcPM7LlEvpmNMrNOZtYVOAR4sxhKBFyRJDEzpuLi238dpzjMpCF6cAYKG9iqI/CUpFkE05hJZvagpO9KWkwYaTwk6bFY/nygGzBc0syYOqRvujj41FYD49t/HacCKeDUlpnNAvZOk/8AYfoqNf9KsuzKMrMFFNHo30ckDYxv/3WcCiThIiWXVIG4ImlgfPuv41QgTdxFSoU+VuNmzJhXXXE4TiXRxL3/+oikhu/HVHwGDerF/PlDWLful8yfP4RBg0rir9RxKoqG68Fp8BGJE2iRvUgBcDsSxykODdODa6FCox/mgo9IapgaU3FxOxLHKQ4N04Mz4CMSJzA7fu5f1Lu4HYnjFIeG6cEZ8DUSpyHJZC/idiSOU8b49l+nIXE7EsepQJr41JYrkgbG7UgcpwIprIuUkiKplaQ6SVqh+rFx43YkjlNhlPEaiaRmwKmE3dP7ESI0tpT0AfAwMNrM5tbWRlFHJJIWxDjCMyVNi3ntJE2SNDd+bp1UfpikeZLekHRkUn6f2M48SX+UpMJL+6OYio/bkThO4Wm4HpwGAdU5psbHU8AuwDBgOzPb3sw6AN8EXgCukXR6bQ00hA79tpktTzofCkw2s2skDY3nl0ranaAVewKdgCck9YgBXkYBZxMe6mGCb/5HGkD2guN2JI5TgRQ2ZntDc7iZfZWaaWYfAeOB8TF2fEZKsUZyPHB7PL4dOCEpf6yZrTaz+cA8YH9JHYE2Zva8mRlwR1KdAvJcTMXF7Ugcpzg0TA/OQAEX2yVtL+kpSXMkzZY0JObvJen5ODszUVKbmH+EpOkxf7qkfmnanCAp7X+qCSUiaZekWO99Jf1vIi5KOkWTTLEViQGPx4dLxCXe1syWRuGWAgm/+Z2BRUl1F8e8zvE4NX8TJJ2diINc9xDFb8ZUXNyOxHGKQ8P04Foo3K6ttcBFZvZ14EDgvDhj83/AUDPbg+BO/uJYfjkwIOafAdyZ3JikE4HPcrjveGCdpG7AzcBOwD25CFxsRXKwme0DHE34Mg6tpWy6dQ+rJX/TTLPRZrZviIe8Rd2lbQDcjsRxKpAC7toys6Vm9lI8XgnMIfzzvCvwTCw2CRgYy8wwsyUxfzZQnTSyaA1cSJZ4JZH1ZrYW+C7wBzO7gBBkKytFVSSJhzOz9wkadH9gWZyuIn6+H4svBrZPqt4FWBLzu6TJL0vcjsRxKpC6TW21T8ycxHR22jYBSV0JQa7+S4jZfly8dDIbvy8TDARmmNnqeD4SuJ7cpmi+kjSIMKp5MObVujaSoGiKJO5F3jJxDPQnfBETCIISP/8VjycAp0pqKWknoDswNU5/rZR0YNytNTipTtnhdiSOU4HUTZEsT8ycxDQ6bZNhNDEe+JmZfQr8mDCzMx3YEliTUr4ncC1wTjzvDXSLkRVz4UeEML5Xmdn8+B6+K5eKxdy1tS3wQNyp2xy4x8welfQiME7SmcBCgmbFzGZLGge8RpgjPC/u2AL4CXAbsDlht1YRdmzlpHgLgtuROE7habgenIaEi5RCNRd2SY0H7jaz+wHM7HXCP+RI6gEck1S+C2HWZ7CZvRWzDwL6SFpAeAd3kDTFzPqm3Gs04Z36hJn9byI/bnq6Jhd5i6ZIzOxtYK80+R8CabcomdlVwFVp8qdRxHjDgVq3SReUQYN6cfXVh7HDDluxcOEnXHbZZFcsjpMnDdeD01BAg8Q483IzMMfMbkjK72Bm70cDwl8Af435bYGHgGFmVrNxzcxGEUwnElNkD6YqkcgtBJOKCyWtAR4HHjWzl3OVuUxtMcsXtyNxnAqksJbtBwM/AF6RNDPmXQZ0l3RePL8fuDUenw90A4ZLGh7z+se16ayY2QsEG70Rkr5GGPVcJGlP4CWCUhlXWxuuSGp4On5+q6h3qc2OxBWJ49SfhunBtVAgg0Qze5b0u1UBbkxT/kqy7MoyswXkMKsTZ4zGxISkPoTRSq24Iqnh7fhZ3J+h25E4TnFomB6cgWY0VvcnOROnyAYDXUnSDcnrJplwRdLALFz4CV27tk2b7zhOGVO+LlISPEyY4noFWF+XirUqEknVwLEE512dgC8IW3gfMrPZtdV10nPZZZM3WiMBtyNxnLKnjL3/JlFtZhfWp2LGR5c0gmD8MoVgDPM+YfDWg+ANsppgxj+rPjduqiTWQXzXluNUEJWhSO6UdBbBGDFh0Jhw3lgrtT36i2Y2IsO1GyR1AHaoi5SNm8bpUsVxnNwoaQ+uDEWyBvgdcDkb3FAZsHO2ihkf3cweilGyrjGzi9Ncf58N7k0qgFMa5C6+/ddxikPD9ODMWPmvkVxIsIRfnrVkCrW6SImW5X2KE0iqaeJu5B2n8jDBuua5pUbMbOruNh3IbTA2A/iXpPuAVYnMhNl+5fBE/Dy8qHfx7b+OUxwapgenx5rB6pa5ui6s04aohmQdMFPSU2y8RlKQ7b/tgA+B5GApRrCsrCAWZS9SAHz7r+MUh4bpwekxiXXNcx1urMlepDT8M6Y6k/XJzaxkYZArEd/+6ziVybqq8l4kMbPbs5dKT9axmKQekiYnwjRK2lPSL+p7w6aOu5F3nMrDEOuoyik1NmLY3gHp4rJL2lnSFZJ+XFsbuYzF/k4I6fg3ADObJekecou45aTB3cg7TmVhiNU5+5HPJeptg3IWYcfWHyR9BHxAsBncCZgH/NnMao0BlYsi2cLMpqZs3FpbP3kbM20a7E7uRt5xCk/D9eBNSYxIyhEzew+4BLgkupvvSPBi8qaZ5bSLKxdFslzSLkQDFUknAUvrJXGjZmCD3MXtSBynODRMD05PIRWJpO2BO4DtCFu8RpvZjZLuJcRtB2gLrDCz3pKOIASgakFYyb/YzJ5MaXMCsLOZ1eoBOHoJXlBXmXNRJOcBo4HdJL0LzAe+X9cbOQF3I+84lUkBRyRrCe6nXorhyqdLmmRmNTaXkq4HEls9lwMDzGyJpF7AY0DnpLInUuT5tFx2bb0NHB7jrjczs5XFFKh0JKL3Hl3Uu7gdieMUh4bpwekxxNoCKRIzW0qc9TGzlZLmEBTDa1ATQfF7RJMMM5uRVH02UC2ppZmtjnHfLwTOBmoNTpUPueza+pqkPwL/BqZIujFG0aow3oupuGSyF3E7EsfJj4bpwekJU1vNc0pAe0nTktLZmdqNaxZ7ExznJvgmsMzM5qapMhCYYWYJg8KRwPXkYLEu6dgYxrfO5FJpLGEVfyBwUjy+tz43c4IdyapVGxskuR2J45Q/ddj+u9zM9k1Ko9O1F0cT44GfmdmnSZcGESMYppTvCVwLnBPPexN8Zz2Q4yOcCsyV9FtJX8/1uSFHy3YzG5l0fqWkE+pyE2cD7kbecSqP9YjVtMheMEeiTcd44O5kd1SSmgMnAn1SyncBHgAGm9lbMfsggq/EBYR3fQdJU8ysb7p7mtnpktoQFNWtkowQF35MtiWNXBTJU5JOZcP82knAQznUczLgdiSOU2koMW2Vf0thDeRmYI6Z3ZBy+XDgdTNbnFS+LeGdPMzMnkvkm9koYFQs0xV4MJMSSarzqaTxwObAz4DvAhdL+qOZ/SlTvYxTW5JWSvqUMEy6h7CtbA1hquuC2oRJaadK0gxJD8bzdpImSZobP7dOKjtM0jxJb0g6Mim/j6RX4rU/Fscb8ddiKj6DBvVi/vwhrFv3S+bPH8KgQbXuyHMcJwcargdvSoEt2w8GfgD0kzQzpu/Ea6ey6bTW+UA3YHhS+Q51fQZJx0l6AHgS2AzY38yOBvYCfl5b3drikWxZV0EyMASYwwZ7oaHAZDO7RtLQeH6ppN0JX1JPQljfJyT1iK7sRxF2HbxAiCt8FBs2aRSI4wrbXAbcjsRxikPD9ODMFGr7r5k9SwiVle7aD9PkXUkWTyPRPiTbf6wnAb83s2dS6n6ezUVKTiv00b/WcZJOTKQc63UBjgH+Lyn7eCDhHOx24ISk/LFmttrM5hNM8/eX1BFoY2bPm5kRDHVOoEzxeCSOU3mspxmraZFTasQsTVUikq4FMLNadwNlndSTdAuwJ2F/csKRfq5u5P9AML1PHt1sG/dJY2ZLk4ZgnQkjjgSLY95X8Tg1v8BMiJ/F/b/G7Ugcpzg0TA/OTKHWSErIEcClKXlHp8nbhFye/EAz272uEkk6FnjfzKZL6ptLlTR5Vkt+unueTZgCA+r6Yv6wjuXrh8cjcZzi0DA9OD3l7GtL0k+AnwK7SJqVdGlL4Ln0tTYml6mt5+P6RV05GDgubj0bS1g4ugtYFqeriJ+JuO+Lge2T6ncBlsT8LmnyN8HMRif2ZsMW9RC5+LgdieNUHuXsRp6wmWoA8K/4mUh9zOz0XBrIRZHcTlAmb0iaFXdPzcpWycyGmVkXM+tKWER/Mgo1ATgjFjsjCk/MP1VSS0k7Ad2BqXEabKWkA+NurcFJdcoOj0fiOJXJWqpySo0Qi4vx5wErkxKS2uXSQC5TW7cQtqK9QmGCDV8DjJN0JrAQOBnAzGZLGkfwJ7MWOC/u2AL4CXAbYW/zIxR8x1bD4nYkjlNZWAHtSErAPcCxwHQ2XU4wYOdsDeTy5AvNbEL2YpkxsynAlHj8IZB2i5KZXQVclSZ/Gtm3ruXJdsVt3nGcolLKHlzOayRmdmz83Km+beSiSF6PEREnAglHYCSb7VcGpfAZ6jhOoShlD7YCu0gpBZK+S1iC+CSetwX6mtk/s9XNRZFsTlAg/ZPyct3+6ziOU/GU+dRWgl8lO3g0sxWSfgX8M1vFXOKR/Cg/2cqF8fGzlHHWHMepL6XuweU6tZVEus1XOWnHXAwSbyWN3YaZ1WoyX358mr2I4ziNllL24HJeI0limqQbgL8Q3vn/j7AAn5VctM2DScfVBG+Qae04HMdxmiKVsEZCUBzDCfGmBDxO2BKclVymtsYnn0saAzxRdxkdx3Eqk0pYIzGzVcDQGJNkvZnlHOe9PmEVuwM71KOe4zhORVJIy3ZJ20t6StIcSbMlDYn5IyS9m+paXtIRkqZHY/HpkvqlaXOCpFqN1yTtIWkGwWZwdmwrJ7OLXNZIVrLBSMUIYZGzOvEqP7bPXsRxnEZLqXtwAddI1gIXmdlLkrYEpkuaFK/93syuSym/HBhgZkvii/8xkhzbRm/tuYwu/gZcaGZPxXp9gdHAN7JVzGVqq1BxSRo5h5daAMdx8qCUPdhQwdyfRLdQCQ/pKyXNoRaP52Y2I+l0NlAtqaWZrY5x3y8kOLMdl7aBDbRKKJHY7hRJrXKROadJPUmdgR2Ty6f6rXccx2mq1HGNpL2kaUnno81sdLqCMUTu3sB/CY5wz5c0GJhGGLV8nFJlIDDDzBLG4yOB64HPc5DrbUnDgTvj+enA/Bzq5TS1dS1wCsEHVsL3lQEVpkjujZ+nlFQKx3HqR6l7cB2mtpYHD+W1E0cT44GfxVjqowiKwdigIH6cVL4ncC3ReFxSb6CbmV0QFVI2fgz8mmBsLsI7Pic7wlxU6AnArkkarkLJRWE7jtNYKWUPNsSaAm7/lbQZQYncnXBHZWbLkq7/nSTTjBiN9gFgsJm9FbMPAvrEUB7NgQ6SpphZ37TPEEY3/1sfeXNRJG8TAsFXuCJxHMepH4VcI4nhMm4G5pjZDUn5HRPRZQn2fK/G/LbAQ8AwM6sJRGVmo4BRsUxX4MF0SkTSRDIEC4ztZA06mYsi+RyYKWkyGzttrJfmchzHqTQKbEdyMDF0h6SZMe8yYFCcrjJgAXBOvHY+0A0YHtc4APqbWSJoYDZSd4HVmVyefAIbwiE7juM4aSjU9l8ze5b0IcYfzlD+SuDKLG0uIEMoDjN7OnEsaXNgBzN7I1d5Ibftv7fXpcHyJWvsFsdxGjGl7MGV4GtL0gDC6KQFsFMc/VxRqKmtJsK3Si2A4zh5UMoeXMg1khIyAtifDUEIZ+a428sVieM4Tr6EXVstSy1Gvqw1s0/CWn/dcEVSw13x8/SSSuE4Tv0oZQ+uhKkt4FVJpwFVkroTtgL/J5eKGRVJIbaElRdflVoAx3HyoNQ9uAIUyf8DLifszr2H4LOr1kX8BLWNSBJbwk4EtmODwh9E2HrmOI7jUDFrJLua2eUEZVInMiqSxJYwSSPN7NCkSxMlVZh7FMdxnPpTCfFIgBskdQTuA8aa2excK+YSj2QbSTU76yTtBGyTrZKkaklTJb0cfer/Oua3kzRJ0tz4uXVSnWGS5kl6Q9KRSfl9oq/9eZL+qPqsBjmO4xSJhIuUXFJjxcy+DfQFPgBGx3fuL3Kpm4siuQCYImmKpCnAU8DPcqi3GuhnZnsBvYGjJB0IDAUmm1l3YHI8R9LuwKlAT+Ao4CZJibHiKIIb5O4xHZXLw9WNHjE5jlOOlLIHJ6a2ckmNGTN7z8z+CJwLzAR+mUu9XAwSH40r+LvFrNdzceBoZsaGYCqbxWTA8QStB3A7Yc/ypTF/bGx7vqR5wP7R4VgbM3seQNIdBEeSj2R/vLpwcGGbcxynQSl1Dy73qS1JXyc4Tz4J+BAYC1yUS93adm31M7MnY3StZHaRRMIjZRbBqoDpBD8wfzGz/0raNuF4zMyWSuoQi3cGXkiqvjjmfRWPU/Mdx3EaBRWy/fdWYAzBT9eSulSsTYV+C3gSGJDmmhF81teKma0DekfvlA9kif+bbt3DasnftAHpbMIUGLBVNvFSuDV+5uR+33GcRkYpe3AlKBIzO7C+dWvbtfUrSc2AR8wsW4jGWjGzFXF95ShgWcIdctwhkPBQuZiNwy53AZbE/C5p8tPdZzQhxjBSp4w2MI7jOIWmsa9/FJNaF9vNbD3BRXGdkbRNHIkkPEoeDrxO8CR8Rix2BvCveDwBOFVSy7gzrDswNU6DrZR0YNytNTipjuM4TslJbP/NJWVD0vaSnpI0J+54HRLzR0qaJWmmpMcldYr5R0iaHndZTZfUL02bEyS9WvAHj+SyOjRJ0s8JkSxXJTLN7KMs9ToCt8d1kmbAODN7UNLzwDhJZwILgZNje7MljSOE9F0LnBenxgB+AtwGbE5YZC/wQrvjOE79KXCExLWEeOwvSdoSmC5pEvA7MxsOIOl/CTuqzgWWAwPMbElcPniMpHXkuM79WepNMiGplZmtyl5yA7kokkRM4POS8owsXpvNbBYhaH1q/ofAYRnqXAVclSZ/Ghl86TuO45SaQq6RxFmYxIaklZLmAJ3N7LWkYq2Ia8VmNiMpfzZQLamlma2Ocd8vJKwd17pEIekbwP8BrYEdJO0FnGNmP80mcy7bf3fKVqYy6FlqARzHyYNS9mCjTmsk7SVNSzofHdd3NyG6cd8b+G88v4owvf8J8O00VQYCM5JMNEYC15NbSPvfA0cSAxma2cuSDq29SiCrIkmz/RfCQ7xSh1COZcD+pRbAcZw8KG0PrpOLlOVmtm/WFsNoYjzwMzP7FCDhC0vSMML69a+SyvcErgX6x/PeQDczuyDXuCJmtijFcci6TGWTyeXJzwQOIli0QzAmfAHoIekKM7szlxs1ftbEz8brwsBxnMyUsgcXeI0ESZsRlMjdGWz27gEeIioSSV2AB4DBZvZWLHMQ0CcadTcHOkiaYmZ9M9x2UZzeMkktCG7k5+Qiby4uUtYDXzezgWY2ENid4P7kAIJFeoVwd0yO45QjpezBhXSREnen3gzMMbMbkvK7JxU7jrALlrg79iFgmJk9VyOT2Sgz62RmXYFDgDdrUSIQFu7PIyzULya4tjqvlvI15DIi6Wpmy5LO3wd6mNlHkkodAsBxHKfkFNj778HAD4BXJM2MeZcBZ0ralfDP/TuEFz+EKa5uwHBJw2Ne/3osPcjMvl8fgXN58n9LepDgWhjCYs4zkloBK+pzU8dxnEqjgLu2niW9R4+HM5S/kiwBqMxsAdl3vv5H0nyCqcd4M1uRVdhILorkPEJwq0MID3dHvImRfteA4zhOk6JCXKR0l7Q/wQv75ZJeIzjSvStL1VqdNsoihEWf8ZnK5CG74zhO2WOIdevLW5EAmNlUYKqkq4EbCB7a669IgKckjQf+ZWYLE5lxNf8QgnuTpwgW5xVA71IL4DhOHvQu5c0N1q4tb0UiqQ3wXcKIZBfCLrCcdlXXpkiOIli1j4m+r1YQXJQ0Ax4Hfm9mM+stdaNjEyN8x3HKiFL2YDOxbm15xyMBXgb+CVyRiP+UK7V5//0SuIkQqXAzoD3wRV0WYMqLhGuZViWVwnGc+lHKHmzrxZovy94Gbef6LlXkpELN7Cui75fKJeGGxuOROE45UsoebCbWflXeU1sE1y2XELzNVCcyzWwTb8Kp5GKQ6DiO49SKWL+ueU6pEXM3wchxJ+DXwALgxVwqNuqnchzHKQvWC8p/autrZnazpCFm9jTwtKSnc6mYdUQi6XxJW+ctouM4TqViwFrllhovCU8lSyUdI2lvNo5Om5FcRiTbAS9Kegm4BXjMbUccx3FSWFtqAfLmSklbARcBfwLaABfkUjGXeCS/iP5b+hPWsf4cIxnenORlsgLYr9QCOI6TByXtwSEgSbnzRNytmynWSUZy3bVlkt4D3iN8XVsD/5A0ycwuqau0jRMPwOg45UxJe3BlKJJXJS0D/g08AzxnZp/kUjGXwFb/S7BiX04Iw3ixmX0lqRkwF6gQRZL4vrYqqRSO49SPkvZgY8MKQ5liZt0k7QB8EziWYEO4wsx6Z6uby/bf9sCJZnakmd0XbUows/XxZhXC/TE5jlOOlLQHGyGWYC4pC5K2l/SUpDmSZksaEvNPjufrJe2bVP4ISdMlvRI/N7H7kDRB0qtZ7tuF4ML+mwRHAbMJnoCzkssayS9ruZZT9CzHcZyKp3BTW2uBi8zsJUlbAtMlTQJeJXhi/1tK+eXAADNbIqkX8BghOBVQEy79sxzuu5BgN3K1mZ2brXAybkfiOI6TL+uBLwvTlJktJXoSMbOVkuYAnc1sEkBKTHXMbEbS6WygWlJLM1sd475fCJzNBuP/TOxNcMh7mqShhKWLp83s5mwyuyJxHMfJl7ottreXNC3pfLSZjU5XUFJXwgv+vzm2PRCYYWar4/lI4Hrg82wVzexlSW8BbxGmt04HDiWE/a2VorlIqWWer52kSZLmxs+tk+oMkzRP0huSjkzK7xPn/+ZJ+qNSVbLjOE4pSSiSXBIsN7N9k1ImJdKaEAfqZ2b2aTYRJPUErgXOiee9gW5m9kAujxCV2/MEV/KvA4fGeO9ZKeaIJNM83w+ByWZ2TRw+DQUulbQ7wQ9+T6AT8ISkHma2DhhFGJq9QAg3eRTwSGHF/UZhm3Mcp0EpaQ824IvCNRc9ro8H7jazrHsI4kL5A8DgJPu+g4A+khYQ3vUdJE0xs74ZmjnazD6oj7xFG5GY2VIzeykerwTmEBaAjidE3SJ+nhCPjyeEdVxtZvOBecD+kjoCbczs+WhRf0dSnQKya0yO45QjJe3Bhd21JcJ00hwzuyGH8m2Bh4BhZvZcjUhmo8ysUxxVHAK8WYsSIVmJSHowu6QbaBDvvynzfNvGxaTEolKHWKwzsCip2uKY1zkep+anu8/ZkqaFIVrWKcEUlsfkOE45UtIeXLeprWwcDPwA6CdpZkzfkfRdSYsJI42HJD0Wy58PdAOGJ5XvkKHtXEn7js1E0RfbU+f5alneSHfBasnfNDPMNY4O9+1UR39gE+OnxyNxnHKkpD24gJbtZvYs6d97EKavUstfCVyZpc0F1M34f0b2IhsoqiLJMM+3TFJHM1sap63ej/mLge2TqncBlsT8LmnyHcdxGgdl7CJFUjVwLmFU8wrBj+KP69JGMXdtZZrnm0BwuUL8/FdS/qmSWsYY8d2BqXH6a6WkA2Obg5PqOI7jNA4KN7XV0NwO7EtQIkcTtgvXiWKOSBLzfK9ImhnzLgOuAcZJOpNgSXkygJnNjl6FXyN83efFHVsAPwFuAzYn7NYq8I4tx3GcPCjjEQmwu5ntASDpZmBqXRsomiLJMs93WIY6VwFXpcmfhrvndRynsVLeiqTG3aSZra2PmZ5bttdwaKkFcBwnD0ragwvoIqUE7CUpYfAoYPN4LkIUkTbZGnBFUsMupRbAcZw8KHkPLtMRiZlV5duGK5IalsbPjiWVwnGc+lHSHlzeU1t544qkhkfjp9uROE45UtIevJ6CukgpN1yROI7j5EvCRUoTxRWJ4zhOIfCpLcdxHKfe+BqJ4ziOkxdGkjVG08MVSQ1pbSQdxykTStqDm/gaSYO4kS8PdojJcZxypKQ9uIBu5CXdIul9Sa8m5e0l6fkYKXaipDYx/whJ02P+dEn90rQ3IbmtYuCKpIaFMTmOU46UvAcXzmnjbYQosMn8HzA0+sR6ALg45i8HBsT8M4A7kytJOhH4rM7PUkdckdQwOSbHccqRkvbghIuUXFIWzOwZ4KOU7F2BZ+LxJGBgLDvDzBJhNWYD1ZJaQk0sqAvJEqukELgicRzHyZe6TW21T0RyjensHO7wKnBcPD6ZjWM3JRgIzDCz1fF8JMElfF3DxdYZX2x3HMfJl7pt/11uZvvW8Q4/Bv4o6ZeE2E1rki9K6glcC/SP572BbmZ2QQx1XlRckTiO4+SLUVTvv2b2OhuURA/gmMQ1SV0I6yaDzeytmH0Q0EfSAsJ7voOkKWbWtxjy+dSW4zhOvhRw11Y6JHWIn82AXwB/jedtgYeAYWb2XI04ZqPMrJOZdQUOAd4slhIBH5EkkbpJwnGccqKkPbiAlu2SxgB9CWspi4FfAa0lnReL3A/cGo/PJ8RaHy5peMzrb2bvF0aa3HBFUoO7j3eccqakPbiAlu1mNijDpRvTlL2SLLuyzGwBRY4w64qkhsTUYsnD4xSdrbduwYgR+9CtWxuaFWFyc6s5wCPfLHzDTt1Zv55P583jpREjWPPxx6WWpqiUtAc3cct2VyQ1JLZoV74iGTFiH/bffyeaN29FiKZZWDp+3dCqpdkLOkXHgFXt2sGIEbwwZEipxSkqJe/B7rTRaUp069amaErEaVwIaNW8OW26dSu1KJWNe/91mhphOsuVSFNBQFHmMJ0NNHHvv0X7dWVwPNZO0iRJc+Pn1knXhkmaJ+kNSUcm5feJDsnmSfqjJH8DOo7TuFgPrM4xVSDF/DflNjbdkTcUmGxm3QlucYYCSNodOBXoGevcJKkq1hkFnA10j8n36VYAN95yC9/+3vc4fNAgjjjtNF56tajOSXPipHPO4eXXXitK23+/5x6++HKDxdoPhgzhk5Uri3Ivp0QU0Y6ksVO0qS0zeyaNaf7xhP3RALcDU4BLY/7Y6CNmvqR5wP7RKrONmT0PIOkO4ATgkcJLPKDwTVYIjzxyPzfddA3Lli1h22078dOfDuXoo0+sd3vTZs3iiWef5dG77qJlixZ8tGIFa77Kf15g7dq1NG/eOGdr/2/sWAZ+5ztsXl0NwJ03brKT08mTkvbgJj611dC9blszWwpgZksT1ppAZ+CFpHKLY95X8Tg1Py3R+Vl0gLZVHUVrX8fyTYNHHrmfq6++hC+//AKA9957l6uvvgSg3srk/eXLabfVVrRs0QKAdm3b1lz799SpjLzxRtatW8deu+/Ob4YOpWWLFhxw3HE8cscdtGvblpdfe42RN97IP/72N64fPZplH3zAoqVLade2LSMuuICh11zDO+++C8BvLr2U/fbai/EPP8wt997Lmq++Yu9evfjNpZdSVVWVTryN+PiTT7ho5EgWvvsu1dXV/Payy9i9e3dWff45v/jd75g1Zw6SuOCsszimXz+GXnMNL7/2Gl9++SXHHHYYPz/nHG4eO5ZlH3zAyeeey9Zt2/KPv/51o+f52913c++ECQAMOv54zjrtNBYtWcLpQ4aw/157MW3WLLbr0IFbrruuRhE5m1LSHtzEt/82lhW4dOseVkt+WsxstJntGxyibVFHEd6IyUnmppuuqVEiCb788gtuuumaerf5rQMPZMmyZRwycCDDrrmG56dPD+2uXs0Fv/41o66+msljx7J23Tru+Mc/srY36/XXueW66/jLlVcy/LrrOHDvvXninnt47M472XWXXZg7fz4TJk3inzffzKR77qGqWTPuf/TRnGS9fvRoeu26K0+MGcPQn/6UIb/6FQB/uPlmtmzdmsljx/LEmDEcvG/wwXfpT37CI3fcwRNjxvDCSy/x2ty5nHnqqWy7zTbc99e/8o+//nVj2efMYdzEiTx4221MvPVW7vnnP3n1jfA7nL9oEWecfDJPjRtHmy235OEnn8z5O26KlLQHF9CNfDnS0IpkmaSOAPEzYca/mI3dIncBlsT8Lmnyi8B/YnKSWbYs/dedKT8XWm2xBY/eeSe/vewyvrb11vzkssu4d+JE3nrnHXbo3JlddtwRgJOPOYb/zpiRtb3+hx5a85/6c9OmMfikkwCoqqqiTevWPPvii7zy+ut8Z/BgjjjtNJ598UUWxhFLNqbOnMnAo48G4JD99uPjTz7h088+499Tp/LDk0+uKde2TRsAJj7xBEeefjpHnn46b7z9NnPnz8/a/lF9+7LF5pvTaostOPrb36555u07daLXrrsCsOduu7Foqdvm1EZJe3BiaiuXVIE09NTWBEIUr2vi57+S8u+RdAPQibCoPtXM1klaKelA4L/AYOBPDSxzk2bbbTvx3nubvnS33bZTXu1WVVXxjT59+EafPuzWrRv3PfggPXv0yFi+eVUV69evB2D1mo08aLNFlukeM+PkY45h2Pnn11lOs00HwIr5qRsIF777Ln+76y4euv122rZpw89GjODL1bVv00nXfoKWm21Wc1zVrBlfrmvCcyflQBP+8xRz++8Y4HlgV0mLJZ1JUCBHSJoLHBHPMbPZwDjgNeBR4DwzS/xZfkIIMzmP4AWhCAvtDc0s4PfAiPg5q6TS1MZPfzqU6urNN8qrrt6cn/50aL3bnLdgAW8v3BAUdfabb9KlY0e6de3KoiVLmL9oEQDjH36YA/fZB4AuHTsya84cAB6qZYrnkP32q5kOW7duHSs/+4xD9tuPB598kuUfhaBzH3/yCYtz/O/+wH32qZkG+8/06bRr25YtW7fmWwccwK3jxtWUW/Hpp6xctYrNN9+cNq1b88GHH/LU88/XXG+9xRZ8tmpV2vYfe/ppvvjySz7/4gsenTKFA/beOyfZnEaG5ZgqkGLu2srkeOywDOWvAq5Kkz+NIjsca1hmARPZMMb9JJ4D7FkSiWojsaBeyF1bn3/xBb/43e/49LPPaF5VRdcuXfjt5ZdT3bIlN/zyl5wzdGjNYvsPBg4E4MKzzuKiK6/kT7fdxt49e2Zs+4qLLuKSq69m7IQJNGvWjN8MHcq+e+7JJeeey6Dzz8fMaN68OVddcgldOm7q5m/wBRfU7Pzqs8ceXDtsGBdecQWHDxpEdXU1fxgxAoAhZ57JZb/9Lf1OOYVmVVVc+D//w3f69aNXjx58+5RT2KFzZ/bbc8Pf8/vf/S6nDxlCh/btN1on2WO33Tj52GM55owzgLDY3mvXXVm0pEgzuI5TBFTb0LqckToZnFOHGgmvzD8qhjhJ/J6gPFLZCrigyPcOPPJIf9q337Fo7Xfc19A0n89vTLyzfDmPx7WeSiWfHjwCptcjamEN0r4G03ItXeu9JN0CHAu8b2a9Yt69hLjtAG2BFWbWW1JiZqcFIWrixWb2ZEp7E4CdE20Vg8a56b4k1P8/7LqRTonUlu84Ti40VA9uAG4D/gzckcgws1MSx5KuZ8MLYzkwwMyWSOoFPEaSiYSkE4HPii2wK5Ia6mp3ks99Mo1IHMepL6XtQeuBL7KWyoUMxtwARBdR3wP6xbLJ2xpnA9WSWprZakmtgQsJtnXjNmmsgDQWO5JGwKsxFZvDgM1S8jYjw9KR4zg50lA9OD112v/bXtK0pHR2HW70TWCZmc1Nc20gMCN6CAEYCVwPfF6PB6oTPiKp4cX4Wex1/cQC7GTCyGQrghJpfAvtjlNONFQPTk+d/Mgvz2M9ZhAwJjVTUk/gWqB/PO8NdDOzCzKNbgqJK5KSsCeuOBynkii+sy1JzQlLQX1S8rsADwCDzSwRKPIgoE/0V9gc6CBpipn1LYZsPrXlOI6TNw1i2n448LqZ1fgflNQWeAgYZmbP1UhjNsrMOplZV+AQ4M1iKRFwReKUiO0POIAjTjuNfqecwhkXXFBwl+rFctPuruad9BhhsT2XVDsZjLkhhNpIndY6H+gGDJc0M6YONDA+teVkpV27zenceUtatKhizZp1vPvuSj76KL8dKtUtWzLpnnsAGDJiBLfddx9DfvzjQogLFMZNu5lhZjRroOiC7mq+nClcrN1Mxtxm9sM0eVcCV2ZpbwFFXjpyRVLD90otQKOkXbvN2XHHraiqCi/Tli2bs+OOYaNlvsokQZ899mDO3LAJZcHixVx+7bV8uGIFm1dX87vLL6db16588OGHdXIPn3DTPurOO+m83XY1DhavHz2aVltswbmnn86oO+9k4qRJrPnqK47q25efn3NOjfv2b/Tpw/RXXuGW665LawGfjLuabxyUtgc37YAkPrVVQ6uYnGQ6d96yRokkqKpqRufOWxak/XXr1vHsiy/S/9BDAbjkqqsYefHFPHrnnQwfMoRh114LUG/38Mf378/ESZNqzic+8QQDDj+cp194gfkLF/LQ7bfz+N13M+v113nhpZcAeOuddzjpmGN4/O67syoRcFfzjYXS9uDEiKRphkj0EUkNCbsed5iXTIsW6YM/ZcrPlS9Xr+aI005j8dKl7LHbbhx6wAGs+vxzpr/yCucM3eAQMhE58blp07jx178GNriHH//wwzXu4RNttm/XbqP79Np1V5Z//DHvffABH378MVttuSWdt9uOm8eO5en//pf+3/8+EPx/zV+0iM7bbUeXjh3ps8ceOT/L1Jkz+XtUeKmu5m+6aoP7uGRX83c/8ADr1q1j2fLlzJ0/n927d6+1/YSreaDG1Xz/Qw91V/NJlLYHN+0RiSuSGmbGT1ckyaxZs46WLTf9maxZk5/P7MQayaeffcYZF1zAbffdx/eOPZY2rVvXrJ1kI1f38Mf068dDkyfz/ocfcnz//jV1z//hD/nBiRs71li0ZElWt/Tp5EjFXc03PDPjZ+kUSWWONnLBp7acWnn33ZWsW7d+o7x169bz7ruF2U3UpnVrRv785/z1rruorq5m+06dmPjEE0B4gc5+800gP/fwx/fvz78ef5yHnnySYw4LHgT6HnQQ906YwKrPg9Hv0vffr2mnrrireWeDi5T8d22VIz4icWolsaBe6F1byfTadVd2796dfz3+OH8eOZJh11zDjbfcwtq1azn+iCPo2aNHXu7hd91lF1Z9/jnbbbMN27YPkb2/deCBzJ0/n+PiTrEtttiCP11xBVU57NByV/POpjTtqS13I19DQ7mRLz3uRr7p4W7ka2dE3m7kuxvckGPp4/K6V2PERySO4zh507RHJK5Iavh+qQVwHCcPStuDXZE4QAgw1jRYvx7CD19ZSjqVgEHij17RlLYHN+1dW65IapgaP/cvqRQNwbx5n9Ku3SqaN2+FK5PKxoBVa9fy6bx5pRal6JS2BxcusFU54oqkhtnxs/IVyYgRLzFiBHTr1oZiuJH6ag6w3EMHNwrWr+fTefN4Ke4kq2RK24N9astpYnz88RqGDHmhaO0PtzVU7X510dp3nMZH057aKhuDRElHSXpD0jxJQ7PXcBzHaSgKF49E0i2S3pf0alLeCEnvJrmK/07MP0LSdEmvxM9+adqbkNxWMSiLEYmkKuAvwBHAYuBFSRPMrJbAEB+yYWd5gp6Ege8a4O6Ua+8BrePxKmAcm7IfwRvzJ8D9aa5/A9gVWA5MTHP9UGAXYCnwaJrrhwE7AAsJoXhTOQroCLwFPJPm+gCgPfAG8J80108khPZ9lQ2BSZP5HsHt3Qw2OJxI5vuEJc2pbJhISCbs4H/+uhdIDSi9GXB6PH4aeDvl+hbAKfH4CWBRyvU2hIDUAI8Q/lrJfA04Lh5PIPz1k9kOSFhRjAc+Tbm+PSFqEMC9bBrkemfgW/H4LjZ9HfQADo7Hqb86qP2XB9Cb4NrDf3n5/PLC3zX1+8/lt5c/BR2R3Ab8GbgjJf/3ZnZdSt5yYICZLZHUC3gM6Jy4KOlE4LNCCZaJchmR7A/MM7O3zWwNMBY4vsQyOY7jRArnIsXMngFy8tdjZjPMLOHiYDZQLaklgKTWwIVkiVdSCMrCsl3SScBRZvY/8fwHwAFmdn5KubOBs+NpL8I/QOVCe8J/F+WEy9wwuMzFZ0cz26a+lSU9SnjmXKgGvkw6H21mo1Pa6wo8aGa94vkI4IeEQdc04CIz+zilzknAuWZ2eDz/PWEAOSO5rWJQFlNbpN+juokGjH+M0QCSppWTG4Jykxdc5obCZW78mNlRRb7FKGAk4b03ErgeqAkpKqkncC3QP573BrqZ2QVRKRWVcpnaWkyYxk7QBXCPdY7jNAnMbJmZrTOz9cDfSdrlLKkL8AAw2MzeitkHAX0kLQCeBXpImlIs+cpFkbwIdJe0k6QWwKmENVXHcZyKR1KyS+vvEqftJbUFHgKGmdlziQJmNsrMOplZV+AQ4E0z61ss+cpiasvM1ko6n7AjoQq4xczSbd5IZnSW642NcpMXXOaGwmVuQkgaA/QF2ktaDPwK6BunqwxYwAbX5ucD3YDhkobHvP5m9n6DylwOi+2O4zhO46VcprYcx3GcRoorEsdxHCcvKk6RlIsrFUkLoluDmZKmxbx2kiZJmhs/ty6xjOlcNWSUUdKw+L2/IenIRiRzWvcSjUFmSdtLekrSHEmzJQ2J+Y32e65F5kb7PTtFxswqJhEW4t8ieLRoAbwM7F5quTLIugBon5L3W2BoPB4KXFtiGQ8F9gFezSYjsHv8vlsCO8W/Q1UjkXkE8PM0ZUsuM8HzyD7xeEvgzShXo/2ea5G50X7PnoqbKm1EUu6uVI4Hbo/HtwMnlE6UjK4aMsl4PDDWzFab2XxgHiXw6J1B5kyUXGYzW2pmL8XjlcAcgq+kRvs91yJzJkous1NcKk2RdGZjf3+Lqf0HXkoMeDx67Ey4ddnWzJZC6KxAh5JJl5lMMjb27/58SbPi1FdimqhRyRwtkPcG/kuZfM8pMkMZfM9O4ak0RZKTK5VGwsFmtg/BKe15kg4ttUB50pi/+1EE57e9CQ5wr4/5jUbm6GBvPPAzM0t1TrxR0TR5jUXmRv89O8Wh0hRJ2bhSseix04Lh0AOEof6yhAVr/GxQo6IcySRjo/3uLbN7iUYhs6TNCC/ku80s4SW+UX/P6WRu7N+zUzwqTZGUhSsVSa0kbZk4Jjhae5Ug6xmx2BnAv0ojYa1kknECcKqklpJ2ArqzIYx2ScnkXoJGILMkATcDc8zshqRLjfZ7ziRzY/6enSJT6tX+QifgO4RdJG8Bl5dangwy7kzYxfIyIYbA5TH/a4S4QnPjZ7sSyzmGMEXxFeG/yjNrkxG4PH7vbwBHNyKZ7wReAWYRXmodG4vMBD9IFmWbGdN3GvP3XIvMjfZ79lTc5C5SHMdxnLyotKktx3Ecp4FxReI4juPkhSsSx3EcJy9ckTiO4zh54YrEcRzHyQtXJE5JkLS5pKclVdWx3hWSDk+T31fSg4WTMCdZPsuz/rGSfl0oeRynVLgicUrFj4H7zWxdrhUkVZnZL83siSLK1SBIak6ItX2cpC1KLY/j5IMrEqegSNovOu2rjhb8syX1SlP0+0RrbUnNJN0Uyz4o6WFJJ8VrCyT9UtKzwMmSbku6dpSk1+O1EzPI80NJ90t6NMb2+G3Stc+Sjk+SdFs8vk3SqBhz421J34pOCOckyiTVu17SS5ImS9om5u0S7zdd0r8l7ZbU7g2SniK4hTdgCnBsfb5rx2ksuCJxCoqZvUiwar6SEFPjLjN7NblMdF+zs5ktiFknAl2BPYD/AQ5KafZLMzvEzMYmtVFN8Oc0APgmsF0tYvUGTontnyJp+1rKJtga6AdcAEwEfg/0BPaQ1DuWaQW8ZMH55tPAr2L+aOD/mVkf4OfATUnt9gAON7OL4vm0KL/jlC3NSy2AU5FcQfB79iXwv2mutwdWJJ0fAtxnwdnfe/E/9mTuTdPGbsB8M5sLIOku4Ow05QAmm9knsdxrwI5s7NY8HRPNzCS9Aiwzs1di/dkEpTcTWJ8k213A/dEj7jeA+4JLKiAEdEpwX8p03vtApyyyOE6jxhWJUwzaAa2BzYBqYFXK9S9ifoJ0bsaTSa2fIFf/PquTjtex4XefXD9ZnuQ661PqrydzvzHCKH+FmfXOUCb1WaoJ34fjlC0+teUUg9HAcOBu4NrUi2b2MVAVp6cAngUGxrWSbYG+OdzjdWAnSbvE80H1kHOZpK9LakbwVltXmgEnxePTgGctxOWYL+lkCJ5yJe1VSxs92OAl13HKElckTkGRNBhYa2b3ANcA+0nql6bo44QpLQhxLRYTXqh/I0Tb+6S2+5jZl4SprIfiYvs79RB3KPAg8CTBY3BdWQX0lDSdsJ5yRcz/PnCmpIR359rCPX+bsHvLccoW9/7rlARJewMXmtkP4nlrM/tM0tcIsSoONrP3SipkkYmjr3vM7LBSy+I4+eBrJE5JMLMZcXttVVx8flBSW6AFMLLSlUhkB+CirKUcp5HjIxLHcRwnL3yNxHEcx8kLVySO4zhOXrgicRzHcfLCFYnjOI6TF65IHMdxnLz4/53xKzfmo8DiAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Define coordinates for source\n",
    "ReceiverFileinput=np.zeros([0,2])\n",
    "#Receiver set 1\n",
    "x_start=0.046\n",
    "x_end=0.046\n",
    "y_start=4.0266\n",
    "y_end=6.01\n",
    "\n",
    "ReqReceivers=8\n",
    "DistStarttoEnd=np.sqrt((x_end-x_start)**2+(y_end-y_start)**2)\n",
    "DistReceivers_m=DistStarttoEnd/ReqReceivers\n",
    "\n",
    "spacing=DistReceivers_m\n",
    "\n",
    "Array_raw=LinearArray(x_start,x_end,y_start,y_end,spacing)\n",
    "Array=TRplacement(DH,0,0,Array_raw)\n",
    "Receiver_addon=np.zeros([len(Array),2])\n",
    "for n in range(len(Array)):\n",
    "    Receiver_addon[n,0]=Array[n,0]\n",
    "    Receiver_addon[n,1]=Array[n,1]\n",
    "ReceiverFileinput=np.vstack((ReceiverFileinput,Receiver_addon))\n",
    "\n",
    "im1 = plt.contourf(xx_grid.T, yy_grid.T, zz_Vp,500,cmap=plt.cm.jet,norm=None)\n",
    "plt.scatter(SourceFileinput[:,0]/DH,SourceFileinput[:,1]/DH, color='black',label='Source Location')\n",
    "plt.scatter(ReceiverFileinput[:,0]/DH,ReceiverFileinput[:,1]/DH, color='white',label='Receiver Location')\n",
    "plt.plot([0,NX-1],[FW,FW],'black',linestyle='dashed')\n",
    "plt.plot([0,NX-1],[NY-FW-1,NY-FW-1],'black',linestyle='dashed')\n",
    "plt.plot([FW,FW],[0,NY-1],'black',linestyle='dashed')\n",
    "plt.plot([NX-FW-1,NX-FW-1],[0,NY-1],'black',linestyle='dashed')\n",
    "plt.xlim(0,NX-1) ; plt.ylim(0,NY-1)\n",
    "plt.legend()\n",
    "plt.title(\"Receivers' Location\")\n",
    "plt.xlabel('x (grid number)'); plt.ylabel('y (grid number)')\n",
    "cbar = plt.colorbar(im1, orientation = 'vertical')\n",
    "cbar.set_label(\"P-wave velocity (m/s)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "01023065",
   "metadata": {},
   "outputs": [],
   "source": [
    "SEISMO=4\n",
    "READREC=0\n",
    "REC_FILE='./receiver/receiver.dat'\n",
    "REFREC_TUPLE=str(0)+' , '+str(0)\n",
    "REC1_TUPLE=str(x_start)+' , '+str(y_start)\n",
    "REC2_TUPLE=str(x_end)+' , '+str(y_end)\n",
    "NGEOPH=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "117cd4b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "Decimals=6\n",
    "file=open('receiver.dat','w')\n",
    "for n in range(len(ReceiverFileinput)):\n",
    "    file.write('{} {}\\n'.format(np.round(ReceiverFileinput[n,0],decimals=Decimals),np.round(ReceiverFileinput[n,1],decimals=Decimals)))\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "c8848895",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.046 4.026\n",
      "0.046 4.274\n",
      "0.046 4.522\n",
      "0.046 4.77\n",
      "0.046 5.018\n",
      "0.046 5.266\n",
      "0.046 5.514\n",
      "0.046 5.762\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file=open('receiver.dat','r')\n",
    "print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6842e31a",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "cddcab72",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Receivers\"]=\"comment\"\n",
    "jsonfile_output[\"SEISMO\"]=str(SEISMO)\n",
    "jsonfile_output[\"READREC\"]=str(READREC)\n",
    "jsonfile_output[\"REC_FILE\"]=str(REC_FILE)\n",
    "jsonfile_output[\"REFRECX, REFRECY\"]=str(REFREC_TUPLE)\n",
    "jsonfile_output[\"XREC1, YREC1\"]=str(REC1_TUPLE)\n",
    "jsonfile_output[\"XREC2, YREC2\"]=str(REC2_TUPLE)\n",
    "jsonfile_output[\"NGEOPH\"]=str(NGEOPH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1abb3e90",
   "metadata": {},
   "source": [
    "#### 4.11 Receiver array\n",
    "In case I want horizontal set of receivers, I can set up this option on.\n",
    "Parameters are:\n",
    "- REC_ARRAY: number of horizontal receiver arrays simulated. (No=0)\n",
    "- REC_ARRAY_DEPTH: depth of the first array (in m)\n",
    "- REC_ARRAY_DIST: vertical distance between arrays (in m)\n",
    "- DRX: distance between receivers for each horizontal array (in grid points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "991c82cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "REC_ARRAY=0\n",
    "REC_ARRAY_DEPTH=70\n",
    "REC_ARRAY_DIST=40\n",
    "DRX=4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "379276fb",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "d168879b",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Receivers array\"]=\"comment\"\n",
    "jsonfile_output[\"REC_ARRAY\"]=str(REC_ARRAY)\n",
    "jsonfile_output[\"REC_ARRAY_DEPTH\"]=str(REC_ARRAY_DEPTH)\n",
    "jsonfile_output[\"REC_ARRAY_DIST\"]=str(REC_ARRAY_DIST)\n",
    "jsonfile_output[\"DRX\"]=str(DRX)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d90be554",
   "metadata": {},
   "source": [
    "#### 4.12 Seismograms\n",
    "In this step, I set up the format and location of output waveforms at each receiver.\n",
    "Parameters are:\n",
    "- NDT: sampling rate (in time steps)\n",
    "- SEIS_FORMAT: data output format (SU format=1, TEXTUAL -native ASCII- =2,BINARY -IEEE-4-bytes-float-=3)\n",
    "- SEIS_FILE: basic filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a120aa1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "NDT=1\n",
    "SEIS_FORMAT=4\n",
    "SEIS_FILE='./su/test'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ccb1e09",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "f2cfa546",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Seismograms\"]=\"comment\"\n",
    "jsonfile_output[\"NDT\"]=str(NDT)\n",
    "jsonfile_output[\"SEIS_FORMAT\"]=str(SEIS_FORMAT)\n",
    "jsonfile_output[\"SEIS_FILE\"]=str(SEIS_FILE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d94dc268",
   "metadata": {},
   "source": [
    "#### 4.13 Monitoring the simulation\n",
    "In this step I setup the amount of information I obtain in order to control the simulation.\n",
    "Parameters are:\n",
    "- LOG: output of logging information of node (no output=0, to stdout=1, to file LOG_FILE=2)\n",
    "- LOG_FILE: log file name to output the monitoring info\n",
    "- OUT_TIMESTEP_INFO: time between monitoring outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4d6dd5f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "LOG=1\n",
    "LOG_FILE='log/test.log/'\n",
    "OUT_TIMESTEP_INFO=10000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758adf92",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "cb8f01bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Monitoring\"]=\"comment\"\n",
    "jsonfile_output[\"LOG_FILE\"]=str(LOG_FILE)\n",
    "jsonfile_output[\"LOG\"]=str(LOG)\n",
    "jsonfile_output[\"OUT_TIMESTEP_INFO\"]=str(OUT_TIMESTEP_INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2261ee10",
   "metadata": {},
   "source": [
    "#### 4.14 Checkpointing (probably not working on the code...)\n",
    "If I want to generate checkpoints and continue from an specific point since I interrupted my processing, I can set up this parameters. They can generate a huge amount of data!\n",
    "Parameters are:\n",
    "- CHECKPTREAD: read wavefield from checkpoint file (yes=1, no=0)\n",
    "- CHECKPTWRITE: write wavefield to checkpoint file (yes=1, no=0)\n",
    "- CHECKPTFILE: checkpoint filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d20c13d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHECKPTREAD=0\n",
    "CHECKPTWRITE=0\n",
    "CHECKPT_FILE='tmp/checkpoint_sofi2D'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c3412d7",
   "metadata": {},
   "source": [
    "##### JSON Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "96669b92",
   "metadata": {},
   "outputs": [],
   "source": [
    "jsonfile_output[\"Checkpointing\"]=\"comment\"\n",
    "jsonfile_output[\"CHECKPTREAD\"]=str(CHECKPTREAD)\n",
    "jsonfile_output[\"CHECKPTWRITE\"]=str(CHECKPTWRITE)\n",
    "jsonfile_output[\"CHECKPT_FILE\"]=str(CHECKPT_FILE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "334ded1a",
   "metadata": {},
   "source": [
    "#### 4.15 JSON File Preview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "d16dfbcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('sofi2D.json', 'w+') as f:\n",
    "    json.dump(jsonfile_output, f,indent=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "24a0c639",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "\"Domain Decomposition\": \"comment\",\n",
      "\"NPROCX\": \"4\",\n",
      "\"NPROCY\": \"5\",\n",
      "\"FD order\": \"comment\",\n",
      "\"FDORDER\": \"12\",\n",
      "\"FDORDER_TIME\": \"4\",\n",
      "\"MAXRELERROR\": \"1\",\n",
      "\"2-D Grid\": \"comment\",\n",
      "\"NX\": \"300\",\n",
      "\"NY\": \"7000\",\n",
      "\"DH\": \"0.001\",\n",
      "\"Time Stepping\": \"comment\",\n",
      "\"TIME\": \"0.0055\",\n",
      "\"DT\": \"2.5e-08\",\n",
      "\"Sources\": \"comment\",\n",
      "\"SOURCE_SHAPE\": \"1\",\n",
      "\"SIGNAL_FILE\": \"signal_mseis.tz\",\n",
      "\"SOURCE_TYPE\": \"1\",\n",
      "\"SRCREC\": \"1\",\n",
      "\"SOURCE_FILE\": \"./sources/source.dat\",\n",
      "\"RUN_MULTIPLE_SHOTS\": \"0\",\n",
      "\"PLANE_WAVE_DEPTH\": \"0\",\n",
      "\"PLANE_WAVE_ANGLE\": \"89\",\n",
      "\"TS\": \"0.2\",\n",
      "\"Model Generation\": \"comment\",\n",
      "\"READMOD\": \"1\",\n",
      "\"MFILE\": \"model/test\",\n",
      "\"WRITE_MODELFILES\": \"0\",\n",
      "\"Q-Approximation\": \"comment\",\n",
      "\"L\": \"0\",\n",
      "\"FL1\": \"5\",\n",
      "\"TAU\": \"1e-05\",\n",
      "\"Boundary Conditions\": \"comment\",\n",
      "\"FREE_SURF\": \"0\",\n",
      "\"BOUNDARY\": \"0\",\n",
      "\"FW\": \"15\",\n",
      "\"ABS_TYPE\": \"1\",\n",
      "\"NPOWER\": \"4\",\n",
      "\"K_MAX_CPML\": \"1\",\n",
      "\"VPPML\": \"3500\",\n",
      "\"FPML\": \"4000\",\n",
      "\"DAMPING\": \"8\",\n",
      "\"Wavefield Snapshots\": \"comment\",\n",
      "\"SNAP\": \"4\",\n",
      "\"TSNAP1\": \"2.5e-08\",\n",
      "\"TSNAP2\": \"0.0055\",\n",
      "\"TSNAPINC\": \"0.0005499999999999999\",\n",
      "\"IDX\": \"1\",\n",
      "\"IDY\": \"1\",\n",
      "\"SNAP_FORMAT\": \"3\",\n",
      "\"SNAP_FILE\": \"./snap/test\",\n",
      "\"Receivers\": \"comment\",\n",
      "\"SEISMO\": \"4\",\n",
      "\"READREC\": \"0\",\n",
      "\"REC_FILE\": \"./receiver/receiver.dat\",\n",
      "\"REFRECX, REFRECY\": \"0 , 0\",\n",
      "\"XREC1, YREC1\": \"0.046 , 4.0266\",\n",
      "\"XREC2, YREC2\": \"0.046 , 6.01\",\n",
      "\"NGEOPH\": \"1\",\n",
      "\"Receivers array\": \"comment\",\n",
      "\"REC_ARRAY\": \"0\",\n",
      "\"REC_ARRAY_DEPTH\": \"70\",\n",
      "\"REC_ARRAY_DIST\": \"40\",\n",
      "\"DRX\": \"4\",\n",
      "\"Seismograms\": \"comment\",\n",
      "\"NDT\": \"1\",\n",
      "\"SEIS_FORMAT\": \"4\",\n",
      "\"SEIS_FILE\": \"./su/test\",\n",
      "\"Monitoring\": \"comment\",\n",
      "\"LOG_FILE\": \"log/test.log/\",\n",
      "\"LOG\": \"1\",\n",
      "\"OUT_TIMESTEP_INFO\": \"10000\",\n",
      "\"Checkpointing\": \"comment\",\n",
      "\"CHECKPTREAD\": \"0\",\n",
      "\"CHECKPTWRITE\": \"0\",\n",
      "\"CHECKPT_FILE\": \"tmp/checkpoint_sofi2D\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "jsonfile = open(\"sofi2D.json\", \"r\")\n",
    "print(jsonfile.read())\n",
    "jsonfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "549d367a",
   "metadata": {},
   "source": [
    "### 5. Next Steps\n",
    "\n",
    "#### 5.1 Generated input files and location\n",
    "We describe the generated files, function and location within the /SOFI2D/par/ folder\n",
    "- JSON file (sofi2D.json)--> Parameters --> ./in_and_out/\n",
    "- VP, VS, RHO, QP and QS models (test.vp, test.vs, test.rho, test.qp, test.qs) --> Mechanical properties models --> ./model/\n",
    "- SOURCES file (source.dat) --> Sources' location and parameters --> ./sources/\n",
    "- RECEIVERS file (receiver.dat) --> Receiver's location\n",
    "\n",
    "#### 5.2 Model QC\n",
    "After moving the model files to SOFI2D/model/ folder, we can check the model structure using the command ximage.\n",
    "Using this command before executing the files helps QCing input files.\n",
    "Execute for (each) one of the input model files (from SOFI2D/par/ directory):\n",
    "ximage n1=NY n2=NX < model/.test.vp\n",
    "\n",
    "#### 5.3 Compilation of sofi2D\n",
    "This is located and run in folder SOFI2D/src/\n",
    "This can be done once, unless you change something within the parametrical modeling files.\n",
    "- MODEL_V=hh_visco.c --> viscoelastic model (L>0)\n",
    "- MODEL_E=hh_elastic.c --> elastic model (L=0)\n",
    "- Overnight builts (not developed here)\n",
    "Within src directory, execute either make all or make sofi2D (snapmerge will be also generated)\n",
    "\n",
    "#### 5.4 Running the program\n",
    "Running the program is started from the folder SOFI2D/par/\n",
    "Running has the following structure:\n",
    "    mpirun -np 1 nice -19 ../bin/sofi2D ./in_and_out/sofi2D.json | tee ./in_and_out/sofi2D.jout\n",
    "where:\n",
    "- mpirun is the executing command\n",
    "- -np is the number of processors we are using (if it is not equal to the one in sofi2D.json, the program will abort)\n",
    "- nice -19 is the priority index (-19 allows to process sofi2D in background and using the computer while processing)\n",
    "- ../bin/sofi2D is the compiled file (from 5.2)\n",
    "- ./in_and_out/sofi2D.json is the parameters file\n",
    "- | tee ./in_and_out/sofi2D.jout is the request to generate a report file called sofi2D.jout\n",
    "\n",
    "Once executed, the model will show sofi2d.json parameters in a table and start working. For each parameters, it will QC whether the parameter is correct (or not) and briefly explain its implications within processing. In most cases, if a parameter is not correct (wrong input), the process will terminate and a message error will show the parameter causing the issue.\n",
    "\n",
    "#### 5.5 Processing results - Output files and location\n",
    "After execution of the script, multiple files will be generated, depending on the JSON file parameters.\n",
    "We will enumerate files, structure and location of each output file:\n",
    "\n",
    "##### 5.5.a Report File\n",
    "This file writes down onscreen report shown when running the program.\n",
    "It will be written if, when running the program, \"| tee ./in_and_out/sofi2D.jout\" was written.\n",
    "Location of this file is ./in_and_out/\n",
    "Format of the file is ASCII, can be opened as text\n",
    "\n",
    "##### 5.5.b Models\n",
    "These files replicate the input model we used during processing.\n",
    "It will be written if the JSON parameter WRITE_MODELFILES is equal to 1 or 2. If equal to 1, then it will output all models Rho, U, Pi and Taup and Taus. If equal to 2, only density model Rho.\n",
    "Location of these files is ./model/\n",
    "File naming depends on the number of processors  used:\n",
    "- Files start with: test.SOFI2D.property (pi, rho, u, vp, vs)\n",
    "- Files have names based on how processors are distributed, assuming a grid with defined by arrays 0 to NX and 0 to NY\n",
    "- For example, the Vp model used in the segment taken by Processor number 4 (in NX=NY=2) is shown as: test.SOFI2D.vp.1.1\n",
    "Format of the file is binary.\n",
    "\n",
    "##### 5.5.c Wavefield snapshots\n",
    "These files replicate spatial seismograms during processing.\n",
    "It will be written if the JSON parameter SNAP is equal to 1, 2, 3 or 4. If equal to 1 the output is only particle velocities; if equal to 2, is the pressure field; if 3, curl and divergence energy; and if 4, all 1,2 and 3.\n",
    "Location of these files is ./snap/\n",
    "File naming depends on the number of processors  used:\n",
    "- Files start with: test.bin/txt.property (vx, vy, p, div, curl)\n",
    "- Files have names based on how processors are distributed, assuming a grid with defined by arrays 0 to NX and 0 to NY\n",
    "- For example, the Vp model used in the segment taken by Processor number 4 (in NX=NY=2) is shown as: test.bin.vp.1.1 (if the file is binary)\n",
    "- A final file containing the simulation within the whole space will have no processor coordinate references\n",
    "- Each file contains all snapshots in a single file\n",
    "Format of the files depends on JSON parameter SNAP_FORMAT: if equal to 2, format is ASCII, if equal to 3, then binary\n",
    "\n",
    "##### 5.5.d Seismograms\n",
    "These files are the waveforms acquired by each defined receiver.\n",
    "It will be written if the JSON parameter SEISMO is equal to 1, 2, 3 or 4. If equal to 1 the output is only particle velocities; if equal to 2, is the pressure field; if 3, curl and divergence energy; and if 4, all 1,2 and 3.\n",
    "Location of these files is ./su/\n",
    "File naming depends on the number of processors  used:\n",
    "- Files start with: test_property (vx, vy, p, div, curl)\n",
    "- Files have names based on how processors are distributed, assuming a grid with defined by arrays 0 to NX and 0 to NY\n",
    "- For example, the Vp model used in the segment taken by Processor number 4 (in NX=NY=2) is shown as: test_vp.bin.shot1 (when analyzing shot 1 for multiple shots)\n",
    "- A final file containing the simulation within the whole space will have no processor coordinate references\n",
    "- If multiple shots were performed, every file will be divided for each shot\n",
    "Format of the files depends on JSON parameter SEIS_FORMAT: if equal to 1, Seismic Unix format; if 2, format is ASCII, if equal to 3, then binary\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "302fc404",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}