{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9dc175c8-f744-4655-9037-b313c486c951",
   "metadata": {},
   "source": [
    "This final notebook for this model demonstrates how to create the boundary conditions.\n",
    "\n",
    "First, import packages to re-create and visualize the model fields here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "836f57c0-6983-48ce-b8a0-31c5b04463a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the modules for computation, plotting, and reading files\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import netCDF4 as nc4\n",
    "from matplotlib.gridspec import GridSpec\n",
    "\n",
    "# import the necessary modules from eccoseas\n",
    "from eccoseas.ecco import io\n",
    "from eccoseas.downscale import hFac\n",
    "from eccoseas.downscale import horizontal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ea43d2c-8106-4b7e-9d71-dda71ff556e4",
   "metadata": {},
   "source": [
    "## Constructing the Boundary Conditions\n",
    "For this model, we will again use the model state from the ECCO Version 5 state estimate. We will prepare the boundary condition fields in 7 steps:\n",
    "1. download the ECCO model output in 2007, 2008, and 2009\n",
    "2. read the ECCO model grid\n",
    "3. read in the bathymetry for the regional model as well as its grid\n",
    "4. prepare the ECCO fields for interpolation\n",
    "5. interpolate the ECCO fields onto the regional model grid and store each as a binary file\n",
    "6. plot the interpolated fields to ensure they look as expected"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c5328af-a028-439b-a89a-4f39b72a9a65",
   "metadata": {},
   "source": [
    "### Step 1: Download the ECCO fields\n",
    "To begin, we downloadd the model fields generated by the ECCO Version 5 Alpha state estimate. These fields are available [HERE](https://ecco.jpl.nasa.gov/drive/files/Version5/Alpha/nctiles_monthly). In particular, we downloaded the following list of files that contain the fields pertaining to time span of my model (2007-2009):\n",
    "\n",
    "| Variable | File Name |\n",
    "| -------- | --------- |\n",
    "|THETA|THETA/THETA_200[7-9].nc|\n",
    "|SALT|SALT/SALT_200[7-9].nc|\n",
    "|UVEL|UVELMASS/UVELMASS_200[7-9].nc|\n",
    "|VVEL|VVELMASS/VVELMASS_200[7-9].nc|\n",
    "\n",
    "Note that these include some of same files used to generate the initial conditions. In fact, the interpolation proceedure wil be very similar - the only difference is that it will only be applied to the boundary and it will be conducted at several timesteps. I stored these fields in the following directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "34d9856c-ec0b-4f6e-9f9c-c18a73cd6858",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_folder = '../../../data/california'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d170a9e7-8862-4e25-b732-1268f2c77c5a",
   "metadata": {},
   "source": [
    "### Step 2: Read in the ECCO grid\n",
    "To read in the ECCO fields, we will rely on the `io` module from the `eccoseas.ecco` package:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a925b6ec-93ab-429b-a830-d6591b15a327",
   "metadata": {},
   "outputs": [],
   "source": [
    "ecco_XC_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='XC')\n",
    "ecco_YC_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='YC')\n",
    "ecco_hFacC_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='hFacC')\n",
    "ecco_hFacW_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='hFacW')\n",
    "ecco_hFacS_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='hFacS')\n",
    "ecco_RF_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='RF')\n",
    "ecco_DRF_tiles = io.read_ecco_grid_tiles_from_nc(data_folder, var_name='DRF')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64a135ac-a5bb-4766-83b5-60039dcc0c56",
   "metadata": {},
   "source": [
    "### Step 3: Read in the Model Grid and Generate a Mask\n",
    "Here, we will recreate the grid we will use in the regional model, read in the bathymetry file, and recreate the masks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1ad50393-2c0a-449c-a8e4-673b0d963186",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the input directory (constructed in the previous notebook for bathymetry)\n",
    "# this directory should already have the bathymetry file called CA_bathymetry.bin\n",
    "input_dir = '../../../configurations/california/input'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f48b8cc3-eb40-40c3-b61e-1359d986109d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the parameters that will be used in the data file\n",
    "delX = 1/12\n",
    "delY = 1/16\n",
    "xgOrigin = -135\n",
    "ygOrigin = 29\n",
    "n_rows = 360\n",
    "n_cols = 240\n",
    "\n",
    "# recreate the grids that will be used in the model\n",
    "xc = np.arange(xgOrigin+delX/2, xgOrigin+n_cols*delX, delX)\n",
    "yc = np.arange(ygOrigin+delY/2, ygOrigin+n_rows*delY+delY/2, delY)\n",
    "XC, YC = np.meshgrid(xc, yc)\n",
    "\n",
    "# read in the bathymetry file\n",
    "bathy = np.fromfile(os.path.join(input_dir,'CA_bathymetry.bin'),'>f4').reshape(np.shape(XC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a5f9cf36-029c-431c-b2f0-5fe80a139c64",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this model will use the same vertical spacing as the ECCO Version 5 configuration\n",
    "delR = ecco_DRF_tiles[1]\n",
    "\n",
    "# generate the hFac grids - this may take a few minutes\n",
    "hFacC = hFac.create_hFacC_grid(bathy, delR)\n",
    "hFacS = hFac.create_hFacS_grid(bathy, delR)\n",
    "hFacW = hFac.create_hFacW_grid(bathy, delR)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eb82b3d-ffa2-4312-916f-3325a0089c6b",
   "metadata": {},
   "source": [
    "The mask is generated by setting all of the non-zero `hFac` points to 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d1dcfe0a-3641-43d7-99aa-88a48310eeda",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate the masks\n",
    "maskC = np.copy(hFacC)\n",
    "maskC[maskC>0] = 1\n",
    "\n",
    "maskS = np.copy(hFacS)\n",
    "maskS[maskS>0] = 1\n",
    "\n",
    "maskW = np.copy(hFacW)\n",
    "maskW[maskW>0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a37e0e64-13eb-4122-ae3c-0fead095fc9b",
   "metadata": {},
   "source": [
    "### Step 4: Prepare the grids for interpolation\n",
    "Just as in our initial condition notebook, we will read in all of the grid information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bfd5f5ec-1a41-4da6-81aa-9d121dfa023a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tile_list = [8,11]\n",
    "\n",
    "# determine the number of points in each set\n",
    "total_points = 0\n",
    "for tile_number in tile_list:\n",
    "    total_points += np.size(ecco_XC_tiles[tile_number])\n",
    "\n",
    "# make empty arrays to fill in\n",
    "ecco_XC_points = np.zeros((total_points, ))\n",
    "ecco_YC_points = np.zeros((total_points, ))\n",
    "ecco_maskC_points = np.zeros((np.size(ecco_RF_tiles[1]) , total_points))\n",
    "ecco_maskW_points = np.zeros((np.size(ecco_RF_tiles[1]) , total_points))\n",
    "ecco_maskS_points = np.zeros((np.size(ecco_RF_tiles[1]) , total_points))\n",
    "ecco_hFacW_points = np.zeros((np.size(ecco_RF_tiles[1]) , total_points))\n",
    "ecco_hFacS_points = np.zeros((np.size(ecco_RF_tiles[1]) , total_points))\n",
    "\n",
    "# loop through the tiles and fill in the XC, YC, and mask points for interpolation\n",
    "points_counted = 0\n",
    "for tile_number in tile_list:\n",
    "    tile_N = np.size(ecco_XC_tiles[tile_number])\n",
    "    \n",
    "    ecco_XC_points[points_counted:points_counted+tile_N] = ecco_XC_tiles[tile_number].ravel()\n",
    "    ecco_YC_points[points_counted:points_counted+tile_N] = ecco_YC_tiles[tile_number].ravel()\n",
    "    \n",
    "    for k in range(np.size(ecco_RF_tiles[tile_number])):\n",
    "        level_hFacC = ecco_hFacC_tiles[tile_number][k, :, :]\n",
    "        if tile_number<7:\n",
    "            level_hFacW = ecco_hFacW_tiles[tile_number][k, :, :]\n",
    "            level_hFacS = ecco_hFacS_tiles[tile_number][k, :, :]\n",
    "        else:\n",
    "            level_hFacS = ecco_hFacW_tiles[tile_number][k, :, :] # these are switched due to the \n",
    "            level_hFacW = ecco_hFacS_tiles[tile_number][k, :, :] # assumptions about velocity - see note below\n",
    "        ecco_hFacW_points[k, points_counted:points_counted+tile_N] = level_hFacW.ravel()\n",
    "        ecco_hFacS_points[k, points_counted:points_counted+tile_N] = level_hFacS.ravel()\n",
    "        level_maskC = np.copy(level_hFacC)\n",
    "        level_maskC[level_maskC>0] = 1\n",
    "        level_maskW = np.copy(level_hFacW)\n",
    "        level_maskW[level_maskW>0] = 1\n",
    "        level_maskS = np.copy(level_hFacS)\n",
    "        level_maskS[level_maskS>0] = 1\n",
    "        ecco_maskC_points[k, points_counted:points_counted+tile_N] = level_maskC.ravel()\n",
    "        ecco_maskW_points[k, points_counted:points_counted+tile_N] = level_maskW.ravel()\n",
    "        ecco_maskS_points[k, points_counted:points_counted+tile_N] = level_maskS.ravel()\n",
    "    \n",
    "    points_counted += tile_N\n",
    "\n",
    "# remove the points with positive longitude\n",
    "local_indices = ecco_XC_points<0\n",
    "ecco_maskC_points = ecco_maskC_points[:, local_indices]\n",
    "ecco_maskW_points = ecco_maskW_points[:, local_indices]\n",
    "ecco_maskS_points = ecco_maskS_points[:, local_indices]\n",
    "ecco_YC_points = ecco_YC_points[local_indices]\n",
    "ecco_XC_points = ecco_XC_points[local_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4462677-8079-45e5-9faf-d39452350218",
   "metadata": {},
   "source": [
    "Next, we'll write some scripts to read in the data fields and apply the modifications. In the initial condition approach, we just needed to do this one time since there was only one field. Here, we will write a function that we can use in a loop so we can do it over several years."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6963b363-9245-4f9b-9f40-2b7318286460",
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a file dictionary to loop over\n",
    "def read_annual_ECCO_field(data_folder, year):\n",
    "\n",
    "    file_prefix_dict = {'THETA':'THETA_'+str(year)+'.nc',\n",
    "                        'SALT':'SALT_'+str(year)+'.nc',\n",
    "                        'UVEL':'UVELMASS_'+str(year)+'.nc',\n",
    "                        'VVEL':'VVELMASS_'+str(year)+'.nc'}\n",
    "    variable_names = list(file_prefix_dict.keys())\n",
    "    \n",
    "    # make a list to hold all of the ECCO grids\n",
    "    init_grids = []\n",
    "    timesteps = 12 # data is monthly\n",
    "    \n",
    "    # loop through each variable to read in the grid\n",
    "    for variable_name in variable_names:\n",
    "        \n",
    "        if variable_name == 'ETAN':\n",
    "            ds = nc4.Dataset(os.path.join(data_folder,file_prefix_dict[variable_name]))\n",
    "            grid = ds.variables[variable_name][:,:,:,:]\n",
    "            ds.close()\n",
    "        elif 'VEL' in variable_name:\n",
    "            ds = nc4.Dataset(os.path.join(data_folder,'UVELMASS_'+str(year)+'.nc'))\n",
    "            u_grid = ds.variables['UVELMASS'][:,:,:,:,:]\n",
    "            ds.close()\n",
    "            ds = nc4.Dataset(os.path.join(data_folder,'VVELMASS_'+str(year)+'.nc'))\n",
    "            v_grid = ds.variables['VVELMASS'][:,:,:,:,:]\n",
    "            ds.close()\n",
    "        else:\n",
    "            ds = nc4.Dataset(os.path.join(data_folder,file_prefix_dict[variable_name]))\n",
    "            grid = ds.variables[variable_name][:,:,:,:,:]\n",
    "            ds.close()\n",
    "        \n",
    "        # create a grid of zeros to fill in\n",
    "        N = np.shape(grid)[-1]*np.shape(grid)[-2]\n",
    "        if variable_name == 'ETAN':\n",
    "            init_grid = np.zeros((timesteps, 1, N*len(tile_list)))\n",
    "        else:\n",
    "            init_grid = np.zeros((timesteps, np.size(ecco_RF_tiles[1]), N*len(tile_list)))\n",
    "    \n",
    "        # loop through the tiles\n",
    "        for t in range(timesteps):\n",
    "            points_counted = 0\n",
    "            for tile_number in tile_list:\n",
    "                if variable_name == 'ETAN':\n",
    "                    init_grid[t, points_counted:points_counted+N] = \\\n",
    "                         grid[t, tile_number-1, :, :].ravel()\n",
    "                elif 'VEL' in variable_name: # when using velocity, need to consider the tile rotations\n",
    "                    if variable_name == 'UVEL':\n",
    "                        if tile_number<7:\n",
    "                            for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                                init_grid[t, k,points_counted:points_counted+N] = \\\n",
    "                                     u_grid[t, k, tile_number-1, :, :].ravel()\n",
    "                        else:\n",
    "                            for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                                init_grid[t, k,points_counted:points_counted+N] = \\\n",
    "                                     v_grid[t, k, tile_number-1, :, :].ravel()\n",
    "                    if variable_name == 'VVEL':\n",
    "                        if tile_number<7:\n",
    "                            for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                                init_grid[t,k,points_counted:points_counted+N] = \\\n",
    "                                     v_grid[t, k, tile_number-1, :, :].ravel()\n",
    "                        else:\n",
    "                            for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                                init_grid[t,k,points_counted:points_counted+N] = \\\n",
    "                                     -1*u_grid[t, k, tile_number-1, :, :].ravel()\n",
    "                else:\n",
    "                    for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                        init_grid[t,k,points_counted:points_counted+N] = \\\n",
    "                         grid[t, k, tile_number-1, :, :].ravel()\n",
    "                points_counted += N\n",
    "    \n",
    "        # apply some corrections\n",
    "        if variable_name == 'UVEL':\n",
    "            for t in range(timesteps):\n",
    "                for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                    non_zero_indices = ecco_hFacW_points[k,:]!=0\n",
    "                    init_grid[t,k,non_zero_indices] = init_grid[t,k,non_zero_indices]/(ecco_hFacW_points[k,non_zero_indices])\n",
    "        if variable_name == 'VVEL':\n",
    "            for t in range(timesteps):\n",
    "                for k in range(np.size(ecco_RF_tiles[1])):\n",
    "                    non_zero_indices = ecco_hFacS_points[k,:]!=0\n",
    "                    init_grid[t,k,non_zero_indices] = init_grid[t,k,non_zero_indices]/(ecco_hFacS_points[k,non_zero_indices])\n",
    "    \n",
    "        # remove the points with positive longitudes\n",
    "        init_grid = init_grid[:,:,local_indices]\n",
    "        \n",
    "        init_grids.append(init_grid)\n",
    "\n",
    "    return(init_grids, variable_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8e32043-a3a3-49df-a724-de2be9f98708",
   "metadata": {},
   "source": [
    "### Step 5: Interpolate the Fields onto the Model Grid\n",
    "Next, we will interpolate the ECCO external fields onto the regional model domain. Just like the initial conditions, we will use the `horizontal` module from the `eccoseas` package to accomplish this interpolation.\n",
    "\n",
    "Before we begin, we need to define a boundary list - the list of open boundaries for our model. In this domain, the top, left, and bottom boundary are open, corresponding to the directions north, west, and south. The right side (i.e. the eastern side) is completely on land, and is not an open boundary). The list is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f6c081d0-77ac-4aba-8af7-baeb749a9a15",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the boundary list for the model\n",
    "boundary_list = ['north', 'west', 'south']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "328118fc-6296-4c7a-9ced-b523baba8545",
   "metadata": {},
   "source": [
    "Next, we'll carry on with the interpolation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8c1028da-5a5b-4662-b772-73dadd97bd2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ensure there is a location to store these files in the input directory\n",
    "if 'obcs' not in os.listdir(input_dir):\n",
    "    os.mkdir(os.path.join(input_dir,'obcs'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d0aae164-a3f8-470b-a973-7f7ddffdcef1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  - Generating boundary conditions in year 2007\n",
      "    - Reading in the ECCO Data...\n",
      "      - Working on the north boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "      - Working on the west boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "      - Working on the south boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "  - Generating boundary conditions in year 2008\n",
      "    - Reading in the ECCO Data...\n",
      "      - Working on the north boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "      - Working on the west boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "      - Working on the south boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "  - Generating boundary conditions in year 2009\n",
      "    - Reading in the ECCO Data...\n",
      "      - Working on the north boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "      - Working on the west boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n",
      "      - Working on the south boundary\n",
      "        - Interpolating the THETA grid\n",
      "        - Interpolating the SALT grid\n",
      "        - Interpolating the UVEL grid\n",
      "        - Interpolating the VVEL grid\n"
     ]
    }
   ],
   "source": [
    "# define the number of timesteps\n",
    "timesteps = 1 # for testing\n",
    "# timesteps = 12 # data is monthly, uncomment after testing\n",
    "\n",
    "\n",
    "for year in [2007, 2008, 2009]:\n",
    "    print('  - Generating boundary conditions in year '+str(year))\n",
    "\n",
    "    print('    - Reading in the ECCO Data...')\n",
    "    # read in the ECCO data for the year using the function above\n",
    "    init_grids, variable_names = read_annual_ECCO_field(data_folder, year)\n",
    "    \n",
    "    # loop through each boundary\n",
    "    for boundary in boundary_list:\n",
    "        print('      - Working on the '+boundary+' boundary')\n",
    "    \n",
    "        # loop through each variable and corresponding ECCO grid\n",
    "        for variable_name, init_grid in zip(variable_names, init_grids):\n",
    "\n",
    "            if variable_name == 'UVEL':\n",
    "                mask = maskW\n",
    "                ecco_mask_points = ecco_maskW_points\n",
    "            elif variable_name == 'VVEL':\n",
    "                mask = maskS\n",
    "                ecco_mask_points = ecco_maskS_points\n",
    "            else:\n",
    "                mask = maskC\n",
    "                ecco_mask_points = ecco_maskC_points\n",
    "        \n",
    "            if boundary == 'west':\n",
    "                boundary_XC = XC[:,:1]\n",
    "                boundary_YC = YC[:,:1]\n",
    "                boundary_mask = mask[:,:,:1]\n",
    "            elif boundary == 'east':\n",
    "                boundary_XC = XC[:,-1:]\n",
    "                boundary_YC = YC[:,-1:]\n",
    "                boundary_mask = mask[:,:,-1:]\n",
    "            elif boundary == 'north':\n",
    "                boundary_XC = XC[-1:,:]\n",
    "                boundary_YC = YC[-1:,:]\n",
    "                boundary_mask = mask[:,-1:,:]\n",
    "            elif boundary == 'south':\n",
    "                boundary_XC = XC[:1,:]\n",
    "                boundary_YC = YC[:1,:]\n",
    "                boundary_mask = mask[:,:1,:]\n",
    "            else:\n",
    "                raise ValueError('Boundary '+boundary+' not recognized')\n",
    "    \n",
    "            output_grid = np.zeros((timesteps, np.size(delR), np.size(boundary_XC)))\n",
    "        \n",
    "            # print a message to keep track of which variable we are working on\n",
    "            print('        - Interpolating the '+variable_name+' grid')\n",
    "    \n",
    "            for t in range(timesteps):\n",
    "                interpolated_grid = horizontal.downscale_3D_points(np.column_stack([ecco_XC_points, ecco_YC_points]),\n",
    "                                                                   init_grid[t,:,:], ecco_mask_points, \n",
    "                                                                   boundary_XC, boundary_YC, boundary_mask)\n",
    "                for k in range(len(delR)):\n",
    "                    output_grid[t,k,:] = interpolated_grid[k,:,:].ravel()\n",
    "        \n",
    "            # output the interpolated grid\n",
    "            output_file = os.path.join(input_dir,'obcs',variable_name+'_'+boundary+'_'+str(year))\n",
    "            output_grid.ravel('C').astype('>f4').tofile(output_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe30ee2-7b83-498d-813c-9b9ea152ed6f",
   "metadata": {},
   "source": [
    "### Step 6: Plotting the Boundary Fields\n",
    "Now that the fields have been generated, we will plot them to ensure they look as expected. First, generate some metadata for each one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e7ac447d-91d1-4a85-b4c3-12529580db54",
   "metadata": {},
   "outputs": [],
   "source": [
    "meta_dict = {'THETA':[6, 18, 'turbo', 'm'],\n",
    "            'SALT':[32, 35, 'viridis', 'm'],\n",
    "            'UVEL':[-0.1, 0.1, 'seismic', 'm'],\n",
    "            'VVEL':[-0.1, 0.1, 'seismic', 'm']}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c60e704-57ae-4d35-aca8-2dbc8ad5f84a",
   "metadata": {},
   "source": [
    "Then, create all of the subplots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bd252056-d8e7-4cce-a50d-43e20b50c301",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 24 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12,12))\n",
    "plot_year = 2008\n",
    "\n",
    "plot_counter = 0\n",
    "for i in range(len(variable_names)):\n",
    "    variable_name = variable_names[i]\n",
    "    \n",
    "    for boundary in boundary_list:\n",
    "        \n",
    "        boundary_grid = np.fromfile(os.path.join(input_dir,'obcs',variable_name+'_'+boundary+'_'+str(plot_year)),'>f4')\n",
    "    \n",
    "        if boundary in ['west','east']:\n",
    "            boundary_grid = boundary_grid.reshape((timesteps, np.shape(delR)[0],np.shape(XC)[0]))\n",
    "            boundary_grid = boundary_grid[0, :, :] # choose just the first timestep for plotting\n",
    "            if boundary=='west':\n",
    "                x = YC[:,1]\n",
    "            if boundary=='east':\n",
    "                x = YC[:,-1]\n",
    "        else:\n",
    "            boundary_grid = boundary_grid.reshape((timesteps, np.shape(delR)[0],np.shape(XC)[1]))\n",
    "            boundary_grid = boundary_grid[0, :, :] # choose just the first timestep for plotting\n",
    "            if boundary=='north':\n",
    "                x = XC[-1,:]\n",
    "            if boundary=='south':\n",
    "                x = XC[1,:]\n",
    "\n",
    "        plot_counter += 1\n",
    "        plt.subplot(len(variable_names),len(boundary_list),plot_counter)\n",
    "        C = plt.pcolormesh(x, np.cumsum(delR), boundary_grid,\n",
    "                           vmin=meta_dict[variable_names[i]][0],\n",
    "                           vmax=meta_dict[variable_names[i]][1],\n",
    "                           cmap=meta_dict[variable_names[i]][2])\n",
    "        plt.colorbar(C,fraction=0.26)\n",
    "        plt.gca().invert_yaxis()\n",
    "    \n",
    "        if plot_counter%3==1:\n",
    "            plt.ylabel(variable_name)\n",
    "        if plot_counter<4:\n",
    "            plt.title(boundary)\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c09ea7f2-2254-47f8-989b-04990088b89a",
   "metadata": {},
   "source": [
    "Looks good! Now, with the initial conditions, external forcing conditions, and boundary conditions we have all of the input binaries needed to run our model."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mitgcm",
   "language": "python",
   "name": "mitgcm"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}