diff --git a/datadownload.txt b/datadownload.txt
deleted file mode 100644
index c9c095d6..00000000
--- a/datadownload.txt
+++ /dev/null
@@ -1,48 +0,0 @@
-# # Script/notes to download data from CMEMS
-
-# https://data.marine.copernicus.eu/product/GLOBAL_ANALYSISFORECAST_PHY_001_024/download?dataset=cmems_mod_glo_phy-cur_anfc_0.083deg_PT6H-i_202211
-
-# 5 to -10 N/S
-# -170 to -80 W/E
-
-# All possible depths
-
-# Period?
-
-# files:
-# cmems_mod_glo_phy-cur_anfc_0.083deg_PT6H-i
-# cmems_mod_glo_phy-so_anfc_0.083deg_PT6H-i
-# cmems_mod_glo_phy-thetao_anfc_0.083deg_PT6H-i
-# cmems_mod_glo_phy_anfc_0.083deg_static
-
-# Copy MOTU command from CMEMS website, e.g.
-# python -m motuclient --motu https://nrt.cmems-du.eu/motu-web/Motu --service-id GLOBAL_ANALYSISFORECAST_PHY_001_024-TDS --product-id cmems_mod_glo_phy-cur_anfc_0.083deg_PT6H-i --longitude-min -160 --longitude-max -80 --latitude-min -10 --latitude-max 5 --date-min '2023-09-25 00:00:00' --date-max '2023-09-27 00:00:00' --depth-min 0.49402499198913574 --depth-max 5727.9169921875 --variable uo --variable vo --out-dir <OUTPUT_DIRECTORY> --out-name <OUTPUT_FILENAME> --user <USERNAME> --pwd <PASSWORD>
-
-# conda activate cmems  # environment with motuclient==1.8.4 installed
-
-# replace <OUTPUT_DIRECTORY> and <OUTPUT_FILENAME> with your desired output directory and filename
-# replace <USERNAME> and <PASSWORD> with your CMEMS credentials (mine are stored in /Users/0448257/Data/copernicus_credentials.txt)
-# replace " with ' in the date arguments (doesn't seem to be needed)
-
-# python -m motuclient --motu https://nrt.cmems-du.eu/motu-web/Motu --service-id GLOBAL_ANALYSISFORECAST_PHY_001_024-TDS --product-id cmems_mod_glo_phy-cur_anfc_0.083deg_PT6H-i --longitude-min -170 --longitude-max -75 --latitude-min -10 --latitude-max 5 --date-min '2023-11-19 00:00:00' --date-max '2023-11-22 00:00:00' --depth-min 0.49402499198913574 --depth-max 5727.9169921875 --variable uo --variable vo --out-name studentdata_UV_4.nc --user edaniels --pwd Pepertj3$
-# python -m motuclient --motu https://nrt.cmems-du.eu/motu-web/Motu --service-id GLOBAL_ANALYSISFORECAST_PHY_001_024-TDS --product-id cmems_mod_glo_phy-so_anfc_0.083deg_PT6H-i --longitude-min -170 --longitude-max -75 --latitude-min -10 --latitude-max 5 --date-min '2023-11-01 00:00:00' --date-max '2023-11-11 00:00:00' --depth-min 0.49402499198913574 --depth-max 5727.9169921875 --variable so --out-name studentdata_S.nc --user edaniels --pwd Pepertj3$
-# python -m motuclient --motu https://nrt.cmems-du.eu/motu-web/Motu --service-id GLOBAL_ANALYSISFORECAST_PHY_001_024-TDS --product-id cmems_mod_glo_phy-thetao_anfc_0.083deg_PT6H-i --longitude-min -170 --longitude-max -75 --latitude-min -10 --latitude-max 5 --date-min '2023-11-01 00:00:00' --date-max '2023-11-11 00:00:00' --depth-min 0.49402499198913574 --depth-max 5727.9169921875 --variable thetao --out-name studentdata_T.nc --user edaniels --pwd Pepertj3$
-
-# New files are available! uo, vo, so, thetao all in one file, hourly resolution?
-# cmems_mod_glo_phy_anfc_0.083deg_PT1H-m
-# test download:
-# python -m motuclient --motu https://nrt.cmems-du.eu/motu-web/Motu --service-id GLOBAL_ANALYSISFORECAST_PHY_001_024-TDS --product-id cmems_mod_glo_phy_anfc_0.083deg_PT1H-m --longitude-min -170 --longitude-max -75 --latitude-min -10 --latitude-max 5 --date-min "2023-10-11 23:30:00" --date-max "2023-10-12 23:30:00" --depth-min 0.49402499198913574 --depth-max 5727.9169921875 --variable so --variable thetao --variable uo --variable vo --out-name studentdata11-21.nc --user edaniels --pwd Pepertj3$
-# unfortunately only available at the surface, no depth yet...
-
-# Files can be downloaded in sizes up to 2048.0Mb so had to do several downloads
-# Op lorenz staat cdo geinstalleerd, dus kan je de files aan elkaar plakken met
-# also installed cdo to local cmems environment
-# cdo mergetime studentdata_UV_1.nc studentdata_UV_2.nc studentdata_UV_3.nc studentdata_UV.nc
-
-# TMP, motuclient will be deprecated by Feb 2024
-# python -m motuclient --motu https://nrt.cmems-du.eu/motu-web/Motu --service-id GLOBAL_ANALYSISFORECAST_PHY_001_024-TDS --product-id cmems_mod_glo_phy-cur_anfc_0.083deg_PT6H-i --longitude-min 152 --longitude-max 157 --latitude-min 36.5 --latitude-max 37 --date-min 2024-01-31T00:00:00 --date-max 2024-02-02T00:00:00 --depth-min 0.49402499198913574 --depth-max 155.85069274902344 --variable uo --variable vo --out-name JapanWindCurrents.nc --user edaniels --pwd Pepertj3$
-
-# NEW way to download https://help.marine.copernicus.eu/en/articles/7970514-copernicus-marine-toolbox-installation
-conda activate activate cmt_1.0
-
-https://help.marine.copernicus.eu/en/articles/7972861-copernicus-marine-toolbox-cli-subset
\ No newline at end of file
diff --git a/download_data.py b/download_data.py
index af2ee611..78022017 100644
--- a/download_data.py
+++ b/download_data.py
@@ -1,3 +1,6 @@
+# TODO move into package submodule data downloading or something
+
+
 # Install as in https://help.marine.copernicus.eu/en/articles/7970514-copernicus-marine-toolbox-installation
 # test student_input with VirtualshipConfiguration from virtualship.py (different conda env)
 # conda activate cmt_1.0
diff --git a/src/IPO/ElNinoLesson.ipynb b/lesson_material/ElNinoLesson.ipynb
similarity index 100%
rename from src/IPO/ElNinoLesson.ipynb
rename to lesson_material/ElNinoLesson.ipynb
diff --git a/Sail_the_ship.ipynb b/lesson_material/Sail_the_ship.ipynb
similarity index 100%
rename from Sail_the_ship.ipynb
rename to lesson_material/Sail_the_ship.ipynb
diff --git a/cruise_plan_info.ipynb b/lesson_material/cruise_plan_info.ipynb
similarity index 100%
rename from cruise_plan_info.ipynb
rename to lesson_material/cruise_plan_info.ipynb
diff --git a/student_input.json b/lesson_material/student_input.json
similarity index 100%
rename from student_input.json
rename to lesson_material/student_input.json
diff --git a/src/IPO/cruise_simulation.py b/src/IPO/cruise_simulation.py
deleted file mode 100755
index 30579024..00000000
--- a/src/IPO/cruise_simulation.py
+++ /dev/null
@@ -1,218 +0,0 @@
-#!/usr/bin/env python3
-# Script to simulate a cruise with CTD casts and ADCP data
-
-import numpy as np
-import pyproj
-from datetime import timedelta
-from shapely.geometry import Point, Polygon
-from parcels import Field, FieldSet, JITParticle, Variable, ParticleSet
-
-# set initial location  
-coords_input = [[-85, -2.5], [-95, -2.5], [-105, -2.5], [-115, -2.5], [-125, -2.5], [-120, -2], [-110, -2], [-100, -2], [-90, -2], [-80, -2]]
-#coords_input = [[-80, 2], [-90, 2], [-100, 2], [-110, 2], [-120, 2], [-125, 2.5], [-115, 2.5], [-105, 2.5], [-95, 2.5], [-85, 2.5]]
-
-# Load the CMEMS data (3 weeks for IPO)
-dataset_folder = "/nethome/0448257/Data"
-filenames = {
-    "U": f"{dataset_folder}/studentdata_UV.nc",
-    "V": f"{dataset_folder}/studentdata_UV.nc",
-    "S": f"{dataset_folder}/studentdata_S.nc",
-    "T": f"{dataset_folder}/studentdata_T.nc"}  
-variables = {'U': 'uo', 'V': 'vo', 'S':'so', 'T':'thetao'}
-dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}
-
-# create the fieldset and set interpolation methods
-fieldset = FieldSet.from_netcdf(filenames, variables, dimensions)
-fieldset.T.interp_method = "linear_invdist_land_tracer"
-fieldset.S.interp_method = "linear_invdist_land_tracer"
-
-# add bathymetry data to the fieldset for CTD cast
-bathymetry_file = f"{dataset_folder}/GLO-MFC_001_024_mask_bathy.nc"
-bathymetry_variables = ('bathymetry', 'deptho')
-bathymetry_dimensions = {'lon': 'longitude', 'lat': 'latitude'}
-bathymetry_field = Field.from_netcdf(bathymetry_file, bathymetry_variables, bathymetry_dimensions)
-fieldset.add_field(bathymetry_field)
-# read in data already
-fieldset.computeTimeChunk(0,1)
-
-### Determine ship course as intermediate points between CTD stations
-
-# Initialize lists to store intermediate points
-lons = []
-lats = []
-
-# Loop over station coordinates and calculate intermediate points along great circle path
-i = 0
-for i in (range(len(coords_input)-1)):
-    startlong = coords_input[i][0]
-    startlat = coords_input[i][1]
-    endlong = coords_input[i+1][0]
-    endlat = coords_input[i+1][1]
-
-    # calculate line string along path with segments every 5 min = 3.6*60*5 = 1080 m (or switch comment for 2 midpoints)
-    g = pyproj.Geod(ellps='WGS84')
-    r = g.inv_intermediate(startlong, startlat, endlong, endlat, del_s = 1080)
-    # r = g.inv_intermediate(startlong, startlat, endlong, endlat, initial_idx=0, return_back_azimuth=False, npts=3)
-    lons.append(r.lons) # stored as a list of arrays
-    lats.append(r.lats)
-
-# initial_idx will add begin point to each list (but not end point to avoid dubbling) so add final endpoint manually
-lons = np.append(np.hstack(lons), endlong)
-lats = np.append(np.hstack(lats), endlat)
-
-# check if input sample locations are within data availability area, only save if so
-poly = Polygon([(-170, 5), (-170, -10), (-75, -10), (-75, 5)])
-coords = []
-sample_lons = []
-sample_lats = []
-for coord in coords_input:
-    if poly.contains(Point(coord)):
-        coords.append(coord)
-for i in range(len(lons)):
-    if poly.contains(Point(lons[i], lats[i])):
-        sample_lons.append(lons[i])
-        sample_lats.append(lats[i])
-
-### Define particles and sampling functions 
-        
-# Create ADCP like particles to sample the ocean
-class ADCPParticle(JITParticle):
-    """Define a new particle class that does ADCP like measurements"""
-    U = Variable('U', dtype=np.float32, initial=0.0)
-    V = Variable('V', dtype=np.float32, initial=0.0)
-
-# define ADCP sampling function without conversion (because of A grid)
-def SampleVel(particle, fieldset, time):
-    particle.U, particle.V = fieldset.UV.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)
-    # particle.V = fieldset.V.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)
-
-# Create CTD like particles to sample the ocean
-class CTDParticle(JITParticle):
-    """Define a new particle class that does CTD like measurements"""
-    salinity = Variable("salinity", initial=np.nan)
-    temperature = Variable("temperature", initial=np.nan)
-    pressure = Variable("pressure", initial=np.nan)
-    raising = Variable("raising", dtype=np.int32, initial=0.0)
-
-# define function lowering and raising CTD
-def CTDcast(particle, fieldset, time):
-    seafloor = fieldset.bathymetry[time, particle.depth, particle.lat, particle.lon]
-    vertical_speed = 1.0  # sink and rise speed in m/s
-
-    if particle.raising == 0:
-        # Sinking with vertical_speed until near seafloor
-        particle_ddepth = vertical_speed * particle.dt
-        if particle.depth >= (seafloor - 20): 
-            particle.raising = 1
-
-    if particle.raising == 1:
-        # Rising with vertical_speed until depth is 2 m
-        if particle.depth > 2:
-            particle_ddepth = -vertical_speed * particle.dt  
-            if particle.depth + particle_ddepth <= 2:
-                # to break the loop ...
-                particle.state = 41
-                print("CTD cast finished")
-
-# define function sampling Salinity
-def SampleS(particle, fieldset, time):
-    particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]
-
-# define function sampling Temperature
-def SampleT(particle, fieldset, time):
-    particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]
-
-# define function sampling Pressure
-def SampleP(particle, fieldset, time):
-    particle.pressure = fieldset.P[time, particle.depth, particle.lat, particle.lon]
-
-### Run simulation
-
-# Create ADCP like particle with accurate depths, 1000 m every 20 m = 50 particles
-depthnum = 50
-# Initiate ADCP like particle set
-pset = ParticleSet.from_list(
-    fieldset=fieldset, pclass=ADCPParticle, lon=np.full(depthnum,sample_lons[0]), lat=np.full(depthnum,sample_lats[0]), depth=np.linspace(5, 1005, num=depthnum), time=0
-)
-# create a ParticleFile to store the ADCP output
-adcp_output_file = pset.ParticleFile(name="./results/sailship_adcp.zarr")
-adcp_dt = timedelta(minutes=5).total_seconds() # timestep of ADCP output, every 5 min == 1080 m (3.6*60*5 =m/s*s/min*min)
-
-# initialize CTD station number and time 
-total_time = timedelta(hours=0).total_seconds()
-ctd = 0
-ctd_dt = timedelta(seconds=10) # timestep of CTD output reflecting post-proces binning into 10m bins
-
-# run the model for the length of the sample_lons list
-for i in range(len(sample_lons)-1):
-
-    #vexecute the kernels to sample U and V
-    pset.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False) 
-    adcp_output_file.write(pset, time=pset[0].time)
-
-    # check if we are at a CTD station
-    if (sample_lons[i] - coords[ctd][0]) < 0.01 and (sample_lats[i] - coords[ctd][1]) < 0.01:
-        ctd += 1
-        
-        # release CTD particle
-        pset_CTD = ParticleSet(fieldset=fieldset, pclass=CTDParticle, lon=sample_lons[i], lat=sample_lats[i], depth=2, time=total_time)
-
-        # create a ParticleFile to store the CTD output
-        ctd_output_file = pset_CTD.ParticleFile(name=f"./results/CTD_test_{ctd}.zarr", outputdt=ctd_dt)
-
-        # record the temperature and salinity of the particle
-        pset_CTD.execute([SampleS, SampleT, CTDcast], runtime=timedelta(hours=4), dt=ctd_dt, output_file=ctd_output_file)
-        total_time = pset_CTD.time[0] #+ timedelta(hours=1).total_seconds() # add CTD time and 1 hour for deployment
-
-    # update the particle time and location
-    pset.lon_nextloop[:] = sample_lons[i+1]
-    pset.lat_nextloop[:] = sample_lats[i+1]
-    
-    total_time += adcp_dt
-    pset.time_nextloop[:] = total_time
-# write the final locations of the ADCP particles
-pset.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False)
-adcp_output_file.write_latest_locations(pset, time=total_time)
-
-### Post-processing
-import xarray as xr
-from scipy.ndimage import uniform_filter1d
-
-# rewrite CTD data to cvs
-for i in range(1, ctd+1):
-    
-    # Open output and read to x, y, z
-    ds = xr.open_zarr(f"./results/CTD_test_{i}.zarr")
-    x = ds["lon"][:].squeeze()
-    y = ds["lat"][:].squeeze()
-    z = ds["z"][:].squeeze()
-    time = ds["time"][:].squeeze()
-    T = ds["temperature"][:].squeeze()
-    S = ds["salinity"][:].squeeze()
-    ds.close()
-
-    # add some noise
-    random_walk = np.random.random()/10
-    z_norm = (z-np.min(z))/(np.max(z)-np.min(z))
-    t_norm = np.linspace(0, 1, num=len(time))
-    # dS = abs(np.append(0, np.diff(S))) # scale noise with gradient
-    # for j in range(5, 0, -1):
-    #     dS[dS<1*10**-j] = 0.5-j/10
-    # add smoothed random noise scaled with depth (and OPTIONAL with gradient for S) 
-    # and random (reversed) diversion from initial through time scaled with depth 
-    S = S + uniform_filter1d(
-        np.random.random(S.shape)/5*(1-z_norm) + 
-        random_walk*(np.max(S).values - np.min(S).values)*(1-z_norm)*t_norm/10, 
-        max(int(len(time)/40), 1))
-    T = T + uniform_filter1d(
-        np.random.random(T.shape)*5*(1-z_norm) - 
-        random_walk/2*(np.max(T).values - np.min(T).values)*(1-z_norm)*t_norm/10, 
-        max(int(len(time)/20), 1))
-
-    # reshaping data to export to csv
-    header = f"'pressure [hPa]','temperature [degC]', 'salinity [g kg-1]'"
-    data = np.column_stack([(z/10), T, S])
-    new_line = '\n'
-    np.savetxt(f"./results/CTD_station_{i}.csv", data, fmt="%.4f", header=header, delimiter=',', 
-               comments=f'{x.attrs}{new_line}{x[0].values}{new_line}{y.attrs}{new_line}{y[0].values}{new_line}start time: {time[0].values}{new_line}end time: {time[-1].values}{new_line}')
-
diff --git a/src/IPO/post_process.py b/src/IPO/post_process.py
deleted file mode 100644
index a47ab123..00000000
--- a/src/IPO/post_process.py
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-# Post proces .results folder created by cruise_simulation.py
-
-### Post-processing
-import xarray as xr
-import numpy as np
-from scipy.ndimage import uniform_filter1d
-
-# rewrite CTD data to cvs
-ctd = 9
-for i in range(1, ctd+1):
-    
-    # Open output and read to x, y, z
-    ds = xr.open_zarr(f"./results/CTD_test_{i}.zarr")
-    x = ds["lon"][:].squeeze()
-    y = ds["lat"][:].squeeze()
-    z = ds["z"][:].squeeze()
-    time = ds["time"][:].squeeze()
-    T = ds["temperature"][:].squeeze()
-    S = ds["salinity"][:].squeeze()
-    ds.close()
-
-    # add some noise
-    random_walk = np.random.random()/10
-    z_norm = (z-np.min(z))/(np.max(z)-np.min(z))
-    t_norm = np.linspace(0, 1, num=len(time))
-    # dS = abs(np.append(0, np.diff(S))) # scale noise with gradient
-    # for j in range(5, 0, -1):
-    #     dS[dS<1*10**-j] = 0.5-j/10
-    # add smoothed random noise scaled with depth (and OPTIONAL with gradient for S) 
-    # and random (reversed) diversion from initial through time scaled with depth 
-    S = S + uniform_filter1d(
-        np.random.random(S.shape)/5*(1-z_norm) + 
-        random_walk*(np.max(S).values - np.min(S).values)*(1-z_norm)*t_norm/10, 
-        max(int(len(time)/40), 1))
-    T = T + uniform_filter1d(
-        np.random.random(T.shape)*5*(1-z_norm) - 
-        random_walk/2*(np.max(T).values - np.min(T).values)*(1-z_norm)*t_norm/10, 
-        max(int(len(time)/20), 1))
-
-    # reshaping data to export to csv
-    header = f"'pressure [hPa]','temperature [degC]', 'salinity [g kg-1]'"
-    data = np.column_stack([(z/10), T, S])
-    new_line = '\n'
-    np.savetxt(f"./results/CTD_station_{i}.csv", data, fmt="%.4f", header=header, delimiter=',', 
-               comments=f'{x.attrs}{new_line}{x[0].values}{new_line}{y.attrs}{new_line}{y[0].values}{new_line}start time: {time[0].values}{new_line}end time: {time[-1].values}{new_line}')
-
diff --git a/src/IPO/submit.sh b/src/IPO/submit.sh
deleted file mode 100644
index 5626f4a7..00000000
--- a/src/IPO/submit.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash -l
-#
-#SBATCH -J VSC              # the name of your job   
-#SBATCH -p normal            # request the short partition, job takes less than 3 hours  
-#SBATCH -t 5:00:00          # time in hh:mm:ss you want to reserve for the job
-#SBATCH -n 1                # the number of cores you want to use for the job, SLURM automatically determines how many nodes are needed
-#SBATCH -o log%j.o        # the name of the file where the standard output will be written to. %j will be the jobid determined by SLURM
-#SBATCH -e log%j.e        # the name of the file where potential errors will be written to. %j will be the jobid determined by SLURM
-
-conda activate parcels
-srun ./cruise_simulation.py           
diff --git a/src/OLD/adcpCMEMS.ipynb b/src/OLD/adcpCMEMS.ipynb
deleted file mode 100644
index b6d3f0ec..00000000
--- a/src/OLD/adcpCMEMS.ipynb
+++ /dev/null
@@ -1,359 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Local ADCP Particle test with CMEMS data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datetime import timedelta\n",
-    "import numpy as np\n",
-    "import math\n",
-    "\n",
-    "from parcels import (\n",
-    "    ErrorCode,\n",
-    "    FieldSet,\n",
-    "    JITParticle,\n",
-    "    ParticleSet,\n",
-    "    Variable,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# # Example for function from https://github.com/OceanParcels/parcels/blob/0f396703be2804f8eaf12b10d1ec1c978af812b3/performance/example_performanceProfiling.py#L76\n",
-    "# import os\n",
-    "# from glob import glob\n",
-    "\n",
-    "# def set_cmems_fieldset(cs, deferLoadFlag=True, periodicFlag=False):\n",
-    "#     ddir_head = \"/Users/0448257/Data\"\n",
-    "#     ddir = os.path.join(ddir_head, \"CMEMS/\")\n",
-    "#     files = sorted(glob(ddir+\"glo12_rg_1d-m_2021010*.nc\"))\n",
-    "#     variables = {'U': 'uo', 'V': 'vo'}\n",
-    "#     dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time'}\n",
-    "\n",
-    "#     if cs not in ['auto', False]:\n",
-    "#         # cs = (1, cs, cs) # == OLD initialization as tuple. Advised to rather use a dictionary. ==#\n",
-    "#         cs = {dimensions['time']: 1, dimensions['lon']: cs, dimensions['lat']: cs}\n",
-    "#     if periodicFlag:\n",
-    "#         return FieldSet.from_netcdf(files, variables, dimensions, time_periodic=timedelta(days=30), deferred_load=deferLoadFlag, field_chunksize=cs)\n",
-    "#     else:\n",
-    "#         return FieldSet.from_netcdf(files, variables, dimensions, allow_time_extrapolation=True, deferred_load=deferLoadFlag, field_chunksize=cs)\n",
-    "\n",
-    "# fieldset = set_cmems_fieldset(False)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Read sample input data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.494025\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Load the CMEMS data (3 days manually downloaded)\n",
-    "example_dataset_folder = \"../Data\"\n",
-    "filenames = {\n",
-    "    \"U\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"V\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"S\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-so_hcst_R20210113.nc\",\n",
-    "    \"T\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-thetao_hcst_R20210113.nc\",\n",
-    "}\n",
-    "variables = {'U': 'uo', 'V': 'vo', 'S':'so', 'T':'thetao'}\n",
-    "dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}\n",
-    "fieldset = FieldSet.from_netcdf(filenames, variables, dimensions, time_periodic=timedelta(days=3))\n",
-    "\n",
-    "# uppermost layer in the hydrodynamic data\n",
-    "fieldset.mindepth = fieldset.U.depth[0]\n",
-    "print(fieldset.mindepth)\n",
-    "\n",
-    "# set initial location\n",
-    "ini_lat = -31\n",
-    "ini_lon = 32"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create particles and initalize"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Compiled ArraySampleParticleInitZeroSampleS ==> /tmp/parcels-382783/lib45ac30e829f5354904253e0c9bfec45f_0.so\n",
-      "WARNING: dt or runtime are zero, or endtime is equal to Particle.time. The kernels will be executed once, without incrementing time\n",
-      "INFO: Compiled ArraySampleParticleInitZeroSampleT ==> /tmp/parcels-382783/lib274d8ae72420a16131edca44f12f7cf2_0.so\n"
-     ]
-    },
-    {
-     "ename": "TypeError",
-     "evalue": "ParticleSetSOA.Kernel() got an unexpected keyword argument 'dt'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[4], line 35\u001b[0m\n\u001b[1;32m     33\u001b[0m pset\u001b[39m.\u001b[39mexecute(Sample_S_kernel, dt\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n\u001b[1;32m     34\u001b[0m pset\u001b[39m.\u001b[39mexecute(Sample_T_kernel, dt\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m)\n\u001b[0;32m---> 35\u001b[0m pset\u001b[39m.\u001b[39;49mKernel(SampleVel_kernel, dt\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m)\n",
-      "\u001b[0;31mTypeError\u001b[0m: ParticleSetSOA.Kernel() got an unexpected keyword argument 'dt'"
-     ]
-    }
-   ],
-   "source": [
-    "# Create and initialize Variable particles to sample the ocean\n",
-    "class SampleParticleInitZero(JITParticle):\n",
-    "    \"\"\"Define a new particle class with Variables init 0\"\"\"\n",
-    "    salinity = Variable(\"salinity\", initial=0)\n",
-    "    temperature = Variable(\"temperature\", initial=0)\n",
-    "    U = Variable('U', dtype=np.float32, initial=np.nan)\n",
-    "    V = Variable('V', dtype=np.float32, initial=np.nan)\n",
-    "\n",
-    "# define function sampling Salinity \n",
-    "def SampleS(particle, fieldset, time):\n",
-    "    particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling Temperature \n",
-    "def SampleT(particle, fieldset, time):\n",
-    "    particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling u and v as in https://docs.oceanparcels.org/en/latest/examples/tutorial_sampling.html\n",
-    "def SampleVel_correct(particle, fieldset, time):\n",
-    "    particle.U, particle.V = fieldset.UV[time, particle.depth, particle.lat, particle.lon, particle]\n",
-    "\n",
-    "# Attempt for ADCP like particle TODO accurate depths \n",
-    "depthnum = 30\n",
-    "# Initiate ADCP like particle set \n",
-    "pset = ParticleSet.from_list(\n",
-    "    fieldset=fieldset, pclass=SampleParticleInitZero, lon=np.full(depthnum,ini_lon), lat=np.full(depthnum,ini_lat), depth=np.linspace(5, 1000, num=depthnum)\n",
-    ")\n",
-    "\n",
-    "Sample_S_kernel = pset.Kernel(SampleS)  # Casting the SampleS function to a kernel.\n",
-    "Sample_T_kernel = pset.Kernel(SampleT)  # similar for temperature\n",
-    "SampleVel_kernel = pset.Kernel(SampleVel_correct)  # Casting the function to a kernel.\n",
-    "\n",
-    "# only execute the sampling kernels to record the init temp of the particles\n",
-    "pset.execute(Sample_S_kernel, dt=0)\n",
-    "pset.execute(Sample_T_kernel, dt=0)\n",
-    "pset.execute(SampleVel_kernel, dt=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Determine ship course and add as kernel "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# change advection to ship movement\n",
-    "# Cruising speed Pelagia (and Anna Weber) is 9 knp https://www.nioz.nl/application/files/3614/9744/8746/Pelagia_Technical_specifications-2016.pdf\n",
-    "# survey speed nog iets lager? Zoals bij https://schmidtocean.org/rv-falkor/ship-specifications/\n",
-    "# 7 knp = 13 km/h = 3.6 m/s\n",
-    "\n",
-    "def ShipVel(particle, fieldset, time):\n",
-    "    speed = 3.6\n",
-    "    target_lat = -50\n",
-    "    target_lon = 20\n",
-    "    # determine ship direction\n",
-    "    heading = math.sqrt((target_lat - particle.lat)**2 + (target_lon - particle.lon)**2)\n",
-    "    # calculate e/w and n/s speed (m/s)\n",
-    "    lat_add = (target_lat - particle.lat)/(heading/speed)\n",
-    "    lon_add = (target_lon - particle.lon)/(heading/speed)\n",
-    "    # convert to lat/lon\n",
-    "    lat_add_deg = lat_add / 1.11e5\n",
-    "    lon_add_deg = lon_add / (1.11e5 * math.cos(particle.lat * math.pi / 180))\n",
-    "    # add to particle position\n",
-    "    particle.lat += lat_add_deg * particle.dt\n",
-    "    particle.lon += lon_add_deg * particle.dt\n",
-    "\n",
-    "# cast the ships velocity function to a kernel object\n",
-    "ShipVel_kernel = pset.Kernel(ShipVel)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Run simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Compiled ArraySampleParticleInitZeroShipVelSampleSSampleTSampleVel_correct ==> /tmp/parcels-382783/lib057c17877b184be2fe6a44f0844c423d_0.so\n",
-      "INFO: Output files are stored in ADCPtest.zarr.\n",
-      "100%|██████████| 86400.0/86400.0 [02:32<00:00, 566.27it/s] \n"
-     ]
-    }
-   ],
-   "source": [
-    "# set output file name and dt\n",
-    "output_file = pset.ParticleFile(\n",
-    "    name=\"ADCPtest.zarr\",  # the file name\n",
-    "    outputdt=timedelta(hours=1),  # the time step of the outputs\n",
-    ")\n",
-    "\n",
-    "# Choose which kernels to use\n",
-    "kernels = ShipVel_kernel + Sample_S_kernel + Sample_T_kernel + SampleVel_kernel\n",
-    "\n",
-    "# Execute code and save to file \n",
-    "pset.execute(\n",
-    "    kernels, \n",
-    "    runtime=timedelta(days=1),  # the total length of the run\n",
-    "    dt=timedelta(minutes=60),  # the timestep of the kernel\n",
-    "    output_file=output_file,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Do some plotting to check output"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1300x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import xarray as xr\n",
-    "\n",
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_zarr(\"ADCPtest.zarr\")\n",
-    "x = ds[\"lon\"][:].squeeze()\n",
-    "y = ds[\"lat\"][:].squeeze()\n",
-    "z = ds[\"z\"][:].squeeze()\n",
-    "U = ds[\"U\"][:].squeeze()\n",
-    "V = ds[\"V\"][:].squeeze()\n",
-    "S = ds[\"salinity\"][:].squeeze()\n",
-    "T = ds[\"temperature\"][:].squeeze()\n",
-    "ds.close()\n",
-    "\n",
-    "# Plot Particle depth\n",
-    "fig = plt.figure(figsize=(13, 10))\n",
-    "ax = plt.axes(projection=\"3d\")\n",
-    "cb = ax.scatter(x, y, z, c=U, s=20, marker=\"o\")\n",
-    "ax.set_title('Zonal velocity along ship trajectory', size=15)\n",
-    "ax.set_xlabel(\"Longitude\")\n",
-    "ax.set_ylabel(\"Latitude\")\n",
-    "ax.set_zlabel(\"Depth (m)\")\n",
-    "ax.set_zlim(np.max(z), 0)\n",
-    "plt.colorbar(cb, shrink = 0.7)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<xarray.Dataset>\n",
-      "Dimensions:      (trajectory: 10, obs: 73)\n",
-      "Coordinates:\n",
-      "  * obs          (obs) int32 0 1 2 3 4 5 6 7 8 9 ... 64 65 66 67 68 69 70 71 72\n",
-      "  * trajectory   (trajectory) int64 80 81 82 83 84 85 86 87 88 89\n",
-      "Data variables:\n",
-      "    U            (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    V            (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    lat          (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    lon          (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    salinity     (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    temperature  (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    time         (trajectory, obs) datetime64[ns] dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "    z            (trajectory, obs) float32 dask.array<chunksize=(10, 1), meta=np.ndarray>\n",
-      "Attributes:\n",
-      "    Conventions:            CF-1.6/CF-1.7\n",
-      "    feature_type:           trajectory\n",
-      "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-      "    parcels_mesh:           spherical\n",
-      "    parcels_version:        2.4.2\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(ds)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py3_parcels",
-   "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.11.4"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/src/OLD/adcp_ctdCMEMS.ipynb b/src/OLD/adcp_ctdCMEMS.ipynb
deleted file mode 100644
index a7e60e35..00000000
--- a/src/OLD/adcp_ctdCMEMS.ipynb
+++ /dev/null
@@ -1,558 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Combined ADCP and CTD particle test with CMEMS data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Read sample input data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datetime import timedelta\n",
-    "import numpy as np\n",
-    "import math\n",
-    "\n",
-    "from parcels import (\n",
-    "    AdvectionRK4,\n",
-    "    ErrorCode,\n",
-    "    Field,\n",
-    "    FieldSet,\n",
-    "    JITParticle,\n",
-    "    ScipyParticle,\n",
-    "    ParticleSet,\n",
-    "    Variable,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load the CMEMS data (3 days manually downloaded)\n",
-    "example_dataset_folder = \"../Data\"\n",
-    "filenames = {\n",
-    "    \"U\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"Usample\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"V\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"Vsample\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"S\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-so_hcst_R20210113.nc\",\n",
-    "    \"T\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-thetao_hcst_R20210113.nc\"}\n",
-    "variables = {'U': 'uo', 'Usample': 'uo', 'V': 'vo', 'Vsample': 'vo', 'S':'so', 'T':'thetao'}\n",
-    "dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}\n",
-    "\n",
-    "# create the fieldset and set interpolation methods\n",
-    "fieldset = FieldSet.from_netcdf(filenames, variables, dimensions, time_periodic=timedelta(days=3))\n",
-    "fieldset.T.interp_method = \"linear_invdist_land_tracer\"\n",
-    "fieldset.S.interp_method = \"linear_invdist_land_tracer\"\n",
-    "\n",
-    "# # determine top and bottom layer in the hydrodynamic data\n",
-    "# fieldset.mindepth = math.ceil(fieldset.U.depth[0])\n",
-    "# fieldset.maxdepth = math.floor(fieldset.U.depth[-1])\n",
-    "\n",
-    "# add bathymetry data to the fieldset for CTD cast\n",
-    "bathymetry_file = f\"{example_dataset_folder}/GLO-MFC_001_024_mask_bathy.nc\"\n",
-    "bathymetry_variables = ('bathymetry', 'deptho')\n",
-    "bathymetry_dimensions = {'lon': 'longitude', 'lat': 'latitude'}\n",
-    "bathymetry_field = Field.from_netcdf(bathymetry_file, bathymetry_variables, bathymetry_dimensions)\n",
-    "fieldset.add_field(bathymetry_field) \n",
-    "fieldset.add_constant('z_start',0.5)\n",
-    "\n",
-    "# set initial location\n",
-    "coords = [[-94.394531, -4.390229], [-106.523437, -0.175781], [-124.541016, -6.053161], [-140.537109, -0.527336]]\n",
-    "loc = 1\n",
-    "ini_lat = coords[loc][1]\n",
-    "ini_lon = coords[loc][0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### Determine ship course and add as kernel "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# change advection to ship movement\n",
-    "# Cruising speed Pelagia (and Anna Weber) is 9 knp https://www.nioz.nl/application/files/3614/9744/8746/Pelagia_Technical_specifications-2016.pdf\n",
-    "# survey speed nog iets lager? Zoals bij https://schmidtocean.org/rv-falkor/ship-specifications/\n",
-    "# 7 knp = 13 km/h = 3.6 m/s\n",
-    "\n",
-    "# TODO add coords to function\n",
-    "def ShipVel(particle, fieldset, time):\n",
-    "    # loc = 1\n",
-    "    speed = 3.6\n",
-    "    target_lat = -32 #coords[loc][0]\n",
-    "    target_lon = 49 #coords[loc][1]\n",
-    "    # # slow down when close to target\n",
-    "    # if target_lat - particle.lat < 3.6*3600/1.11e5 or target_lon - particle.lon < 3.6*3600/(1.11e5 * math.cos(particle.lat * math.pi / 180)):\n",
-    "    #     speed = speed/4\n",
-    "    # determine ship direction\n",
-    "    heading = math.sqrt((target_lat - particle.lat)**2 + (target_lon - particle.lon)**2)\n",
-    "    # calculate e/w and n/s speed (m/s)\n",
-    "    lat_add = (target_lat - particle.lat)/(heading/speed)\n",
-    "    lon_add = (target_lon - particle.lon)/(heading/speed)\n",
-    "    # convert to lat/lon\n",
-    "    lat_add_deg = lat_add / 1.11e5\n",
-    "    lon_add_deg = lon_add / (1.11e5 * math.cos(particle.lat * math.pi / 180))\n",
-    "    # add to particle position\n",
-    "    particle.lat += lat_add_deg * particle.dt\n",
-    "    particle.lon += lon_add_deg * particle.dt\n",
-    "    # update loc if close to target TODO target reached\n",
-    "    # if target_lat - particle.lat < 3.6*3600/1.11e5 or target_lon - particle.lon < 3.6*3600/(1.11e5 * math.cos(particle.lat * math.pi / 180)):\n",
-    "    #     loc += 1\n",
-    "    #     speed = 3.6"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Define particles and sampling functions "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create and initialize Variable particles to sample the ocean\n",
-    "class ADCPParticle(JITParticle):\n",
-    "    \"\"\"Define a new particle class that does ADCP like measurements\"\"\"\n",
-    "    U = Variable('U', dtype=np.float32, initial=0.0)\n",
-    "    V = Variable('V', dtype=np.float32, initial=0.0)\n",
-    "\n",
-    "# # define function sampling u and v as in https://docs.oceanparcels.org/en/latest/examples/tutorial_sampling.html\n",
-    "# def SampleVel_correct(particle, fieldset, time):\n",
-    "#     # Attention: samples particle velocity in units of the mesh (deg/s or m/s)\n",
-    "#     particle.U, particle.V = fieldset.UV[time, particle.depth, particle.lat, particle.lon, particle]\n",
-    "\n",
-    "# define sampling function from Usample and Vsample (because of A grid)\n",
-    "def SampleVel(particle, fieldset, time):\n",
-    "    particle.U = fieldset.Usample[time, particle.depth, particle.lat, particle.lon]\n",
-    "    particle.V = fieldset.Vsample[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# Create and initialize Variable particles to sample the ocean\n",
-    "class CTDParticle(JITParticle):\n",
-    "    \"\"\"Define a new particle class that does CTD like measurements\"\"\" \n",
-    "    salinity = Variable(\"salinity\", initial=np.nan)\n",
-    "    temperature = Variable(\"temperature\", initial=np.nan)\n",
-    "    raising = Variable(\"raising\", dtype=np.int32, initial=0.0)\n",
-    "\n",
-    "# define function lowering and raising CTD\n",
-    "def CTDcast(particle, fieldset, time):\n",
-    "    seafloor = fieldset.bathymetry[time, particle.depth, particle.lat,particle.lon]\n",
-    "    vertical_speed = 1.0  # sink and rise speed in m/s\n",
-    "\n",
-    "    if particle.raising == 0:\n",
-    "        # Sinking with vertical_speed until depth is smaller than seafloor\n",
-    "        particle.depth += vertical_speed * particle.dt\n",
-    "        if particle.depth >= seafloor:\n",
-    "            particle.raising = 1\n",
-    "\n",
-    "    elif particle.raising == 1:\n",
-    "        # Rising with vertical_speed until depth is 0.5 m\n",
-    "        while particle.depth > 1.5:\n",
-    "            particle.depth -= vertical_speed * particle.dt\n",
-    "            if particle.depth <= 1.5:\n",
-    "                print(\"CTD cast finished\")\n",
-    "                break\n",
-    "\n",
-    "# define function sampling Salinity \n",
-    "def SampleS(particle, fieldset, time):\n",
-    "    particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling Temperature \n",
-    "def SampleT(particle, fieldset, time):\n",
-    "    particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create a particle set and choose kernels"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# ADCP like particle TODO accurate depths \n",
-    "depthnum = 5\n",
-    "# Initiate ADCP like particle set \n",
-    "pset = ParticleSet.from_list(\n",
-    "    fieldset=fieldset, pclass=ADCPParticle, lon=np.full(depthnum,ini_lon), lat=np.full(depthnum,ini_lat), depth=np.linspace(5, 1000, num=depthnum)\n",
-    ")\n",
-    "\n",
-    "# Casting the ADCP sample function to a kernel\n",
-    "# SampleVel_kernel = pset.Kernel(SampleVel_correct)  \n",
-    "SampleVel_kernel = pset.Kernel(SampleVel)  \n",
-    "\n",
-    "# Cast the ships velocity function to a kernel object\n",
-    "ShipVel_kernel = pset.Kernel(ShipVel)\n",
-    "\n",
-    "# Choose which kernels to use\n",
-    "kernels = SampleVel_kernel + ShipVel_kernel "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Run simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Compiled ArrayCTDParticleSampleSSampleTCTDcast ==> /tmp/parcels-382783/lib04c095da969e206ae079d9f759b9dab8_0.so\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CTD time!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Compiled ArrayCTDParticleSampleSSampleTCTDcast ==> /tmp/parcels-382783/lib7d7b341c638368966a66052fef88a67a_0.so\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CTD time!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Compiled ArrayCTDParticleSampleSSampleTCTDcast ==> /tmp/parcels-382783/lib805b3b4194b363c3477f9afc8b5c61e2_0.so\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CTD cast finished\n",
-      "CTD cast finished\n"
-     ]
-    },
-    {
-     "ename": "ThroughSurfaceError",
-     "evalue": "0\nParticle P[35](lon=-102.290871, lat=-1.041822, depth=-9.500000, salinity=34.711002, temperature=22.843367, raising=1.000000, time=46630.000000)\nTime: 2021-01-02T00:57:10.000000000\ntimestep dt: 10.0\nThrough-surface sampling by particle at (-102.2908706665039, -1.041822075843811, -9.5)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mThroughSurfaceError\u001b[0m                       Traceback (most recent call last)",
-      "\u001b[1;32m/nethome/0448257/Virtual_ship_classroom/adcp_ctdCMEMS.ipynb Cell 14\u001b[0m line \u001b[0;36m5\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcp_ctdCMEMS.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=49'>50</a>\u001b[0m CTD_kernels \u001b[39m=\u001b[39m Sample_S_kernel \u001b[39m+\u001b[39m Sample_T_kernel \u001b[39m+\u001b[39m Cast_CTD_kernel\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcp_ctdCMEMS.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=51'>52</a>\u001b[0m \u001b[39m# record the temperature and salinity of the particles\u001b[39;00m\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcp_ctdCMEMS.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=52'>53</a>\u001b[0m pset_CTD\u001b[39m.\u001b[39;49mexecute(CTD_kernels, runtime\u001b[39m=\u001b[39;49moutputdt, dt\u001b[39m=\u001b[39;49mtimedelta(seconds\u001b[39m=\u001b[39;49m\u001b[39m10\u001b[39;49m))\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcp_ctdCMEMS.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=54'>55</a>\u001b[0m \u001b[39m# write the CTD particles to the output file\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcp_ctdCMEMS.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=55'>56</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mCTD time!\u001b[39m\u001b[39m\"\u001b[39m)\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/particleset/baseparticleset.py:548\u001b[0m, in \u001b[0;36mBaseParticleSet.execute\u001b[0;34m(self, pyfunc, pyfunc_inter, endtime, runtime, dt, moviedt, recovery, output_file, movie_background_field, verbose_progress, postIterationCallbacks, callbackdt)\u001b[0m\n\u001b[1;32m    546\u001b[0m \u001b[39m# If we don't perform interaction, only execute the normal kernel efficiently.\u001b[39;00m\n\u001b[1;32m    547\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minteraction_kernel \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 548\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mkernel\u001b[39m.\u001b[39;49mexecute(\u001b[39mself\u001b[39;49m, endtime\u001b[39m=\u001b[39;49mnext_time, dt\u001b[39m=\u001b[39;49mdt, recovery\u001b[39m=\u001b[39;49mrecovery, output_file\u001b[39m=\u001b[39;49moutput_file,\n\u001b[1;32m    549\u001b[0m                         execute_once\u001b[39m=\u001b[39;49mexecute_once)\n\u001b[1;32m    550\u001b[0m \u001b[39m# Interaction: interleave the interaction and non-interaction kernel for each time step.\u001b[39;00m\n\u001b[1;32m    551\u001b[0m \u001b[39m# E.g. Inter -> Normal -> Inter -> Normal if endtime-time == 2*dt\u001b[39;00m\n\u001b[1;32m    552\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    553\u001b[0m     cur_time \u001b[39m=\u001b[39m time\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/kernel/kernelsoa.py:213\u001b[0m, in \u001b[0;36mKernelSOA.execute\u001b[0;34m(self, pset, endtime, dt, recovery, output_file, execute_once)\u001b[0m\n\u001b[1;32m    211\u001b[0m recovery_kernel \u001b[39m=\u001b[39m recovery_map[p\u001b[39m.\u001b[39mstate]\n\u001b[1;32m    212\u001b[0m p\u001b[39m.\u001b[39mset_state(StateCode\u001b[39m.\u001b[39mSuccess)\n\u001b[0;32m--> 213\u001b[0m recovery_kernel(p, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfieldset, p\u001b[39m.\u001b[39;49mtime)\n\u001b[1;32m    214\u001b[0m \u001b[39mif\u001b[39;00m p\u001b[39m.\u001b[39misComputed():\n\u001b[1;32m    215\u001b[0m     p\u001b[39m.\u001b[39mreset_state()\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/tools/statuscodes.py:193\u001b[0m, in \u001b[0;36mrecovery_kernel_through_surface\u001b[0;34m(particle, fieldset, time)\u001b[0m\n\u001b[1;32m    189\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Default sampling error kernel that throws OutOfBoundsError.\"\"\"\u001b[39;00m\n\u001b[1;32m    190\u001b[0m \u001b[39mif\u001b[39;00m particle\u001b[39m.\u001b[39mexception \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    191\u001b[0m     \u001b[39m# TODO: JIT does not yet provide the context that created\u001b[39;00m\n\u001b[1;32m    192\u001b[0m     \u001b[39m# the exception. We need to pass that info back from C.\u001b[39;00m\n\u001b[0;32m--> 193\u001b[0m     \u001b[39mraise\u001b[39;00m ThroughSurfaceError(particle, fieldset)\n\u001b[1;32m    194\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    195\u001b[0m     error \u001b[39m=\u001b[39m particle\u001b[39m.\u001b[39mexception\n",
-      "\u001b[0;31mThroughSurfaceError\u001b[0m: 0\nParticle P[35](lon=-102.290871, lat=-1.041822, depth=-9.500000, salinity=34.711002, temperature=22.843367, raising=1.000000, time=46630.000000)\nTime: 2021-01-02T00:57:10.000000000\ntimestep dt: 10.0\nThrough-surface sampling by particle at (-102.2908706665039, -1.041822075843811, -9.5)"
-     ]
-    }
-   ],
-   "source": [
-    "# write the particle data every hour\n",
-    "outputdt = timedelta(hours=1).total_seconds()\n",
-    "\n",
-    "# release CTD every 6 hours\n",
-    "repeatdt = timedelta(hours=6).total_seconds()\n",
-    "\n",
-    "# run the model for 24 hours\n",
-    "runtime = timedelta(hours=15).total_seconds()\n",
-    "\n",
-    "# CTD stuff\n",
-    "# initialize CTD station number\n",
-    "station = 0\n",
-    "# # Set max depth for CTD cast OLD from before adding bathymetry\n",
-    "# CTD_depth = fieldset.maxdepth - fieldset.mindepth\n",
-    "\n",
-    "# create a ParticleFile to store the output\n",
-    "# Note: Do not specify the outputdt yet, so we can manually write the output\n",
-    "output_file = pset.ParticleFile(name=\"ADCP_CTD_test.zarr\")\n",
-    "\n",
-    "for time in np.arange(0, runtime, outputdt):\n",
-    "\n",
-    "    # check if time is a multiple of repeatdt\n",
-    "    # TODO add time\n",
-    "    if np.isclose(np.fmod(time, repeatdt), 0):\n",
-    "        station += 1\n",
-    "        # create a ParticleFile to store the CTD output\n",
-    "        ctd_output_file = pset.ParticleFile(name=f\"CTD_test_{station}.zarr\")\n",
-    "\n",
-    "        cur_lon = pset.lon[0]\n",
-    "        cur_lat = pset.lat[0]\n",
-    "\n",
-    "        # release CTD particle\n",
-    "        pset_CTD = ParticleSet.from_list(fieldset=fieldset, pclass=CTDParticle, lon=[cur_lon], lat=[cur_lat], depth=fieldset.z_start, time=time)\n",
-    "\n",
-    "        # # release CTD particles OLD way all at once\n",
-    "        # pset_CTD = ParticleSet.from_list(\n",
-    "        #     fieldset=fieldset, \n",
-    "        #     pclass=CTDParticle, \n",
-    "        #     lon=np.full(CTD_depth,cur_lon), \n",
-    "        #     lat=np.full(CTD_depth,cur_lat), \n",
-    "        #     depth=np.linspace(fieldset.mindepth, fieldset.maxdepth, num=CTD_depth),\n",
-    "        #     time=time,\n",
-    "        # )           \n",
-    "\n",
-    "        # Casting the SampleS and T functions to kernels\n",
-    "        Cast_CTD_kernel = pset_CTD.Kernel(CTDcast)  # Casting the CTDcast function to a kernel\n",
-    "        Sample_S_kernel = pset_CTD.Kernel(SampleS)  # Casting the SampleS function to a kernel\n",
-    "        Sample_T_kernel = pset_CTD.Kernel(SampleT)  # similar for temperature\n",
-    "        # Choose which kernels to use for CTD\n",
-    "        CTD_kernels = Sample_S_kernel + Sample_T_kernel + Cast_CTD_kernel\n",
-    "\n",
-    "        # record the temperature and salinity of the particles\n",
-    "        pset_CTD.execute(CTD_kernels, runtime=outputdt, dt=timedelta(seconds=1))\n",
-    "\n",
-    "        # write the CTD particles to the output file\n",
-    "        print(\"CTD time!\")\n",
-    "        ctd_output_file.write(pset_CTD, time)\n",
-    "\n",
-    "    # write the initialised particles and the advected particles\n",
-    "    output_file.write(pset, time)\n",
-    "\n",
-    "    pset.execute(kernels, runtime=outputdt, dt=timedelta(minutes=60))\n",
-    "    # print(f\"Writing time {time}\")\n",
-    "\n",
-    "output_file.write(pset, time + outputdt)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/nethome/0448257/.conda/envs/Parcels/lib/python3.11/site-packages/xarray/coding/times.py:618: RuntimeWarning: invalid value encountered in cast\n",
-      "  int_num = np.asarray(num, dtype=np.int64)\n"
-     ]
-    }
-   ],
-   "source": [
-    "import xarray as xr\n",
-    "# Open and combine the CTD output files\n",
-    "da = xr.open_zarr(\"CTD_test_1.zarr\")\n",
-    "for i in range(2, station+1):\n",
-    "    da = xr.concat([da, xr.open_zarr(f\"CTD_test_{i}.zarr\")], \"obs\")\n",
-    "# Write the combined output to a netcdf file\n",
-    "da.to_netcdf(\"CTD_test.nc\", mode=\"w\")\n",
-    "da.close()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Do some plotting to check output"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1300x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import xarray as xr\n",
-    "from mpl_toolkits.mplot3d import Axes3D\n",
-    "\n",
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_zarr(\"ADCP_CTD_test.zarr\")\n",
-    "# ds = xr.open_zarr('tmp.zarr')\n",
-    "x = ds[\"lon\"][:].squeeze()\n",
-    "y = ds[\"lat\"][:].squeeze()\n",
-    "z = ds[\"z\"][:].squeeze()\n",
-    "U = ds[\"U\"][:].squeeze()\n",
-    "V = ds[\"V\"][:].squeeze()\n",
-    "# salinity = ds[\"salinity\"][:].squeeze()\n",
-    "# temperature = ds[\"temperature\"][:].squeeze()\n",
-    "ds.close()\n",
-    "\n",
-    "# Plot Particle depth\n",
-    "fig = plt.figure(figsize=(13, 10))\n",
-    "ax = plt.axes(projection=\"3d\")\n",
-    "cb = ax.scatter(x, y, z, c=V, s=20, marker=\"o\")\n",
-    "ax.set_xlabel(\"Longitude\")\n",
-    "ax.set_ylabel(\"Latitude\")\n",
-    "ax.set_zlabel(\"Depth (m)\")\n",
-    "ax.set_zlim(np.max(z), 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Plot CTD casts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/nethome/0448257/.conda/envs/Parcels/lib/python3.11/site-packages/xarray/coding/times.py:254: RuntimeWarning: invalid value encountered in cast\n",
-      "  flat_num_dates_ns_int = (flat_num_dates * _NS_PER_TIME_DELTA[delta]).astype(\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1300x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_dataset(\"CTD_test.nc\")\n",
-    "x = ds[\"lon\"][:].squeeze()\n",
-    "y = ds[\"lat\"][:].squeeze()\n",
-    "z = ds[\"z\"][:].squeeze()\n",
-    "U = ds[\"U\"][:].squeeze()\n",
-    "V = ds[\"V\"][:].squeeze()\n",
-    "# salinity = ds[\"salinity\"][:].squeeze()\n",
-    "# temperature = ds[\"temperature\"][:].squeeze()\n",
-    "ds.close()\n",
-    "\n",
-    "# Plot Particle depth\n",
-    "fig = plt.figure(figsize=(13, 10))\n",
-    "ax = plt.axes(projection=\"3d\")\n",
-    "cb = ax.scatter(x, y, z, c=U, s=20, marker=\"o\")\n",
-    "ax.set_xlabel(\"Longitude\")\n",
-    "ax.set_ylabel(\"Latitude\")\n",
-    "ax.set_zlabel(\"Depth (m)\")\n",
-    "ax.set_zlim(np.max(z), 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<xarray.Dataset>\n",
-      "Dimensions:     (trajectory: 1, obs: 1)\n",
-      "Coordinates:\n",
-      "  * obs         (obs) int32 0\n",
-      "  * trajectory  (trajectory) int64 32\n",
-      "Data variables:\n",
-      "    U           (trajectory, obs) float32 dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-      "    V           (trajectory, obs) float32 dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-      "    lat         (trajectory, obs) float32 dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-      "    lon         (trajectory, obs) float32 dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-      "    time        (trajectory, obs) datetime64[ns] dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-      "    z           (trajectory, obs) float32 dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-      "Attributes:\n",
-      "    Conventions:            CF-1.6/CF-1.7\n",
-      "    feature_type:           trajectory\n",
-      "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-      "    parcels_mesh:           spherical\n",
-      "    parcels_version:        2.4.2\n",
-      "3\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "da = xr.open_zarr(\"CTD_test_2.zarr\")\n",
-    "print(da)\n",
-    "da.close()\n",
-    "print(station)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py3_parcels",
-   "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.11.4"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/src/OLD/ctdCMEMS.ipynb b/src/OLD/ctdCMEMS.ipynb
deleted file mode 100644
index 2f60d385..00000000
--- a/src/OLD/ctdCMEMS.ipynb
+++ /dev/null
@@ -1,296 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Local ADCP Particle test with CMEMS data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datetime import timedelta\n",
-    "import numpy as np\n",
-    "import math\n",
-    "\n",
-    "from parcels import (\n",
-    "    AdvectionRK4,\n",
-    "    ErrorCode,\n",
-    "    FieldSet,\n",
-    "    JITParticle,\n",
-    "    ScipyParticle,\n",
-    "    ParticleSet,\n",
-    "    Variable,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Read sample input data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1\n",
-      "5727\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Load the CMEMS data (3 days manually downloaded)\n",
-    "example_dataset_folder = \"../Data\"\n",
-    "filenames = {\n",
-    "    \"U\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"V\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"S\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-so_hcst_R20210113.nc\",\n",
-    "    \"T\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-thetao_hcst_R20210113.nc\",\n",
-    "}\n",
-    "variables = {'U': 'uo', 'V': 'vo', 'S':'so', 'T':'thetao'}\n",
-    "dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}\n",
-    "\n",
-    "# create the fieldset and set interpolation methods\n",
-    "fieldset = FieldSet.from_netcdf(filenames, variables, dimensions, time_periodic=timedelta(days=3))\n",
-    "fieldset.T.interp_method = \"linear_invdist_land_tracer\"\n",
-    "fieldset.S.interp_method = \"linear_invdist_land_tracer\"\n",
-    "\n",
-    "# determin top and bottom layer in the hydrodynamic data\n",
-    "fieldset.mindepth = math.ceil(fieldset.U.depth[0])\n",
-    "fieldset.maxdepth = math.floor(fieldset.U.depth[-1])\n",
-    "\n",
-    "# set initial location\n",
-    "ini_lat = -31\n",
-    "ini_lon = 32"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create particles and initalize"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "WARNING: dt or runtime are zero, or endtime is equal to Particle.time. The kernels will be executed once, without incrementing time\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Create and initialize Variable particles to sample the ocean\n",
-    "class SampleParticleInitZero(ScipyParticle):\n",
-    "    \"\"\"Define a new particle class with Variables init Nan\"\"\" \n",
-    "    salinity = Variable(\"salinity\", initial=np.nan)\n",
-    "    temperature = Variable(\"temperature\", initial=np.nan)\n",
-    "    U = Variable('U', dtype=np.float32, initial=np.nan)\n",
-    "    V = Variable('V', dtype=np.float32, initial=np.nan)\n",
-    "\n",
-    "# define function sampling Salinity \n",
-    "def SampleS(particle, fieldset, time):\n",
-    "    particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling Temperature \n",
-    "def SampleT(particle, fieldset, time):\n",
-    "    particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling u and v as in https://docs.oceanparcels.org/en/latest/examples/tutorial_sampling.html\n",
-    "def SampleVel_correct(particle, fieldset, time):\n",
-    "    particle.U, particle.V = fieldset.UV[time, particle.depth, particle.lat, particle.lon, particle]\n",
-    "\n",
-    "# Attempt for CTD like particle \n",
-    "depthnum = fieldset.maxdepth - fieldset.mindepth\n",
-    "# Initiate CTD like particle set \n",
-    "pset = ParticleSet.from_list(\n",
-    "    fieldset=fieldset, pclass=SampleParticleInitZero, lon=np.full(depthnum,ini_lon), lat=np.full(depthnum,ini_lat), depth=np.linspace(fieldset.mindepth, fieldset.maxdepth, num=depthnum)\n",
-    ")\n",
-    "Sample_S_kernel = pset.Kernel(SampleS)  # Casting the SampleS function to a kernel.\n",
-    "Sample_T_kernel = pset.Kernel(SampleT)  # similar for temperature\n",
-    "SampleVel_kernel = pset.Kernel(SampleVel_correct)  # Casting the function to a kernel.\n",
-    "\n",
-    "# only execute the sampling kernels to record the init values of the particles\n",
-    "pset.execute(Sample_S_kernel, dt=0)\n",
-    "pset.execute(Sample_T_kernel, dt=0)\n",
-    "pset.execute(SampleVel_correct, dt=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Determine ship course and add as kernel "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# change advection to ship movement\n",
-    "# Cruising speed Pelagia (and Anna Weber) is 9 knp https://www.nioz.nl/application/files/3614/9744/8746/Pelagia_Technical_specifications-2016.pdf\n",
-    "# survey speed nog iets lager? Zoals bij https://schmidtocean.org/rv-falkor/ship-specifications/\n",
-    "# 7 knp = 13 km/h = 3.6 m/s\n",
-    "\n",
-    "def ShipVel(particle, fieldset, time):\n",
-    "    speed = 3.6\n",
-    "    target_lat = -50\n",
-    "    target_lon = 20\n",
-    "    # determine ship direction\n",
-    "    heading = math.sqrt((target_lat - particle.lat)**2 + (target_lon - particle.lon)**2)\n",
-    "    # calculate e/w and n/s speed (m/s)\n",
-    "    lat_add = (target_lat - particle.lat)/(heading/speed)\n",
-    "    lon_add = (target_lon - particle.lon)/(heading/speed)\n",
-    "    # convert to lat/lon\n",
-    "    lat_add_deg = lat_add / 1.11e5\n",
-    "    lon_add_deg = lon_add / (1.11e5 * math.cos(particle.lat * math.pi / 180))\n",
-    "    # add to particle position\n",
-    "    particle.lat += lat_add_deg * particle.dt\n",
-    "    particle.lon += lon_add_deg * particle.dt\n",
-    "\n",
-    "# cast the ships velocity function to a kernel object\n",
-    "ShipVel_kernel = pset.Kernel(ShipVel)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Run simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Output files are stored in CTDtest.zarr.\n",
-      "100%|██████████| 86400.0/86400.0 [01:46<00:00, 812.82it/s] \n"
-     ]
-    }
-   ],
-   "source": [
-    "# set output file name and dt\n",
-    "output_file = pset.ParticleFile(\n",
-    "    name=\"CTDtest.zarr\",  # the file name\n",
-    "    outputdt=timedelta(hours=6),  # the time step of the outputs\n",
-    ")\n",
-    "\n",
-    "# Choose which kernels to use\n",
-    "kernels = ShipVel_kernel + Sample_S_kernel + Sample_T_kernel + SampleVel_kernel\n",
-    "\n",
-    "# Execute code and save to file \n",
-    "pset.execute(\n",
-    "    kernels, \n",
-    "    runtime=timedelta(days=1),  # the total length of the run\n",
-    "    dt=timedelta(minutes=60),  # the timestep of the kernel\n",
-    "    output_file=output_file,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Do some plotting to check output"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1500x1000 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import xarray as xr\n",
-    "\n",
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_zarr(\"CTDtest.zarr\")\n",
-    "x = ds[\"lon\"][:].values.flatten()\n",
-    "y = ds[\"lat\"][:].values.flatten()\n",
-    "z = ds[\"z\"][:].values.flatten()\n",
-    "U = ds[\"U\"][:].values.flatten()\n",
-    "V = ds[\"V\"][:].values.flatten()\n",
-    "salinity = ds[\"salinity\"][:].values.flatten()\n",
-    "temperature = ds[\"temperature\"][:].values.flatten()\n",
-    "valid_particles = salinity>0\n",
-    "ds.close()\n",
-    "\n",
-    "# Plot Particle depth\n",
-    "fig = plt.figure(figsize=(15, 10))\n",
-    "ax = plt.axes(projection=\"3d\")\n",
-    "# cb = ax.scatter(x, y, z, c=salinity, s=20, marker=\"o\")\n",
-    "cb = ax.scatter(x[valid_particles], y[valid_particles], z[valid_particles], c=U[valid_particles], s=20, marker=\"o\")\n",
-    "ax.set_title('Zonal velocity at CTD measurement locations', size = 14)\n",
-    "ax.set_xlabel(\"Longitude\")\n",
-    "ax.set_ylabel(\"Latitude\")\n",
-    "ax.set_zlabel(\"Depth (m)\")\n",
-    "ax.set_zlim(np.max(z), 0)\n",
-    "fig.colorbar(cb, shrink=0.7)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py3_parcels",
-   "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.11.4"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/src/OLD/leafmap_example.ipynb b/src/OLD/leafmap_example.ipynb
deleted file mode 100644
index 7377c680..00000000
--- a/src/OLD/leafmap_example.ipynb
+++ /dev/null
@@ -1,716 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Local ADCP Particle test with CMEMS data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "parcels environment, at the moment developer: https://docs.oceanparcels.org/en/latest/installation.html\n",
-    "with conda install -c conda-forge leafmap ipyleaflet \n",
-    "reduced geojson geopandas???"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Use interactive map to determine ship course "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3a6fa9d3c17b4b3a94e12bdabebc0a04",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Map(center=[0, -100], controls=(ZoomControl(options=['position', 'zoom_in_text', 'zoom_in_title', 'zoom_out_te…"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import leafmap \n",
-    "from ipyleaflet import Rectangle \n",
-    " \n",
-    "m = leafmap.leafmap.Map(center=(0, -100), zoom=5) \n",
-    "# Draw a rectange to indicate region where data will be collected \n",
-    "m.add_layer(Rectangle(bounds=((5, -125), (-10, -75)))) \n",
-    "# Add a point at port of departure: Puntarenas, Costa Rica \n",
-    "m.add_marker([9.97625, -84.83836]) \n",
-    "m "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([  2.,   6.,  10.,  14.,  18.,  22.,  26.,  30.,  34.,  38.,  42.,\n",
-       "        46.,  50.,  54.,  58.,  62.,  66.,  70.,  74.,  78.,  82.,  86.,\n",
-       "        90.,  94.,  98., 102., 106., 110., 114., 118., 122., 126., 130.,\n",
-       "       134., 138., 142., 146., 150.])"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "np.linspace(2, 150, num=38)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[-87.011719, 2.899153], [-87.626953, -3.337954], [-100.195313, -2.372369], [-96.591797, 3.337954]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Save data and read it back to get coordinates\n",
-    "line = m.user_rois\n",
-    "coords =  line.get('features')[0].get('geometry').get('coordinates')\n",
-    "# import geojson\n",
-    "# m.save_draw_features(\"data.geojson\")\n",
-    "# with open('./data.geojson') as f:\n",
-    "#     gj = geojson.load(f)\n",
-    "# features = gj['features']\n",
-    "# coords = features[0].geometry.coordinates\n",
-    "print(coords) "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "24.0"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "86400/3600"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[868.9349120887674, 781.0994283573966, 683.4303161156888, 889.0583972945243, 783.0875836005266, 1044.7548529427208, 966.2714290317624, 971.5508106070295, 718.6857702835648, 962.1652999572291, 806.6225218889897, 680.2915369286145, 923.2245417902343, 958.1489537614556]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "12037.326354648507"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import math\n",
-    "def haversine(lon1, lat1, lon2, lat2):\n",
-    "    \"\"\"\n",
-    "    Calculate the great circle distance in kilometers between two points\n",
-    "    on the earth (specified in decimal degrees)\n",
-    "    \"\"\"\n",
-    "    # convert decimal degrees to radians\n",
-    "    lon1, lat1, lon2, lat2 = map(math.radians, [lon1, lat1, lon2, lat2])\n",
-    " \n",
-    "    # haversine formula\n",
-    "    dlon = lon2 - lon1\n",
-    "    dlat = lat2 - lat1\n",
-    "    a = (math.sin(dlat/2))**2 + (math.cos(lat1) ) *  (math.cos(lat2) ) * ((math.sin(dlon/2))**2)\n",
-    "    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))\n",
-    "    r = 6371 # Radius of earth in kilometers. Determines return value units.\n",
-    "    return c * r\n",
-    "\n",
-    "coords = [[-85.429688, 2.547988], [-93.251953, 2.547988], [-100.283203, 2.635789], [-106.435547, 2.723583], [-114.433594, 3.074695], [-121.464844, 2.547988], [-130.869141, 2.460181], [-130.693359, -6.227934], [-121.904297, -6.402648], [-115.400391, -6.402648], [-106.699219, -6.140555], [-99.404297, -6.053161], [-93.251953, -6.053161], [-84.902344, -6.140555], [-84.375, 2.460181]]\n",
-    "distances = []\n",
-    "for i in range(len(coords)-1):\n",
-    "    distance = haversine(coords[i][0], coords[i][1], coords[i+1][0], coords[i+1][1])\n",
-    "    distances.append(distance)\n",
-    "\n",
-    "print(distances)\n",
-    "sum(distances)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## OLD stuff"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt \n",
-    "\n",
-    "import pyproj\n",
-    "from shapely.geometry.polygon import Polygon\n",
-    "from shapely.geometry import shape, Point"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Compute ship route as intermediate points beteen CTD stations"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Initialize lists to store intermediate points\n",
-    "sample_lons = []\n",
-    "sample_lats = []\n",
-    "\n",
-    "# Loop over station coordinates and calculate intermediate points\n",
-    "i = 0\n",
-    "for i in (range(len(coords)-1)):\n",
-    "    startlong = coords[i][0]\n",
-    "    startlat = coords[i][1]\n",
-    "    endlong = coords[i+1][0]\n",
-    "    endlat = coords[i+1][1]\n",
-    "\n",
-    "    # calculate line string along path with segments every TODO hour or 5 min = 3.6*60*5 = 1080 m, for now 5 midpoints\n",
-    "    g = pyproj.Geod(ellps='WGS84')\n",
-    "    # r = g.inv_intermediate(startlong, startlat, endlong, endlat, del_s = 1080)\n",
-    "    r = g.inv_intermediate(startlong, startlat, endlong, endlat, 5, initial_idx=0)\n",
-    "    # store all intermediate points \n",
-    "    sample_lons.append(r.lons) # stored as a list of arrays\n",
-    "    sample_lats.append(r.lats)\n",
-    "\n",
-    "# initial_idx will add begin point to each list (but not end point to avoid dubbling) so add final endpoint manually\n",
-    "sample_lons = np.append(np.hstack(sample_lons), endlong)\n",
-    "sample_lats = np.append(np.hstack(sample_lats), endlat)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Read sample input data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datetime import timedelta\n",
-    "import math\n",
-    "\n",
-    "from parcels import (\n",
-    "    FieldSet,\n",
-    "    JITParticle,\n",
-    "    ParticleSet,\n",
-    "    Variable,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-108.457031 3.337954\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Load the CMEMS data (3 days manually downloaded)\n",
-    "example_dataset_folder = \"../Data\"\n",
-    "filenames = {\n",
-    "    \"U\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"V\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-uovo_hcst_R20210113.nc\",\n",
-    "    \"S\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-so_hcst_R20210113.nc\",\n",
-    "    \"T\": f\"{example_dataset_folder}/glo12_rg_1d-m_2021010*_3D-thetao_hcst_R20210113.nc\",\n",
-    "}\n",
-    "variables = {'U': 'uo', 'V': 'vo', 'S':'so', 'T':'thetao'}\n",
-    "dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}\n",
-    "\n",
-    "# create the fieldset and set interpolation methods\n",
-    "fieldset = FieldSet.from_netcdf(filenames, variables, dimensions, time_periodic=timedelta(days=3))\n",
-    "fieldset.T.interp_method = \"linear_invdist_land_tracer\"\n",
-    "fieldset.S.interp_method = \"linear_invdist_land_tracer\"\n",
-    "\n",
-    "# determin top and bottom layer in the hydrodynamic data\n",
-    "fieldset.mindepth = math.ceil(fieldset.U.depth[0])\n",
-    "fieldset.maxdepth = math.floor(fieldset.U.depth[-1])\n",
-    "\n",
-    "ini_lon = coords[0][0]\n",
-    "ini_lat = coords[0][1]\n",
-    "print(ini_lon, ini_lat)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "INFO: Compiled ArraySampleParticleSampleVel_correct ==> /tmp/parcels-382783/lib348184e9bb192099d44b70860e7789a1_0.so\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Create and initialize Variable particles to sample the ocean\n",
-    "class SampleParticle(JITParticle):\n",
-    "    \"\"\"Define a new particle class with Variables\"\"\"\n",
-    "    U = Variable('U', dtype=np.float32, initial=0.0)\n",
-    "    V = Variable('V', dtype=np.float32, initial=0.0)\n",
-    "\n",
-    "# define function sampling u and v as in https://docs.oceanparcels.org/en/latest/examples/tutorial_sampling.html\n",
-    "def SampleVel_correct(particle, fieldset, time):\n",
-    "    # TODO attention: samples particle velocity in units of the mesh (deg/s or m/s)\n",
-    "    particle.U, particle.V = fieldset.UV[time, particle.depth, particle.lat, particle.lon, particle]\n",
-    "\n",
-    "# Attempt for ADCP like particle TODO accurate depths \n",
-    "depthnum = 5\n",
-    "# Initiate ADCP like particle set \n",
-    "pset = ParticleSet.from_list(\n",
-    "    fieldset=fieldset, pclass=SampleParticle, lon=np.full(depthnum,ini_lon), lat=np.full(depthnum,ini_lat), depth=np.linspace(5, 1000, num=depthnum)\n",
-    ")\n",
-    "\n",
-    "# Casting the function to a kernel\n",
-    "SampleVel_kernel = pset.Kernel(SampleVel_correct)  \n",
-    "\n",
-    "# only execute the sampling kernels to record the init values of the particles\n",
-    "pset.execute(SampleVel_kernel, dt=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Run simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CTD time!\n",
-      "367200.0\n",
-      "370800.0\n",
-      "374400.0\n",
-      "378000.0\n",
-      "381600.0\n",
-      "CTD time!\n",
-      "385200.0\n",
-      "388800.0\n",
-      "392400.0\n",
-      "396000.0\n",
-      "399600.0\n",
-      "CTD time!\n",
-      "403200.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "# create a ParticleFile to store the output\n",
-    "# Note: Do not specify the outputdt yet, so we can manually write the output\n",
-    "output_file = pset.ParticleFile(name=\"LeafmapADCPtest.zarr\")\n",
-    "\n",
-    "# write the particle data every hour\n",
-    "outputdt = timedelta(hours=1).total_seconds()\n",
-    "\n",
-    "# Choose which kernels to use\n",
-    "kernels = SampleVel_kernel\n",
-    "\n",
-    "c = 0\n",
-    "for i in range(len(sample_lons)):\n",
-    "    # write the initialised particles \n",
-    "    output_file.write(pset, time)\n",
-    " \n",
-    "    if sample_lons[i] == coords[c][0]:\n",
-    "        print('CTD time!')\n",
-    "        c += 1\n",
-    "\n",
-    "    # set the particle lon and lat\n",
-    "    pset.lon[:] = sample_lons[i]\n",
-    "    pset.lat[:] = sample_lats[i]\n",
-    "    pset.time[:] += outputdt\n",
-    "    time = pset.time[0]\n",
-    "    print(pset.time[0])\n",
-    "\n",
-    "    # execute the kernels i.e. sample at the new location\n",
-    "    # pset.execute(kernels, dt=outputdt)\n",
-    "    # print(f\"Writing time {time}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[-117.64258 -117.64258 -117.64258 -117.64258 -117.64258]\n"
-     ]
-    }
-   ],
-   "source": [
-    "198000-194400 \n",
-    "print(pset.lon)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Do some plotting to check output"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1300x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import xarray as xr\n",
-    "from mpl_toolkits.mplot3d import Axes3D\n",
-    "\n",
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_zarr(\"LeafmapADCPtest.zarr\")\n",
-    "# ds = xr.open_zarr('tmp.zarr')\n",
-    "x = ds[\"lon\"][:].squeeze()\n",
-    "y = ds[\"lat\"][:].squeeze()\n",
-    "z = ds[\"z\"][:].squeeze()\n",
-    "U = ds[\"U\"][:].squeeze()\n",
-    "V = ds[\"V\"][:].squeeze()\n",
-    "ds.close()\n",
-    "\n",
-    "# Plot Particle depth\n",
-    "fig = plt.figure(figsize=(13, 10))\n",
-    "ax = plt.axes(projection=\"3d\")\n",
-    "cb = ax.scatter(x, y, z, c=V, s=20, marker=\"o\")\n",
-    "ax.set_xlabel(\"Longitude\")\n",
-    "ax.set_ylabel(\"Latitude\")\n",
-    "ax.set_zlabel(\"Depth (m)\")\n",
-    "ax.set_zlim(np.max(z), 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<xarray.Dataset>\n",
-      "Dimensions:     (trajectory: 20, obs: 7)\n",
-      "Coordinates:\n",
-      "  * obs         (obs) int32 0 1 2 3 4 5 6\n",
-      "  * trajectory  (trajectory) int64 40 41 42 43 44 45 46 ... 53 54 55 56 57 58 59\n",
-      "Data variables:\n",
-      "    U           (trajectory, obs) float32 dask.array<chunksize=(20, 1), meta=np.ndarray>\n",
-      "    V           (trajectory, obs) float32 dask.array<chunksize=(20, 1), meta=np.ndarray>\n",
-      "    lat         (trajectory, obs) float32 dask.array<chunksize=(20, 1), meta=np.ndarray>\n",
-      "    lon         (trajectory, obs) float32 dask.array<chunksize=(20, 1), meta=np.ndarray>\n",
-      "    time        (trajectory, obs) datetime64[ns] dask.array<chunksize=(20, 1), meta=np.ndarray>\n",
-      "    z           (trajectory, obs) float32 dask.array<chunksize=(20, 1), meta=np.ndarray>\n",
-      "Attributes:\n",
-      "    Conventions:            CF-1.6/CF-1.7\n",
-      "    feature_type:           trajectory\n",
-      "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-      "    parcels_mesh:           spherical\n",
-      "    parcels_version:        2.4.2\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(ds)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "shapes = []\n",
-    "for feature in features:\n",
-    "  shapes.append(shape(feature['geometry']))\n",
-    "  \n",
-    "lons = []\n",
-    "lats = []\n",
-    "npts_line = 1\n",
-    "\n",
-    "for set_shape in shapes:\n",
-    "  # If the release location is a point\n",
-    "  if set_shape.type.lower() == 'point':\n",
-    "    lons.append(set_shape.coords.xy[0][0])\n",
-    "    lats.append(set_shape.coords.xy[1][0])\n",
-    "    \n",
-    "  # If the release location is a linestring (could be multiple lines)\n",
-    "  elif set_shape.type.lower() == 'linestring':\n",
-    "    pointlist_lon = set_shape.coords.xy[0]\n",
-    "    pointlist_lat = set_shape.coords.xy[1]\n",
-    "\n",
-    "    for i in range(len(pointlist_lon)-1):\n",
-    "      point1 = [pointlist_lon[i], pointlist_lat[i]]\n",
-    "      point2 = [pointlist_lon[i+1], pointlist_lat[i+1]]\n",
-    "      lons.append(np.linspace(point1[0], point2[0], npts_line, endpoint=True))\n",
-    "      lats.append(np.linspace(point1[1], point2[1], npts_line, endpoint=True))\n",
-    "\n",
-    "lons = np.hstack(np.asarray(lons))\n",
-    "lats = np.hstack(np.asarray(lats))\n",
-    "\n",
-    "# plt.scatter(lons, lats, s=2)\n",
-    "# plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Compute distance travelled by ship"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from math import radians, cos, sin, asin, sqrt\n",
-    "\n",
-    "def haversine(lon1, lat1, lon2, lat2):\n",
-    "    \"\"\"\n",
-    "    Calculate the great circle distance in kilometers between two points \n",
-    "    on the earth (specified in decimal degrees)\n",
-    "    \"\"\"\n",
-    "    # convert decimal degrees to radians \n",
-    "    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])\n",
-    "\n",
-    "    # haversine formula \n",
-    "    dlon = lon2 - lon1 \n",
-    "    dlat = lat2 - lat1 \n",
-    "    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2\n",
-    "    c = 2 * asin(sqrt(a)) \n",
-    "    r = 6371 # Radius of earth in kilometers. Use 3956 for miles. Determines return value units.\n",
-    "    return c * r"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Create particles and initalize"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### Determine ship course and add as kernel "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NotImplementedError",
-     "evalue": "Subscript not implemented for object type ConstNode",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
-      "\u001b[1;32m/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb Cell 15\u001b[0m line \u001b[0;36m6\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=58'>59</a>\u001b[0m     particle\u001b[39m.\u001b[39mlon \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m lon_add_deg \u001b[39m*\u001b[39m particle\u001b[39m.\u001b[39mdt\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=59'>60</a>\u001b[0m     \u001b[39m# update loc if close to target TODO target reached\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=60'>61</a>\u001b[0m     \u001b[39m# if target_lat - particle.lat < 3.6*3600/1.11e5 or target_lon - particle.lon < 3.6*3600/(1.11e5 * math.cos(particle.lat * math.pi / 180)):\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=61'>62</a>\u001b[0m     \u001b[39m#     loc += 1\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=62'>63</a>\u001b[0m     \u001b[39m#     speed = 3.6\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=63'>64</a>\u001b[0m \n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=64'>65</a>\u001b[0m \u001b[39m# cast the ships velocity function to a kernel object\u001b[39;00m\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Blorenz-compute/nethome/0448257/Virtual_ship_classroom/adcpCMEMSleafmap.ipynb#X20sdnNjb2RlLXJlbW90ZQ%3D%3D?line=65'>66</a>\u001b[0m ShipVel_kernel \u001b[39m=\u001b[39m pset\u001b[39m.\u001b[39;49mKernel(ShipVel)\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/particleset/particlesetsoa.py:722\u001b[0m, in \u001b[0;36mParticleSetSOA.Kernel\u001b[0;34m(self, pyfunc, c_include, delete_cfiles)\u001b[0m\n\u001b[1;32m    714\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(pyfunc, \u001b[39mlist\u001b[39m):\n\u001b[1;32m    715\u001b[0m     \u001b[39mreturn\u001b[39;00m Kernel\u001b[39m.\u001b[39mfrom_list(\n\u001b[1;32m    716\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfieldset,\n\u001b[1;32m    717\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcollection\u001b[39m.\u001b[39mptype,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    720\u001b[0m         delete_cfiles\u001b[39m=\u001b[39mdelete_cfiles,\n\u001b[1;32m    721\u001b[0m     )\n\u001b[0;32m--> 722\u001b[0m \u001b[39mreturn\u001b[39;00m Kernel(\n\u001b[1;32m    723\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfieldset,\n\u001b[1;32m    724\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcollection\u001b[39m.\u001b[39;49mptype,\n\u001b[1;32m    725\u001b[0m     pyfunc\u001b[39m=\u001b[39;49mpyfunc,\n\u001b[1;32m    726\u001b[0m     c_include\u001b[39m=\u001b[39;49mc_include,\n\u001b[1;32m    727\u001b[0m     delete_cfiles\u001b[39m=\u001b[39;49mdelete_cfiles,\n\u001b[1;32m    728\u001b[0m )\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/kernel/kernelsoa.py:98\u001b[0m, in \u001b[0;36mKernelSOA.__init__\u001b[0;34m(self, fieldset, ptype, pyfunc, funcname, funccode, py_ast, funcvars, c_include, delete_cfiles)\u001b[0m\n\u001b[1;32m     96\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mptype\u001b[39m.\u001b[39muses_jit:\n\u001b[1;32m     97\u001b[0m     kernelgen \u001b[39m=\u001b[39m KernelGenerator(fieldset, ptype)\n\u001b[0;32m---> 98\u001b[0m     kernel_ccode \u001b[39m=\u001b[39m kernelgen\u001b[39m.\u001b[39;49mgenerate(deepcopy(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mpy_ast),\n\u001b[1;32m     99\u001b[0m                                       \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfuncvars)\n\u001b[1;32m    100\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfield_args \u001b[39m=\u001b[39m kernelgen\u001b[39m.\u001b[39mfield_args\n\u001b[1;32m    101\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mvector_field_args \u001b[39m=\u001b[39m kernelgen\u001b[39m.\u001b[39mvector_field_args\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/compilation/codegenerator.py:526\u001b[0m, in \u001b[0;36mAbstractKernelGenerator.generate\u001b[0;34m(self, py_ast, funcvars)\u001b[0m\n\u001b[1;32m    523\u001b[0m py_ast \u001b[39m=\u001b[39m TupleSplitter()\u001b[39m.\u001b[39mvisit(py_ast)\n\u001b[1;32m    525\u001b[0m \u001b[39m# Generate C-code for all nodes in the Python AST\u001b[39;00m\n\u001b[0;32m--> 526\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mvisit(py_ast)\n\u001b[1;32m    527\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mccode \u001b[39m=\u001b[39m py_ast\u001b[39m.\u001b[39mccode\n\u001b[1;32m    529\u001b[0m \u001b[39m# Insert variable declarations for non-instrinsics\u001b[39;00m\n\u001b[1;32m    530\u001b[0m \u001b[39m# Make sure that repeated variables are not declared more than\u001b[39;00m\n\u001b[1;32m    531\u001b[0m \u001b[39m# once. If variables occur in multiple Kernels, give a warning\u001b[39;00m\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/ast.py:418\u001b[0m, in \u001b[0;36mNodeVisitor.visit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m    416\u001b[0m method \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mvisit_\u001b[39m\u001b[39m'\u001b[39m \u001b[39m+\u001b[39m node\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\n\u001b[1;32m    417\u001b[0m visitor \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(\u001b[39mself\u001b[39m, method, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgeneric_visit)\n\u001b[0;32m--> 418\u001b[0m \u001b[39mreturn\u001b[39;00m visitor(node)\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/compilation/codegenerator.py:926\u001b[0m, in \u001b[0;36mArrayKernelGenerator.visit_FunctionDef\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m    924\u001b[0m \u001b[39mfor\u001b[39;00m stmt \u001b[39min\u001b[39;00m node\u001b[39m.\u001b[39mbody:\n\u001b[1;32m    925\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mhasattr\u001b[39m(stmt, \u001b[39m'\u001b[39m\u001b[39mvalue\u001b[39m\u001b[39m'\u001b[39m) \u001b[39mand\u001b[39;00m \u001b[39mtype\u001b[39m(stmt\u001b[39m.\u001b[39mvalue) \u001b[39mis\u001b[39;00m ast\u001b[39m.\u001b[39mStr):  \u001b[39m# ignore docstrings\u001b[39;00m\n\u001b[0;32m--> 926\u001b[0m         \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mvisit(stmt)\n\u001b[1;32m    928\u001b[0m \u001b[39m# Create function declaration and argument list\u001b[39;00m\n\u001b[1;32m    929\u001b[0m decl \u001b[39m=\u001b[39m c\u001b[39m.\u001b[39mStatic(c\u001b[39m.\u001b[39mDeclSpecifier(c\u001b[39m.\u001b[39mValue(\u001b[39m\"\u001b[39m\u001b[39mStatusCode\u001b[39m\u001b[39m\"\u001b[39m, node\u001b[39m.\u001b[39mname), spec\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39minline\u001b[39m\u001b[39m'\u001b[39m))\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/ast.py:418\u001b[0m, in \u001b[0;36mNodeVisitor.visit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m    416\u001b[0m method \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mvisit_\u001b[39m\u001b[39m'\u001b[39m \u001b[39m+\u001b[39m node\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\n\u001b[1;32m    417\u001b[0m visitor \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(\u001b[39mself\u001b[39m, method, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgeneric_visit)\n\u001b[0;32m--> 418\u001b[0m \u001b[39mreturn\u001b[39;00m visitor(node)\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/compilation/codegenerator.py:649\u001b[0m, in \u001b[0;36mAbstractKernelGenerator.visit_Assign\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m    647\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mvisit_Assign\u001b[39m(\u001b[39mself\u001b[39m, node):\n\u001b[1;32m    648\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mvisit(node\u001b[39m.\u001b[39mtargets[\u001b[39m0\u001b[39m])\n\u001b[0;32m--> 649\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mvisit(node\u001b[39m.\u001b[39;49mvalue)\n\u001b[1;32m    650\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(node\u001b[39m.\u001b[39mvalue, ast\u001b[39m.\u001b[39mList):\n\u001b[1;32m    651\u001b[0m         \u001b[39m# Detect in-place initialisation of multi-dimensional arrays\u001b[39;00m\n\u001b[1;32m    652\u001b[0m         tmp_node \u001b[39m=\u001b[39m node\u001b[39m.\u001b[39mvalue\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/ast.py:418\u001b[0m, in \u001b[0;36mNodeVisitor.visit\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m    416\u001b[0m method \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mvisit_\u001b[39m\u001b[39m'\u001b[39m \u001b[39m+\u001b[39m node\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\n\u001b[1;32m    417\u001b[0m visitor \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(\u001b[39mself\u001b[39m, method, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgeneric_visit)\n\u001b[0;32m--> 418\u001b[0m \u001b[39mreturn\u001b[39;00m visitor(node)\n",
-      "File \u001b[0;32m~/.conda/envs/Parcels/lib/python3.11/site-packages/parcels/compilation/codegenerator.py:717\u001b[0m, in \u001b[0;36mAbstractKernelGenerator.visit_Subscript\u001b[0;34m(self, node)\u001b[0m\n\u001b[1;32m    715\u001b[0m     node\u001b[39m.\u001b[39mccode \u001b[39m=\u001b[39m node\u001b[39m.\u001b[39mvalue\u001b[39m.\u001b[39m\u001b[39m__getitem__\u001b[39m(node\u001b[39m.\u001b[39mslice\u001b[39m.\u001b[39mccode)\u001b[39m.\u001b[39mccode\n\u001b[1;32m    716\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(node\u001b[39m.\u001b[39mvalue, IntrinsicNode):\n\u001b[0;32m--> 717\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mSubscript not implemented for object type \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mtype\u001b[39m(node\u001b[39m.\u001b[39mvalue)\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m    718\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    719\u001b[0m     node\u001b[39m.\u001b[39mccode \u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00mnode\u001b[39m.\u001b[39mvalue\u001b[39m.\u001b[39mccode\u001b[39m}\u001b[39;00m\u001b[39m[\u001b[39m\u001b[39m{\u001b[39;00mnode\u001b[39m.\u001b[39mslice\u001b[39m.\u001b[39mccode\u001b[39m}\u001b[39;00m\u001b[39m]\u001b[39m\u001b[39m\"\u001b[39m\n",
-      "\u001b[0;31mNotImplementedError\u001b[0m: Subscript not implemented for object type ConstNode"
-     ]
-    }
-   ],
-   "source": [
-    "# Predetermine ship route\n",
-    "# Cruising speed Pelagia (and Anna Weber) is 9 knp https://www.nioz.nl/application/files/3614/9744/8746/Pelagia_Technical_specifications-2016.pdf\n",
-    "# survey speed nog iets lager? Zoals bij https://schmidtocean.org/rv-falkor/ship-specifications/\n",
-    "# 7 knp = 13 km/h = 3.6 m/s\n",
-    "\n",
-    "coords \n",
-    "\n",
-    "speed = 3.6\n",
-    "cur_loc = fieldset.ship_loc\n",
-    "target_lat = fieldset.ship_lats[cur_loc]\n",
-    "# target_lon = fieldset.ship_coords[fieldset.ship_loc][1]\n",
-    "target_lat = 50\n",
-    "target_lon = 5\n",
-    "# # slow down when close to target\n",
-    "# if target_lat - particle.lat < 3.6*3600/1.11e5 or target_lon - particle.lon < 3.6*3600/(1.11e5 * math.cos(particle.lat * math.pi / 180)):\n",
-    "#     speed = speed/4\n",
-    "\n",
-    "# calculate distance to target\n",
-    "# convert decimal degrees to radians \n",
-    "lon1, lat1, lon2, lat2 = map(math.radians, [particle.lon, particle.lat, target_lon, target_lat])\n",
-    "# haversine formula \n",
-    "dlon = lon2 - lon1 \n",
-    "dlat = lat2 - lat1 \n",
-    "a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2\n",
-    "c = 2 * math.asin(math.sqrt(a)) \n",
-    "r = 6371 # Radius of earth in kilometers. Use 3956 for miles. Determines return value units.\n",
-    "dist = c * r\n",
-    "print(dist)\n",
-    "\n",
-    "# determine ship direction\n",
-    "heading = math.sqrt((target_lat - particle.lat)**2 + (target_lon - particle.lon)**2)\n",
-    "\n",
-    "# # OR calculate bearing\n",
-    "# # Convert latitude and longitude to radians\n",
-    "# lat1 = math.radians(particle.lat[0])\n",
-    "# long1 = math.radians(particle.lon[0])\n",
-    "# lat2 = math.radians(target_lat)\n",
-    "# long2 = math.radians(target_lon)\n",
-    "\n",
-    "# # Calculate the bearing\n",
-    "# bearing = math.atan2(\n",
-    "#     math.sin(long2 - long1) * math.cos(lat2),\n",
-    "#     math.cos(lat1) * math.sin(lat2) - math.sin(lat1) * math.cos(lat2) * math.cos(long2 - long1)\n",
-    "# )\n",
-    "# # Convert the bearing to degrees\n",
-    "# bearing = math.degrees(bearing)\n",
-    "# # Make sure the bearing is positive\n",
-    "# bearing = (bearing + 360) % 360\n",
-    "\n",
-    "\n",
-    "# calculate e/w and n/s speed (m/s)\n",
-    "lat_add = (target_lat - particle.lat)/(heading/speed)\n",
-    "lon_add = (target_lon - particle.lon)/(heading/speed)\n",
-    "# convert to lat/lon\n",
-    "lat_add_deg = lat_add / 1.11e5\n",
-    "lon_add_deg = lon_add / (1.11e5 * math.cos(particle.lat * math.pi / 180))\n",
-    "# add to particle position\n",
-    "particle.lat += lat_add_deg * particle.dt\n",
-    "particle.lon += lon_add_deg * particle.dt\n",
-    "# update loc if close to target TODO target reached\n",
-    "# if target_lat - particle.lat < 3.6*3600/1.11e5 or target_lon - particle.lon < 3.6*3600/(1.11e5 * math.cos(particle.lat * math.pi / 180)):\n",
-    "#     loc += 1\n",
-    "#     speed = 3.6\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py3_parcels",
-   "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.11.5"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/src/cruise_simulation.py b/src/cruise_simulation.py
deleted file mode 100755
index 7a6c1b3d..00000000
--- a/src/cruise_simulation.py
+++ /dev/null
@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-# Script to simulate a cruise with CTD casts and ADCP data
-# Simulating ADCP data near Japan because of strong winds there
-
-import numpy as np
-import pyproj
-from datetime import timedelta
-from shapely.geometry import Point, Polygon
-from parcels import Field, FieldSet, JITParticle, Variable, ParticleSet
-
-# set initial location as lon-lat EW-NS 
-coords_input = [[-81.25, -11.83], [-77.8, -10,71]]
-
-# Load the CMEMS data (3 weeks for IPO)
-dataset_folder = "/nethome/0448257/Data"
-filenames = {
-    "U": f"{dataset_folder}/PeruCoast.nc",
-    "V": f"{dataset_folder}/PeruCoast.nc"}
-    # "S": f"{dataset_folder}/studentdata_S.nc",
-    # "T": f"{dataset_folder}/studentdata_T.nc"}  
-variables = {'U': 'uo', 'V': 'vo'} #, 'S':'so', 'T':'thetao'}
-dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}
-
-# create the fieldset and set interpolation methods
-fieldset = FieldSet.from_netcdf(filenames, variables, dimensions)
-# fieldset.T.interp_method = "linear_invdist_land_tracer"
-# fieldset.S.interp_method = "linear_invdist_land_tracer"
-
-# add bathymetry data to the fieldset for CTD cast
-bathymetry_file = f"{dataset_folder}/GLO-MFC_001_024_mask_bathy.nc"
-bathymetry_variables = ('bathymetry', 'deptho')
-bathymetry_dimensions = {'lon': 'longitude', 'lat': 'latitude'}
-bathymetry_field = Field.from_netcdf(bathymetry_file, bathymetry_variables, bathymetry_dimensions)
-fieldset.add_field(bathymetry_field)
-# read in data already
-fieldset.computeTimeChunk(0,1)
-
-### Determine ship course as intermediate points between CTD stations
-
-# Initialize lists to store intermediate points
-lons = []
-lats = []
-
-# Loop over station coordinates and calculate intermediate points along great circle path
-i = 0
-for i in (range(len(coords_input)-1)):
-    startlong = coords_input[i][0]
-    startlat = coords_input[i][1]
-    endlong = coords_input[i+1][0]
-    endlat = coords_input[i+1][1]
-
-    # calculate line string along path with segments every 5 min = 3.6*60*5 = 1080 m (or switch comment for 2 midpoints)
-    g = pyproj.Geod(ellps='WGS84')
-    r = g.inv_intermediate(startlong, startlat, endlong, endlat, del_s = 1080)
-    # r = g.inv_intermediate(startlong, startlat, endlong, endlat, initial_idx=0, return_back_azimuth=False, npts=3)
-    lons.append(r.lons) # stored as a list of arrays
-    lats.append(r.lats)
-
-# initial_idx will add begin point to each list (but not end point to avoid dubbling) so add final endpoint manually
-lons = np.append(np.hstack(lons), endlong)
-lats = np.append(np.hstack(lats), endlat)
-
-# check if input sample locations are within data availability area, only save if so
-#poly = Polygon([(west, north), (west, south), (east, south), (east, north)])
-poly = Polygon([(-83, -6), (-83, -12), (-78, -12), (-78, -6)])
-coords = []
-sample_lons = []
-sample_lats = []
-for coord in coords_input:
-    if poly.contains(Point(coord)):
-        coords.append(coord)
-for i in range(len(lons)):
-    if poly.contains(Point(lons[i], lats[i])):
-        sample_lons.append(lons[i])
-        sample_lats.append(lats[i])
-
-### Define particles and sampling functions 
-        
-# Create ADCP like particles to sample the ocean
-class ADCPParticle(JITParticle):
-    """Define a new particle class that does ADCP like measurements"""
-    U = Variable('U', dtype=np.float32, initial=0.0)
-    V = Variable('V', dtype=np.float32, initial=0.0)
-
-# define ADCP sampling function without conversion (because of A grid)
-def SampleVel(particle, fieldset, time):
-    particle.U, particle.V = fieldset.UV.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)
-    # particle.V = fieldset.V.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)
-
-# # Create CTD like particles to sample the ocean
-# class CTDParticle(JITParticle):
-#     """Define a new particle class that does CTD like measurements"""
-#     salinity = Variable("salinity", initial=np.nan)
-#     temperature = Variable("temperature", initial=np.nan)
-#     pressure = Variable("pressure", initial=np.nan)
-#     raising = Variable("raising", dtype=np.int32, initial=0.0)
-
-# # define function lowering and raising CTD
-# def CTDcast(particle, fieldset, time):
-#     seafloor = fieldset.bathymetry[time, particle.depth, particle.lat, particle.lon]
-#     vertical_speed = 1.0  # sink and rise speed in m/s
-
-#     if particle.raising == 0:
-#         # Sinking with vertical_speed until near seafloor
-#         particle_ddepth = vertical_speed * particle.dt
-#         if particle.depth >= (seafloor - 20): 
-#             particle.raising = 1
-
-#     if particle.raising == 1:
-#         # Rising with vertical_speed until depth is 2 m
-#         if particle.depth > 2:
-#             particle_ddepth = -vertical_speed * particle.dt  
-#             if particle.depth + particle_ddepth <= 2:
-#                 # to break the loop ...
-#                 particle.state = 41
-#                 print("CTD cast finished")
-
-# # define function sampling Salinity
-# def SampleS(particle, fieldset, time):
-#     particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]
-
-# # define function sampling Temperature
-# def SampleT(particle, fieldset, time):
-#     particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]
-
-# # define function sampling Pressure
-# def SampleP(particle, fieldset, time):
-#     particle.pressure = fieldset.P[time, particle.depth, particle.lat, particle.lon]
-
-### Run simulation
-
-# Create ADCP like particle with accurate depths, 150 meter every 4 meters as https://rowetechinc.com/seaseven/
-depthnum = 48
-# Initiate ADCP like particle set
-pset = ParticleSet.from_list(
-    fieldset=fieldset, pclass=ADCPParticle, lon=np.full(depthnum,sample_lons[0]), lat=np.full(depthnum,sample_lats[0]), depth=np.linspace(2, 500, num=depthnum), time=0
-)
-# create a ParticleFile to store the ADCP output
-adcp_output_file = pset.ParticleFile(name="./results/Peru_adcp.zarr")
-adcp_dt = timedelta(minutes=5).total_seconds() # timestep of ADCP output, every 5 min == 1080 m (3.6*60*5 =m/s*s/min*min)
-
-# # initialize CTD station number and time 
-total_time = timedelta(hours=0).total_seconds()
-# ctd = 0
-# ctd_dt = timedelta(seconds=10) # timestep of CTD output reflecting post-proces binning into 10m bins
-
-# run the model for the length of the sample_lons list
-for i in range(len(sample_lons)-1):
-
-    #vexecute the kernels to sample U and V
-    pset.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False) 
-    adcp_output_file.write(pset, time=pset[0].time)
-
-    # # check if we are at a CTD station
-    # if (sample_lons[i] - coords[ctd][0]) < 0.01 and (sample_lats[i] - coords[ctd][1]) < 0.01:
-    #     ctd += 1
-        
-    #     # release CTD particle
-    #     pset_CTD = ParticleSet(fieldset=fieldset, pclass=CTDParticle, lon=sample_lons[i], lat=sample_lats[i], depth=2, time=total_time)
-
-    #     # create a ParticleFile to store the CTD output
-    #     ctd_output_file = pset_CTD.ParticleFile(name=f"./results/CTD_test_{ctd}.zarr", outputdt=ctd_dt)
-
-    #     # record the temperature and salinity of the particle
-    #     pset_CTD.execute([SampleS, SampleT, CTDcast], runtime=timedelta(hours=4), dt=ctd_dt, output_file=ctd_output_file)
-    #     total_time = pset_CTD.time[0] #+ timedelta(hours=1).total_seconds() # add CTD time and 1 hour for deployment
-
-    # update the particle time and location
-    pset.lon_nextloop[:] = sample_lons[i+1]
-    pset.lat_nextloop[:] = sample_lats[i+1]
-    
-    total_time += adcp_dt
-    pset.time_nextloop[:] = total_time
-# write the final locations of the ADCP particles
-pset.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False)
-adcp_output_file.write_latest_locations(pset, time=total_time)
-
-# ### Post-processing
-# import xarray as xr
-# from scipy.ndimage import uniform_filter1d
-
-# # rewrite CTD data to cvs
-# for i in range(1, ctd+1):
-    
-#     # Open output and read to x, y, z
-#     ds = xr.open_zarr(f"./results/CTD_test_{i}.zarr")
-#     x = ds["lon"][:].squeeze()
-#     y = ds["lat"][:].squeeze()
-#     z = ds["z"][:].squeeze()
-#     time = ds["time"][:].squeeze()
-#     T = ds["temperature"][:].squeeze()
-#     S = ds["salinity"][:].squeeze()
-#     ds.close()
-
-#     # add some noise
-#     random_walk = np.random.random()/10
-#     z_norm = (z-np.min(z))/(np.max(z)-np.min(z))
-#     t_norm = np.linspace(0, 1, num=len(time))
-#     # dS = abs(np.append(0, np.diff(S))) # scale noise with gradient
-#     # for j in range(5, 0, -1):
-#     #     dS[dS<1*10**-j] = 0.5-j/10
-#     # add smoothed random noise scaled with depth (and OPTIONAL with gradient for S) 
-#     # and random (reversed) diversion from initial through time scaled with depth 
-#     S = S + uniform_filter1d(
-#         np.random.random(S.shape)/5*(1-z_norm) + 
-#         random_walk*(np.max(S).values - np.min(S).values)*(1-z_norm)*t_norm/10, 
-#         max(int(len(time)/40), 1))
-#     T = T + uniform_filter1d(
-#         np.random.random(T.shape)*5*(1-z_norm) - 
-#         random_walk/2*(np.max(T).values - np.min(T).values)*(1-z_norm)*t_norm/10, 
-#         max(int(len(time)/20), 1))
-
-#     # reshaping data to export to csv
-#     header = f"'pressure [hPa]','temperature [degC]', 'salinity [g kg-1]'"
-#     data = np.column_stack([(z/10), T, S])
-#     new_line = '\n'
-#     np.savetxt(f"./results/CTD_station_{i}.csv", data, fmt="%.4f", header=header, delimiter=',', 
-#                comments=f'{x.attrs}{new_line}{x[0].values}{new_line}{y.attrs}{new_line}{y[0].values}{new_line}start time: {time[0].values}{new_line}end time: {time[-1].values}{new_line}')
-
diff --git a/src/cruise_simulation_CTD.py b/src/cruise_simulation_CTD.py
deleted file mode 100755
index aa2cc359..00000000
--- a/src/cruise_simulation_CTD.py
+++ /dev/null
@@ -1,221 +0,0 @@
-# #!/usr/bin/env python3
-# # Script to simulate a cruise with CTD casts and ADCP data
-# # Simulating CTD data near Japan in Eddy
-
-import numpy as np
-import pyproj
-from datetime import timedelta
-from shapely.geometry import Point, Polygon
-from parcels import Field, FieldSet, JITParticle, Variable, ParticleSet
-
-# # set initial location as lon-lat EW-NS 
-# coords_input = [[154, 38.1], [155, 38.1], [156, 38.1], [157, 38.1], [158, 38.1]]
-
-# # Load the CMEMS data (3 weeks for IPO)
-# dataset_folder = "/nethome/0448257/Data"
-# filenames = {
-#     "U": f"{dataset_folder}/JapanUV.nc",
-#     "V": f"{dataset_folder}/JapanUV.nc",
-#     "S": f"{dataset_folder}/JapanS.nc",
-#     "T": f"{dataset_folder}/JapanT.nc"}  
-# variables = {'U': 'uo', 'V': 'vo', 'S':'so', 'T':'thetao'}
-# dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth':'depth'}
-
-# # create the fieldset and set interpolation methods
-# fieldset = FieldSet.from_netcdf(filenames, variables, dimensions)
-# fieldset.T.interp_method = "linear_invdist_land_tracer"
-# fieldset.S.interp_method = "linear_invdist_land_tracer"
-
-# # add bathymetry data to the fieldset for CTD cast
-# bathymetry_file = f"{dataset_folder}/GLO-MFC_001_024_mask_bathy.nc"
-# bathymetry_variables = ('bathymetry', 'deptho')
-# bathymetry_dimensions = {'lon': 'longitude', 'lat': 'latitude'}
-# bathymetry_field = Field.from_netcdf(bathymetry_file, bathymetry_variables, bathymetry_dimensions)
-# fieldset.add_field(bathymetry_field)
-# # read in data already
-# fieldset.computeTimeChunk(0,1)
-
-# ### Determine ship course as intermediate points between CTD stations
-
-# # Initialize lists to store intermediate points
-# lons = []
-# lats = []
-
-# # Loop over station coordinates and calculate intermediate points along great circle path
-# i = 0
-# for i in (range(len(coords_input)-1)):
-#     startlong = coords_input[i][0]
-#     startlat = coords_input[i][1]
-#     endlong = coords_input[i+1][0]
-#     endlat = coords_input[i+1][1]
-
-#     # calculate line string along path with segments every 5 min = 3.6*60*5 = 1080 m (or switch comment for 2 midpoints)
-#     g = pyproj.Geod(ellps='WGS84')
-#     r = g.inv_intermediate(startlong, startlat, endlong, endlat, initial_idx=0, del_s = 1080)
-#     # r = g.inv_intermediate(startlong, startlat, endlong, endlat, initial_idx=0, return_back_azimuth=False, npts=3)
-#     lons.append(r.lons) # stored as a list of arrays
-#     lats.append(r.lats)
-
-# # initial_idx will add begin point to each list (but not end point to avoid dubbling) so add final endpoint manually
-# lons = np.append(np.hstack(lons), endlong)
-# lats = np.append(np.hstack(lats), endlat)
-
-# # check if input sample locations are within data availability area, only save if so
-# #poly = Polygon([(west, north), (west, south), (east, south), (east, north)])
-# poly = Polygon([(153, 37), (153, 39), (159, 39), (159, 37)])
-# coords = []
-# sample_lons = []
-# sample_lats = []
-# for coord in coords_input:
-#     if poly.contains(Point(coord)):
-#         coords.append(coord)
-# for i in range(len(lons)):
-#     if poly.contains(Point(lons[i], lats[i])):
-#         sample_lons.append(lons[i])
-#         sample_lats.append(lats[i])
-
-# ### Define particles and sampling functions 
-        
-# # Create ADCP like particles to sample the ocean
-# class ADCPParticle(JITParticle):
-#     """Define a new particle class that does ADCP like measurements"""
-#     U = Variable('U', dtype=np.float32, initial=0.0)
-#     V = Variable('V', dtype=np.float32, initial=0.0)
-
-# # define ADCP sampling function without conversion (because of A grid)
-# def SampleVel(particle, fieldset, time):
-#     particle.U, particle.V = fieldset.UV.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)
-#     # particle.V = fieldset.V.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)
-
-# # Create CTD like particles to sample the ocean
-# class CTDParticle(JITParticle):
-#     """Define a new particle class that does CTD like measurements"""
-#     salinity = Variable("salinity", initial=np.nan)
-#     temperature = Variable("temperature", initial=np.nan)
-#     pressure = Variable("pressure", initial=np.nan)
-#     raising = Variable("raising", dtype=np.int32, initial=0.0)
-
-# # define function lowering and raising CTD
-# def CTDcast(particle, fieldset, time):
-#     seafloor = fieldset.bathymetry[time, particle.depth, particle.lat, particle.lon]
-#     vertical_speed = 1.0  # sink and rise speed in m/s
-
-#     if particle.raising == 0:
-#         # Sinking with vertical_speed until near seafloor
-#         particle_ddepth = vertical_speed * particle.dt
-#         if particle.depth >= 2000: #(seafloor - 20): 
-#             particle.raising = 1
-
-#     if particle.raising == 1:
-#         # Rising with vertical_speed until depth is 2 m
-#         if particle.depth > 2:
-#             particle_ddepth = -vertical_speed * particle.dt  
-#             if particle.depth + particle_ddepth <= 2:
-#                 # to break the loop ...
-#                 particle.state = 41
-#                 print("CTD cast finished")
-
-# # define function sampling Salinity
-# def SampleS(particle, fieldset, time):
-#     particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]
-
-# # define function sampling Temperature
-# def SampleT(particle, fieldset, time):
-#     particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]
-
-# # define function sampling Pressure
-# def SampleP(particle, fieldset, time):
-#     particle.pressure = fieldset.P[time, particle.depth, particle.lat, particle.lon]
-
-# ### Run simulation
-
-# # Create ADCP like particle with accurate depths, 150 meter every 4 meters as https://rowetechinc.com/seaseven/
-# depthnum = 48
-# # Initiate ADCP like particle set
-# pset = ParticleSet.from_list(
-#     fieldset=fieldset, pclass=ADCPParticle, lon=np.full(depthnum,sample_lons[0]), lat=np.full(depthnum,sample_lats[0]), depth=np.linspace(2, 500, num=depthnum), time=0
-# )
-# # create a ParticleFile to store the ADCP output
-# adcp_output_file = pset.ParticleFile(name="./results/Japan_ADCP.zarr")
-# adcp_dt = timedelta(minutes=5).total_seconds() # timestep of ADCP output, every 5 min == 1080 m (3.6*60*5 =m/s*s/min*min)
-
-# # # initialize CTD station number and time 
-# total_time = timedelta(hours=0).total_seconds()
-# ctd = 0
-# ctd_dt = timedelta(seconds=10) # timestep of CTD output reflecting post-proces binning into 10m bins
-
-# # run the model for the length of the sample_lons list
-# for i in range(len(sample_lons)-1):
-
-#     #vexecute the kernels to sample U and V
-#     pset.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False) 
-#     adcp_output_file.write(pset, time=pset[0].time)
-
-#     # check if we are at a CTD station
-#     if (sample_lons[i] - coords[ctd][0]) < 0.01 and (sample_lats[i] - coords[ctd][1]) < 0.01:
-#         ctd += 1
-        
-#         # release CTD particle
-#         pset_CTD = ParticleSet(fieldset=fieldset, pclass=CTDParticle, lon=sample_lons[i], lat=sample_lats[i], depth=2, time=total_time)
-
-#         # create a ParticleFile to store the CTD output
-#         ctd_output_file = pset_CTD.ParticleFile(name=f"./results/CTD_Japan_{ctd}.zarr", outputdt=ctd_dt)
-
-#         # record the temperature and salinity of the particle
-#         pset_CTD.execute([SampleS, SampleT, CTDcast], runtime=timedelta(hours=4), dt=ctd_dt, output_file=ctd_output_file)
-#         total_time = pset_CTD.time[0] #+ timedelta(hours=1).total_seconds() # add CTD time and 1 hour for deployment
-
-#     # update the particle time and location
-#     pset.lon_nextloop[:] = sample_lons[i+1]
-#     pset.lat_nextloop[:] = sample_lats[i+1]
-    
-#     total_time += adcp_dt
-#     pset.time_nextloop[:] = total_time
-# # write the final locations of the ADCP particles
-# pset.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False)
-# adcp_output_file.write_latest_locations(pset, time=total_time)
-
-### Post-processing
-import xarray as xr
-from scipy.ndimage import uniform_filter1d
-import numpy as np
-
-ctd = 5
-# rewrite CTD data to cvs
-for i in range(1, ctd+1):
-    
-    # Open output and read to x, y, z
-    ds = xr.open_zarr(f"./results/CTD_Japan_{i}.zarr")
-    x = ds["lon"][:].squeeze()
-    y = ds["lat"][:].squeeze()
-    z = ds["z"][:].squeeze()
-    time = ds["time"][:].squeeze()
-    T = ds["temperature"][:].squeeze()
-    S = ds["salinity"][:].squeeze()
-    ds.close()
-
-    # add some noise
-    random_walk = np.random.random()/10
-    z_norm = (z-np.min(z))/(np.max(z)-np.min(z))
-    t_norm = np.linspace(0, 1, num=len(time))
-    # dS = abs(np.append(0, np.diff(S))) # scale noise with gradient
-    # for j in range(5, 0, -1):
-    #     dS[dS<1*10**-j] = 0.5-j/10
-    # add smoothed random noise scaled with depth (and OPTIONAL with gradient for S) 
-    # and random (reversed) diversion from initial through time scaled with depth 
-    S = S + uniform_filter1d(
-        np.random.random(S.shape)/5*(1-z_norm) + 
-        random_walk*(np.max(S).values - np.min(S).values)*(1-z_norm)*t_norm/10, 
-        max(int(len(time)/40), 1))
-    T = T + uniform_filter1d(
-        np.random.random(T.shape)*5*(1-z_norm) - 
-        random_walk/2*(np.max(T).values - np.min(T).values)*(1-z_norm)*t_norm/10, 
-        max(int(len(time)/20), 1))
-
-    # reshaping data to export to csv
-    header = f"pressure [hPa],temperature [degC],salinity [g kg-1]"
-    data = np.column_stack([(z/10), T, S])
-    new_line = '\n'
-    np.savetxt(f"./results/CTD_Japan_station_{i}.csv", data, fmt="%.4f", header=header, delimiter=',', 
-               comments=f'longitude,{x[0].values},”{x.attrs}”{new_line}latitude,{y[0].values},”{y.attrs}”{new_line}start time,{time[0].values}{new_line}end time,{time[-1].values}{new_line}')
-
diff --git a/src/sailship.ipynb b/src/sailship.ipynb
deleted file mode 100644
index 0ccdf8fb..00000000
--- a/src/sailship.ipynb
+++ /dev/null
@@ -1,1644 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Work in progress to sail the virtual ship"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "import numpy as np\n",
-    "import pyproj\n",
-    "from datetime import timedelta\n",
-    "from shapely.geometry import Point, Polygon\n",
-    "from parcels import Field, FieldSet, JITParticle, Variable, ParticleSet"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Read sample input data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "21600"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Load the CMEMS data (3 weeks nov 2022 for IPO)\n",
-    "dataset_folder = \"/nethome/0448257/Data\"\n",
-    "filenames = {\n",
-    "    \"U\": f\"{dataset_folder}/studentdata_UV_klein.nc\",\n",
-    "    \"V\": f\"{dataset_folder}/studentdata_UV_klein.nc\",\n",
-    "    \"S\": f\"{dataset_folder}/studentdata_S_klein.nc\",\n",
-    "    \"T\": f\"{dataset_folder}/studentdata_T_klein.nc\"}  \n",
-    "variables = {'U': 'uo', 'V': 'vo', 'S': 'so', 'T': 'thetao'}\n",
-    "dimensions = {'lon': 'longitude', 'lat': 'latitude', 'time': 'time', 'depth': 'depth'}\n",
-    "\n",
-    "# create the fieldset and set interpolation methods\n",
-    "fieldset = FieldSet.from_netcdf(filenames, variables, dimensions)\n",
-    "fieldset.T.interp_method = \"linear_invdist_land_tracer\"\n",
-    "fieldset.S.interp_method = \"linear_invdist_land_tracer\"\n",
-    "\n",
-    "# add bathymetry data to the fieldset for CTD cast\n",
-    "bathymetry_file = f\"{dataset_folder}/GLO-MFC_001_024_mask_bathy.nc\"\n",
-    "bathymetry_variables = ('bathymetry', 'deptho')\n",
-    "bathymetry_dimensions = {'lon': 'longitude', 'lat': 'latitude'}\n",
-    "bathymetry_field = Field.from_netcdf(bathymetry_file, bathymetry_variables, bathymetry_dimensions)\n",
-    "fieldset.add_field(bathymetry_field)\n",
-    "# read in data already\n",
-    "fieldset.computeTimeChunk(0,1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# set initial location as lon-lat EW-NS #TODO should be input to function or come from leafmap \n",
-    "coords_input = [[-83.737793, 3.591884], [-86.879883, 4.258768], [-86.879883, -0.747049], [-86.791992, -4.740675], [-86.791992, -9.058702]]\n",
-    "ctd_input = [[-83.737793, 3.591884], [-86.879883, 4.258768], [-86.879883, -0.747049], [-86.791992, -4.740675], [-86.791992, -9.058702]]\n",
-    "drifter_input = [[-83.737793, 3.591884], [-83.737793, 3.591984], [-83.737893, 3.591884]]\n",
-    "coords_input = [[-80, 2], [-80.01, 2], [-90, 2], [-100, 2], [-110, 2], [-120, 2], [-125, 2.5], [-115, 2.5], [-105, 2.5], [-95, 2.5], [-85, 2.5]]\n",
-    "# coords_input = [[-82.924805, 4.696879], [-84.418945, 3.908099], [-86.044922, 3.074695], [-87.978516, 2.021065], [-90, 1.274309], [-91.977539, 0.483393], [-92.021484, -1.054628], [-90.65918, -2.021065], [-88.769531, -1.054628], [-86.879883, 0], [-84.990234, 1.098565], [-83.320313, 2.021065], [-81.650391, 3.513421], [-80.244141, 4.784469]]\n",
-    "# coords_input = [[152.8, 36.6], [156.6, 36.9]]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Determine ship course as intermediate points between CTD stations"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(-89.99982550251605, 89.99982550251605, 1112.521315199904)\n",
-      "(-89.8252315914032, 89.8252315914032, 1111407.073934867)\n",
-      "(-89.82505575223266, 89.82505575223266, 1112519.5900692847)\n",
-      "(-89.82505575223266, 89.82505575223266, 1112519.5900692847)\n",
-      "(-89.82505575223266, 89.82505575223266, 1112519.5900692847)\n",
-      "(-84.22838722804681, 95.5751864989223, 558910.4685414702)\n",
-      "(89.78134505877674, -89.78134505877674, 1112139.781805734)\n",
-      "(89.78134505877674, -89.78134505877674, 1112139.781805734)\n",
-      "(89.78134505877674, -89.78134505877674, 1112139.781805734)\n",
-      "(89.78134505877674, -89.78134505877674, 1112139.781805734)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Initialize lists to store intermediate points\n",
-    "lons = []\n",
-    "lats = []\n",
-    "\n",
-    "# Loop over station coordinates and calculate intermediate points along great circle path\n",
-    "i = 0\n",
-    "for i in (range(len(coords_input)-1)):\n",
-    "    startlong = coords_input[i][0]\n",
-    "    startlat = coords_input[i][1]\n",
-    "    endlong = coords_input[i+1][0]\n",
-    "    endlat = coords_input[i+1][1]\n",
-    "\n",
-    "    # calculate line string along path with segments every 5 min = 3.6*60*5 = 1080 m (or switch comment for 2 midpoints)\n",
-    "    geod = pyproj.Geod(ellps='WGS84')\n",
-    "    r = g.inv_intermediate(startlong, startlat, endlong, endlat, del_s=1080, initial_idx=0, return_back_azimuth=False)\n",
-    "    # r = g.inv_intermediate(startlong, startlat, endlong, endlat, initial_idx=0, return_back_azimuth=False, npts=3)\n",
-    "    lons = np.append(lons, r.lons) # stored as a list of arrays\n",
-    "    lats = np.append(lats, r.lats)\n",
-    "\n",
-    "    # initial_idx will add begin point to each list (but not end point to avoid dubbling) so add final endpoint manually\n",
-    "    lons = np.append(np.hstack(lons), endlong)\n",
-    "    lats = np.append(np.hstack(lats), endlat)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# check if input sample locations are within data availability area, only save if so\n",
-    "poly = Polygon([(-170, 5), (-170, -10), (-75, -10), (-75, 5)])\n",
-    "ctd_coords = []\n",
-    "drifter_coords = []\n",
-    "sample_lons = []\n",
-    "sample_lats = []\n",
-    "for coord in ctd_input:\n",
-    "    if poly.contains(Point(coord)):\n",
-    "        ctd_coords.append(coord)\n",
-    "for coord in drifter_input:\n",
-    "    if poly.contains(Point(coord)):\n",
-    "        drifter_coords.append(coord)\n",
-    "for i in range(len(lons)):\n",
-    "    if poly.contains(Point(lons[i], lats[i])):\n",
-    "        sample_lons.append(lons[i])\n",
-    "        sample_lats.append(lats[i])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Define particles and sampling functions "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create ADCP like particles to sample the ocean\n",
-    "class ADCPParticle(JITParticle):\n",
-    "    \"\"\"Define a new particle class that does ADCP like measurements\"\"\"\n",
-    "    U = Variable('U', dtype=np.float32, initial=0.0)\n",
-    "    V = Variable('V', dtype=np.float32, initial=0.0)\n",
-    "\n",
-    "# define ADCP sampling function without conversion (because of A grid)\n",
-    "def SampleVel(particle, fieldset, time):\n",
-    "    particle.U, particle.V = fieldset.UV.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)\n",
-    "    # particle.V = fieldset.V.eval(time, particle.depth, particle.lat, particle.lon, applyConversion=False)\n",
-    "\n",
-    "# Create particle to sample water underway\n",
-    "class UnderwayDataParticle(JITParticle):\n",
-    "    \"\"\"Define a new particle class that samples water directly under the hull\"\"\"\n",
-    "    salinity = Variable(\"salinity\", initial=np.nan)\n",
-    "    temperature = Variable(\"temperature\", initial=np.nan)\n",
-    "\n",
-    "# Create CTD like particles to sample the ocean\n",
-    "class CTDParticle(JITParticle):\n",
-    "    \"\"\"Define a new particle class that does CTD like measurements\"\"\"\n",
-    "    salinity = Variable(\"salinity\", initial=np.nan)\n",
-    "    temperature = Variable(\"temperature\", initial=np.nan)\n",
-    "    pressure = Variable(\"pressure\", initial=np.nan)\n",
-    "    raising = Variable(\"raising\", dtype=np.int32, initial=0.0)\n",
-    "\n",
-    "# define function lowering and raising CTD\n",
-    "def CTDcast(particle, fieldset, time):\n",
-    "    seafloor = fieldset.bathymetry[time, particle.depth, particle.lat, particle.lon]\n",
-    "    vertical_speed = 1.0  # sink and rise speed in m/s\n",
-    "\n",
-    "    if particle.raising == 0:\n",
-    "        # Sinking with vertical_speed until near seafloor\n",
-    "        particle_ddepth = vertical_speed * particle.dt\n",
-    "        if particle.depth >= (seafloor - 20): \n",
-    "            particle.raising = 1\n",
-    "\n",
-    "    if particle.raising == 1:\n",
-    "        # Rising with vertical_speed until depth is 2 m\n",
-    "        if particle.depth > 2:\n",
-    "            particle_ddepth = -vertical_speed * particle.dt  \n",
-    "            if particle.depth + particle_ddepth <= 2:\n",
-    "                # to break the loop ...\n",
-    "                particle.state = 41\n",
-    "                print(\"CTD cast finished\")\n",
-    "\n",
-    "# define function sampling Salinity\n",
-    "def SampleS(particle, fieldset, time):\n",
-    "    particle.salinity = fieldset.S[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling Temperature\n",
-    "def SampleT(particle, fieldset, time):\n",
-    "    particle.temperature = fieldset.T[time, particle.depth, particle.lat, particle.lon]\n",
-    "\n",
-    "# define function sampling Pressure\n",
-    "def SampleP(particle, fieldset, time):\n",
-    "    particle.pressure = fieldset.P[time, particle.depth, particle.lat, particle.lon]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Run simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO: Output files are stored in ./results/CTD_test_1.zarr.\n",
-      " 40%|███▉      | 5690.0/14400.0 [03:40<10:07, 14.34it/s]CTD cast finished\n",
-      " 40%|███▉      | 5690.0/14400.0 [03:40<05:36, 25.85it/s]\n"
-     ]
-    },
-    {
-     "ename": "IndexError",
-     "evalue": "list index out of range",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[45], line 49\u001b[0m\n\u001b[1;32m     46\u001b[0m     total_time \u001b[38;5;241m=\u001b[39m pset_CTD\u001b[38;5;241m.\u001b[39mtime[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m+\u001b[39m timedelta(hours\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39mtotal_seconds() \u001b[38;5;66;03m# add CTD time and 1 hour for deployment\u001b[39;00m\n\u001b[1;32m     48\u001b[0m \u001b[38;5;66;03m# check if we are at a drifter deployment location\u001b[39;00m\n\u001b[0;32m---> 49\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m (sample_lons[i] \u001b[38;5;241m-\u001b[39m \u001b[43mdrifter_coords\u001b[49m\u001b[43m[\u001b[49m\u001b[43mdrifter\u001b[49m\u001b[43m]\u001b[49m[\u001b[38;5;241m0\u001b[39m]) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0.001\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m (sample_lats[i] \u001b[38;5;241m-\u001b[39m drifter_coords[drifter][\u001b[38;5;241m1\u001b[39m]) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0.001\u001b[39m:\n\u001b[1;32m     50\u001b[0m     drifter \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m     51\u001b[0m     drifter_time\u001b[38;5;241m.\u001b[39mappend(total_time)\n",
-      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
-     ]
-    }
-   ],
-   "source": [
-    "# Create ADCP like particleset and output file\n",
-    "ADCP_bins = np.arange(5, 1000, 24)\n",
-    "vert_particles = len(ADCP_bins)\n",
-    "pset_ADCP = ParticleSet.from_list(\n",
-    "    fieldset=fieldset, pclass=ADCPParticle, lon=np.full(vert_particles,sample_lons[0]), lat=np.full(vert_particles,sample_lats[0]), depth=ADCP_bins, time=0\n",
-    ")\n",
-    "adcp_output_file = pset_ADCP.ParticleFile(name=\"./results/sailship_ADCP.zarr\")\n",
-    "adcp_dt = timedelta(minutes=5).total_seconds() # timestep of ADCP output, every 5 min == 1080 m (3.6*60*5 =m/s*s/min*min)\n",
-    "\n",
-    "# Create underway particle \n",
-    "pset_UnderwayData = ParticleSet.from_list(\n",
-    "    fieldset=fieldset, pclass=UnderwayDataParticle, lon=sample_lons[0], lat=sample_lats[0], depth=2, time=0\n",
-    ")\n",
-    "UnderwayData_output_file = pset_UnderwayData.ParticleFile(name=\"./results/sailship_UnderwayData.zarr\")\n",
-    "\n",
-    "# initialize CTD station number and time \n",
-    "total_time = timedelta(hours=0).total_seconds()\n",
-    "ctd = 0\n",
-    "ctd_dt = timedelta(seconds=10) # timestep of CTD output reflecting post-proces binning into 10m bins\n",
-    "\n",
-    "# initialize drifters and floats\n",
-    "drifter = 0\n",
-    "drifter_time = []\n",
-    "\n",
-    "# run the model for the length of the sample_lons list\n",
-    "for i in range(len(sample_lons)-1):\n",
-    "\n",
-    "    # execute the ADCP kernels to sample U and V and underway T and S\n",
-    "    pset_ADCP.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False) \n",
-    "    adcp_output_file.write(pset_ADCP, time=pset_ADCP[0].time)\n",
-    "    pset_UnderwayData.execute([SampleS, SampleT], dt=adcp_dt, runtime=1, verbose_progress=False)\n",
-    "    UnderwayData_output_file.write(pset_UnderwayData, time=pset_ADCP[0].time)\n",
-    "\n",
-    "    # check if we are at a CTD station\n",
-    "    if (sample_lons[i] - ctd_coords[ctd][0]) < 0.001 and (sample_lats[i] - ctd_coords[ctd][1]) < 0.001:\n",
-    "        ctd += 1\n",
-    "        \n",
-    "        # release CTD particle\n",
-    "        pset_CTD = ParticleSet(fieldset=fieldset, pclass=CTDParticle, lon=sample_lons[i], lat=sample_lats[i], depth=2, time=total_time)\n",
-    "\n",
-    "        # create a ParticleFile to store the CTD output\n",
-    "        ctd_output_file = pset_CTD.ParticleFile(name=f\"./results/CTD_test_{ctd}.zarr\", outputdt=ctd_dt)\n",
-    "\n",
-    "        # record the temperature and salinity of the particle\n",
-    "        pset_CTD.execute([SampleS, SampleT, CTDcast], runtime=timedelta(hours=4), dt=ctd_dt, output_file=ctd_output_file)\n",
-    "        total_time = pset_CTD.time[0] + timedelta(hours=1).total_seconds() # add CTD time and 1 hour for deployment\n",
-    "\n",
-    "    # check if we are at a drifter deployment location\n",
-    "    if drifter < len(drifter_coords):\n",
-    "        while (sample_lons[i] - drifter_coords[drifter][0]) < 0.001 and (sample_lats[i] - drifter_coords[drifter][1]) < 0.001:\n",
-    "            drifter += 1\n",
-    "            drifter_time.append(total_time)\n",
-    "\n",
-    "    # update the particle time and location\n",
-    "    pset_ADCP.lon_nextloop[:] = sample_lons[i+1]\n",
-    "    pset_ADCP.lat_nextloop[:] = sample_lats[i+1]\n",
-    "    pset_UnderwayData.lon_nextloop[:] = sample_lons[i+1]\n",
-    "    pset_UnderwayData.lat_nextloop[:] = sample_lats[i+1]    \n",
-    "    \n",
-    "    total_time += adcp_dt\n",
-    "    pset_ADCP.time_nextloop[:] = total_time\n",
-    "    pset_UnderwayData.time_nextloop[:] = total_time\n",
-    "    if i % 48 == 0:\n",
-    "        print(f\"Gathered data {pset_ADCP[0].time/3600} hours since start\")\n",
-    "\n",
-    "# write the final locations of the ADCP and Underway data particles\n",
-    "pset_ADCP.execute(SampleVel, dt=adcp_dt, runtime=1, verbose_progress=False)\n",
-    "adcp_output_file.write_latest_locations(pset_ADCP, time=total_time)\n",
-    "pset_UnderwayData.execute([SampleS, SampleT], dt=adcp_dt, runtime=1, verbose_progress=False)\n",
-    "UnderwayData_output_file.write_latest_locations(pset_UnderwayData, time=total_time)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[9290.0, 9290.0, 9290.0, 9290.0, 9290.0, 9290.0]"
-      ]
-     },
-     "execution_count": 48,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "drifter_time"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_zarr(\"../results/sailship_ADCP.zarr\")\n",
-    "time = ds[\"time\"][0].values\n",
-    "x = ds[\"lon\"][:].squeeze()\n",
-    "y = ds[\"lat\"][:].squeeze()\n",
-    "z = ds[\"z\"][:].squeeze()\n",
-    "U = ds[\"U\"][:].squeeze()\n",
-    "V = ds[\"V\"][:].squeeze()\n",
-    "ds.close()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([[ 0.21141048,  0.21073838,  0.21154574, ..., -0.05740462,\n",
-       "        -0.05878886, -0.06029826],\n",
-       "       [ 0.22115852,  0.22025768,  0.22080159, ..., -0.06844132,\n",
-       "        -0.07026841, -0.07221974],\n",
-       "       [ 0.23090656,  0.229777  ,  0.23005745, ..., -0.07947803,\n",
-       "        -0.08174795, -0.08414122],\n",
-       "       ...,\n",
-       "       [ 0.15958248,  0.15866159,  0.16019139, ..., -0.16439535,\n",
-       "        -0.16591409, -0.16754586],\n",
-       "       [ 0.13169025,  0.13092402,  0.13297619, ..., -0.1893431 ,\n",
-       "        -0.19044396, -0.19165468],\n",
-       "       [ 0.10379802,  0.10318644,  0.10576099, ..., -0.21429083,\n",
-       "        -0.21497384, -0.2157635 ]], dtype=float32)"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ds.V[1:10].values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'ax' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[9], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m cu \u001b[38;5;241m=\u001b[39m ax1\u001b[38;5;241m.\u001b[39mscatter(x, y, z\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m10\u001b[39m, c\u001b[38;5;241m=\u001b[39mU, s\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m20\u001b[39m, marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mo\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      7\u001b[0m cv \u001b[38;5;241m=\u001b[39m ax2\u001b[38;5;241m.\u001b[39mscatter(x, y, z\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m10\u001b[39m, c\u001b[38;5;241m=\u001b[39mV, s\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m20\u001b[39m, marker\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mo\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m \u001b[43max\u001b[49m\u001b[38;5;241m.\u001b[39mset_xlabel(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLongitude\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      9\u001b[0m ax\u001b[38;5;241m.\u001b[39mset_ylabel(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mLatitude\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     10\u001b[0m ax\u001b[38;5;241m.\u001b[39mset_zlabel(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDepth (m)\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'ax' is not defined"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 4 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "# Plot Particle depth\n",
-    "fig, (ax1, ax2) = plt.subplots(1, 2)\n",
-    "ax1 = plt.axes(projection=\"3d\")\n",
-    "ax2 = plt.axes(projection=\"3d\")\n",
-    "cu = ax1.scatter(x, y, z*10, c=U, s=20, marker=\"o\")\n",
-    "cv = ax2.scatter(x, y, z*10, c=V, s=20, marker=\"o\")\n",
-    "ax.set_xlabel(\"Longitude\")\n",
-    "ax.set_ylabel(\"Latitude\")\n",
-    "ax.set_zlabel(\"Depth (m)\")\n",
-    "ax.set_zlim(np.max(z), 0)\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "FileNotFoundError",
-     "evalue": "No such file or directory: '/storage/home/0448257/Virtual_ship_classroom/results/CTD_3.zarr'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/xarray/backends/zarr.py:429\u001b[0m, in \u001b[0;36mZarrStore.open_group\u001b[0;34m(cls, store, mode, synchronizer, group, consolidated, consolidate_on_close, chunk_store, storage_options, append_dim, write_region, safe_chunks, stacklevel, zarr_version, write_empty)\u001b[0m\n\u001b[1;32m    428\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 429\u001b[0m     zarr_group \u001b[38;5;241m=\u001b[39m \u001b[43mzarr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen_consolidated\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstore\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mopen_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    430\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m:\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/zarr/convenience.py:1351\u001b[0m, in \u001b[0;36mopen_consolidated\u001b[0;34m(store, metadata_key, mode, **kwargs)\u001b[0m\n\u001b[1;32m   1350\u001b[0m \u001b[38;5;66;03m# setup metadata store\u001b[39;00m\n\u001b[0;32m-> 1351\u001b[0m meta_store \u001b[38;5;241m=\u001b[39m \u001b[43mConsolidatedStoreClass\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstore\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata_key\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetadata_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1353\u001b[0m \u001b[38;5;66;03m# pass through\u001b[39;00m\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/zarr/storage.py:2947\u001b[0m, in \u001b[0;36mConsolidatedMetadataStore.__init__\u001b[0;34m(self, store, metadata_key)\u001b[0m\n\u001b[1;32m   2946\u001b[0m \u001b[38;5;66;03m# retrieve consolidated metadata\u001b[39;00m\n\u001b[0;32m-> 2947\u001b[0m meta \u001b[38;5;241m=\u001b[39m json_loads(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstore\u001b[49m\u001b[43m[\u001b[49m\u001b[43mmetadata_key\u001b[49m\u001b[43m]\u001b[49m)\n\u001b[1;32m   2949\u001b[0m \u001b[38;5;66;03m# check format of consolidated metadata\u001b[39;00m\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/zarr/storage.py:1113\u001b[0m, in \u001b[0;36mDirectoryStore.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m   1112\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1113\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key)\n",
-      "\u001b[0;31mKeyError\u001b[0m: '.zmetadata'",
-      "\nDuring handling of the above exception, another exception occurred:\n",
-      "\u001b[0;31mGroupNotFoundError\u001b[0m                        Traceback (most recent call last)",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/xarray/backends/zarr.py:432\u001b[0m, in \u001b[0;36mZarrStore.open_group\u001b[0;34m(cls, store, mode, synchronizer, group, consolidated, consolidate_on_close, chunk_store, storage_options, append_dim, write_region, safe_chunks, stacklevel, zarr_version, write_empty)\u001b[0m\n\u001b[1;32m    431\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 432\u001b[0m     zarr_group \u001b[38;5;241m=\u001b[39m \u001b[43mzarr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen_group\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstore\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mopen_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    433\u001b[0m     warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m    434\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFailed to open Zarr store with consolidated metadata, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    435\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbut successfully read with non-consolidated metadata. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    446\u001b[0m         stacklevel\u001b[38;5;241m=\u001b[39mstacklevel,\n\u001b[1;32m    447\u001b[0m     )\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/zarr/hierarchy.py:1532\u001b[0m, in \u001b[0;36mopen_group\u001b[0;34m(store, mode, cache_attrs, synchronizer, path, chunk_store, storage_options, zarr_version, meta_array)\u001b[0m\n\u001b[1;32m   1531\u001b[0m             \u001b[38;5;28;01mraise\u001b[39;00m ContainsArrayError(path)\n\u001b[0;32m-> 1532\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m GroupNotFoundError(path)\n\u001b[1;32m   1534\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n",
-      "\u001b[0;31mGroupNotFoundError\u001b[0m: group not found at path ''",
-      "\nDuring handling of the above exception, another exception occurred:\n",
-      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[11], line 10\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;66;03m# rewrite CTD data to cvs\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, ctd):\n\u001b[1;32m      8\u001b[0m     \n\u001b[1;32m      9\u001b[0m     \u001b[38;5;66;03m# Open output and read to x, y, z\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m     ds \u001b[38;5;241m=\u001b[39m \u001b[43mxr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen_zarr\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m../results/CTD_\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mi\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m.zarr\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     11\u001b[0m     x \u001b[38;5;241m=\u001b[39m ds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlon\u001b[39m\u001b[38;5;124m\"\u001b[39m][:]\u001b[38;5;241m.\u001b[39msqueeze()\n\u001b[1;32m     12\u001b[0m     y \u001b[38;5;241m=\u001b[39m ds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlat\u001b[39m\u001b[38;5;124m\"\u001b[39m][:]\u001b[38;5;241m.\u001b[39msqueeze()\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/xarray/backends/zarr.py:898\u001b[0m, in \u001b[0;36mopen_zarr\u001b[0;34m(store, group, synchronizer, chunks, decode_cf, mask_and_scale, decode_times, concat_characters, decode_coords, drop_variables, consolidated, overwrite_encoded_chunks, chunk_store, storage_options, decode_timedelta, use_cftime, zarr_version, chunked_array_type, from_array_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m    884\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m    885\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mopen_zarr() got unexpected keyword arguments \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(kwargs\u001b[38;5;241m.\u001b[39mkeys())\n\u001b[1;32m    886\u001b[0m     )\n\u001b[1;32m    888\u001b[0m backend_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m    889\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msynchronizer\u001b[39m\u001b[38;5;124m\"\u001b[39m: synchronizer,\n\u001b[1;32m    890\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconsolidated\u001b[39m\u001b[38;5;124m\"\u001b[39m: consolidated,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    895\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mzarr_version\u001b[39m\u001b[38;5;124m\"\u001b[39m: zarr_version,\n\u001b[1;32m    896\u001b[0m }\n\u001b[0;32m--> 898\u001b[0m ds \u001b[38;5;241m=\u001b[39m \u001b[43mopen_dataset\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    899\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    900\u001b[0m \u001b[43m    \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    901\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdecode_cf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_cf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    902\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmask_and_scale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmask_and_scale\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    903\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdecode_times\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_times\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    904\u001b[0m \u001b[43m    \u001b[49m\u001b[43mconcat_characters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconcat_characters\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    905\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdecode_coords\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_coords\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    906\u001b[0m \u001b[43m    \u001b[49m\u001b[43mengine\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mzarr\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    907\u001b[0m \u001b[43m    \u001b[49m\u001b[43mchunks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    908\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdrop_variables\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdrop_variables\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    909\u001b[0m \u001b[43m    \u001b[49m\u001b[43mchunked_array_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked_array_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    910\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfrom_array_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfrom_array_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    911\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbackend_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    912\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdecode_timedelta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_timedelta\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    913\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cftime\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cftime\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    914\u001b[0m \u001b[43m    \u001b[49m\u001b[43mzarr_version\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzarr_version\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    915\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    916\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ds\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/xarray/backends/api.py:573\u001b[0m, in \u001b[0;36mopen_dataset\u001b[0;34m(filename_or_obj, engine, chunks, cache, decode_cf, mask_and_scale, decode_times, decode_timedelta, use_cftime, concat_characters, decode_coords, drop_variables, inline_array, chunked_array_type, from_array_kwargs, backend_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m    561\u001b[0m decoders \u001b[38;5;241m=\u001b[39m _resolve_decoders_kwargs(\n\u001b[1;32m    562\u001b[0m     decode_cf,\n\u001b[1;32m    563\u001b[0m     open_backend_dataset_parameters\u001b[38;5;241m=\u001b[39mbackend\u001b[38;5;241m.\u001b[39mopen_dataset_parameters,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    569\u001b[0m     decode_coords\u001b[38;5;241m=\u001b[39mdecode_coords,\n\u001b[1;32m    570\u001b[0m )\n\u001b[1;32m    572\u001b[0m overwrite_encoded_chunks \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moverwrite_encoded_chunks\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[0;32m--> 573\u001b[0m backend_ds \u001b[38;5;241m=\u001b[39m \u001b[43mbackend\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen_dataset\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    574\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    575\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdrop_variables\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdrop_variables\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    576\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdecoders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    577\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    578\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    579\u001b[0m ds \u001b[38;5;241m=\u001b[39m _dataset_from_backend_dataset(\n\u001b[1;32m    580\u001b[0m     backend_ds,\n\u001b[1;32m    581\u001b[0m     filename_or_obj,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    591\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m    592\u001b[0m )\n\u001b[1;32m    593\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ds\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/xarray/backends/zarr.py:965\u001b[0m, in \u001b[0;36mZarrBackendEntrypoint.open_dataset\u001b[0;34m(self, filename_or_obj, mask_and_scale, decode_times, concat_characters, decode_coords, drop_variables, use_cftime, decode_timedelta, group, mode, synchronizer, consolidated, chunk_store, storage_options, stacklevel, zarr_version)\u001b[0m\n\u001b[1;32m    944\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mopen_dataset\u001b[39m(  \u001b[38;5;66;03m# type: ignore[override]  # allow LSP violation, not supporting **kwargs\u001b[39;00m\n\u001b[1;32m    945\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    946\u001b[0m     filename_or_obj: \u001b[38;5;28mstr\u001b[39m \u001b[38;5;241m|\u001b[39m os\u001b[38;5;241m.\u001b[39mPathLike[Any] \u001b[38;5;241m|\u001b[39m BufferedIOBase \u001b[38;5;241m|\u001b[39m AbstractDataStore,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    962\u001b[0m     zarr_version\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m    963\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Dataset:\n\u001b[1;32m    964\u001b[0m     filename_or_obj \u001b[38;5;241m=\u001b[39m _normalize_path(filename_or_obj)\n\u001b[0;32m--> 965\u001b[0m     store \u001b[38;5;241m=\u001b[39m \u001b[43mZarrStore\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen_group\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    966\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    967\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    968\u001b[0m \u001b[43m        \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    969\u001b[0m \u001b[43m        \u001b[49m\u001b[43msynchronizer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msynchronizer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    970\u001b[0m \u001b[43m        \u001b[49m\u001b[43mconsolidated\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mconsolidated\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    971\u001b[0m \u001b[43m        \u001b[49m\u001b[43mconsolidate_on_close\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    972\u001b[0m \u001b[43m        \u001b[49m\u001b[43mchunk_store\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunk_store\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    973\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstorage_options\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    974\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstacklevel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstacklevel\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    975\u001b[0m \u001b[43m        \u001b[49m\u001b[43mzarr_version\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzarr_version\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    976\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    978\u001b[0m     store_entrypoint \u001b[38;5;241m=\u001b[39m StoreBackendEntrypoint()\n\u001b[1;32m    979\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m close_on_error(store):\n",
-      "File \u001b[0;32m~/miniconda3/envs/parcels/lib/python3.11/site-packages/xarray/backends/zarr.py:449\u001b[0m, in \u001b[0;36mZarrStore.open_group\u001b[0;34m(cls, store, mode, synchronizer, group, consolidated, consolidate_on_close, chunk_store, storage_options, append_dim, write_region, safe_chunks, stacklevel, zarr_version, write_empty)\u001b[0m\n\u001b[1;32m    433\u001b[0m             warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m    434\u001b[0m                 \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFailed to open Zarr store with consolidated metadata, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    435\u001b[0m                 \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbut successfully read with non-consolidated metadata. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    446\u001b[0m                 stacklevel\u001b[38;5;241m=\u001b[39mstacklevel,\n\u001b[1;32m    447\u001b[0m             )\n\u001b[1;32m    448\u001b[0m         \u001b[38;5;28;01mexcept\u001b[39;00m zarr\u001b[38;5;241m.\u001b[39merrors\u001b[38;5;241m.\u001b[39mGroupNotFoundError:\n\u001b[0;32m--> 449\u001b[0m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mFileNotFoundError\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo such file or directory: \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mstore\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    450\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m consolidated:\n\u001b[1;32m    451\u001b[0m     \u001b[38;5;66;03m# TODO: an option to pass the metadata_key keyword\u001b[39;00m\n\u001b[1;32m    452\u001b[0m     zarr_group \u001b[38;5;241m=\u001b[39m zarr\u001b[38;5;241m.\u001b[39mopen_consolidated(store, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mopen_kwargs)\n",
-      "\u001b[0;31mFileNotFoundError\u001b[0m: No such file or directory: '/storage/home/0448257/Virtual_ship_classroom/results/CTD_3.zarr'"
-     ]
-    }
-   ],
-   "source": [
-    "import xarray as xr\n",
-    "import numpy as np\n",
-    "from scipy.ndimage import uniform_filter1d\n",
-    "\n",
-    "ctd = 10\n",
-    "# rewrite CTD data to cvs\n",
-    "for i in range(1, ctd):\n",
-    "    \n",
-    "    # Open output and read to x, y, z\n",
-    "    ds = xr.open_zarr(f\"../results/CTD_{i}.zarr\")\n",
-    "    x = ds[\"lon\"][:].squeeze()\n",
-    "    y = ds[\"lat\"][:].squeeze()\n",
-    "    z = ds[\"z\"][:].squeeze()\n",
-    "    time = ds[\"time\"][:].squeeze()\n",
-    "    T = ds[\"temperature\"][:].squeeze()\n",
-    "    S = ds[\"salinity\"][:].squeeze()\n",
-    "    ds.close()\n",
-    "\n",
-    "    # add some noise\n",
-    "    random_walk = np.random.random()/10\n",
-    "    z_norm = (z-np.min(z))/(np.max(z)-np.min(z))\n",
-    "    t_norm = np.linspace(0, 1, num=len(time))\n",
-    "    # dS = abs(np.append(0, np.diff(S))) # scale noise with gradient\n",
-    "    # for j in range(5, 0, -1):\n",
-    "    #     dS[dS<1*10**-j] = 0.5-j/10\n",
-    "    # add smoothed random noise scaled with depth (and OPTIONAL with gradient for S) \n",
-    "    # and random (reversed) diversion from initial through time scaled with depth \n",
-    "    S = S + uniform_filter1d(\n",
-    "        np.random.random(S.shape)/5*(1-z_norm) + \n",
-    "        random_walk*(np.max(S).values - np.min(S).values)*(1-z_norm)*t_norm/10, \n",
-    "        max(int(len(time)/40), 1))\n",
-    "    T = T + uniform_filter1d(\n",
-    "        np.random.random(T.shape)*5*(1-z_norm) - \n",
-    "        random_walk/2*(np.max(T).values - np.min(T).values)*(1-z_norm)*t_norm/10, \n",
-    "        max(int(len(time)/20), 1))\n",
-    "\n",
-    "    # reshaping data to export to csv\n",
-    "    header = f\"'pressure [hPa]','temperature [degC]', 'salinity [g kg-1]'\"\n",
-    "    data = np.column_stack([(z/10), T, S])\n",
-    "    new_line = '\\n'\n",
-    "    np.savetxt(f\"../results/CTD_station_{i}.csv\", data, fmt=\"%.4f\", header=header, delimiter=',', \n",
-    "               comments=f'{x.attrs}{new_line}{x[0].values}{new_line}{y.attrs}{new_line}{y[0].values}{new_line}start time: {time[0].values}{new_line}end time: {time[-1].values}{new_line}')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(['-86.8798828125'], '4.258768081665039')"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lon = []\n",
-    "lat = []\n",
-    "with open('../results/CTD_station_2.csv', 'r') as file:\n",
-    "    text = file.read().splitlines()\n",
-    "lon.append(text[1])\n",
-    "lat = text[3]\n",
-    "lon, lat"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Some sample code you can use, you only have to replace the <...> instances to make it work\n",
-    "lon = []\n",
-    "lat = []\n",
-    "z20 = []\n",
-    "\n",
-    "import numpy as np\n",
-    "for i in range(1, 20):\n",
-    "    with open(f'../results/CTDs/CTD_station_{i}.csv', 'r') as file:\n",
-    "        station_data = file.read().splitlines()\n",
-    "    lon.append(station_data[0].split(',')[1])\n",
-    "    lat.append(station_data[1].split(',')[1])\n",
-    "\n",
-    "    P, T, S = np.loadtxt(f'../results/CTDs/CTD_station_{i}.csv', delimiter=',', skiprows=7, unpack=True)\n",
-    "    z20.append(P[T<20][0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "32.14093780517578\n"
-     ]
-    }
-   ],
-   "source": [
-    "with open(f'../results/CTDs/CTD_station_{i}.csv', 'r') as file:\n",
-    "    station_data = file.read().splitlines()\n",
-    "    print(station_data[1].split(',')[1])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[7.2, 9.2, 8.2]"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# z20 = P[T<20][0]\n",
-    "z20"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<Axes: >"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# lat = [1, 2, 3, 4, 5]\n",
-    "# lon = [-80, -90, -100, -110, -120]\n",
-    "# z20 = [1, 2, 3, 4, 5]\n",
-    "import pandas as pd\n",
-    "import geopandas as gpd\n",
-    "df = pd.DataFrame({'lat': lat, 'lon': lon, 'z20': z20})\n",
-    "gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(lon, lat))  \n",
-    "gdf.plot(column='z20', legend=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ModuleNotFoundError",
-     "evalue": "No module named 'cloupy'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
-      "\u001b[1;32m/nethome/0448257/Virtual_ship_classroom/sailship.ipynb Cell 19\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Blorenz/nethome/0448257/Virtual_ship_classroom/sailship.ipynb#X26sdnNjb2RlLXJlbW90ZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mcloupy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mcl\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Blorenz/nethome/0448257/Virtual_ship_classroom/sailship.ipynb#X26sdnNjb2RlLXJlbW90ZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mnumpy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mnp\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Blorenz/nethome/0448257/Virtual_ship_classroom/sailship.ipynb#X26sdnNjb2RlLXJlbW90ZQ%3D%3D?line=3'>4</a>\u001b[0m imap \u001b[39m=\u001b[39m cl\u001b[39m.\u001b[39mm_MapInterpolation(\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Blorenz/nethome/0448257/Virtual_ship_classroom/sailship.ipynb#X26sdnNjb2RlLXJlbW90ZQ%3D%3D?line=4'>5</a>\u001b[0m     dataframe\u001b[39m=\u001b[39mgdf\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2Blorenz/nethome/0448257/Virtual_ship_classroom/sailship.ipynb#X26sdnNjb2RlLXJlbW90ZQ%3D%3D?line=5'>6</a>\u001b[0m )\n",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'cloupy'"
-     ]
-    }
-   ],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Read back in... student example\n",
-    "import numpy as np\n",
-    "z, T, S = np.loadtxt('../results/CTD_station_1.csv', delimiter=',', skiprows=7, unpack=True)\n",
-    "\n",
-    "# TS plot\n",
-    "import matplotlib.pyplot as plt\n",
-    "fig, ax1 = plt.subplots(1,1)\n",
-    "ax1.plot(S[int(len(z)/2):-1], z[int(len(z)/2):-1], color=\"lightblue\")\n",
-    "ax1.plot(S[0:int(len(z)/2)], z[0:int(len(z)/2)], color=\"b\")\n",
-    "ax1.invert_yaxis()\n",
-    "ax1.set_xlabel('Salinity', color = \"b\")\n",
-    "ax1.set_ylabel('Pressure (hPa)')\n",
-    "ax2 = ax1.twiny() # ax1 and ax2 share y-axis\n",
-    "ax2.set_xlabel('Temperature', color = \"r\")\n",
-    "ax2.plot(T[int(len(z)/2):-1], z[int(len(z)/2):-1], color=\"orange\")\n",
-    "ax2.plot(T[0:int(len(z)/2)], z[0:int(len(z)/2)], color=\"r\") \n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[7.2, 7.2, 9.2, 11.2, 15.2, 15.2, 15.2, 15.2, 15.2]"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Some sample code you can use\n",
-    "lon = []\n",
-    "lat = []\n",
-    "z20 = []\n",
-    "\n",
-    "for i in range(1, 10):\n",
-    "    with open(f'./results/CTD_station_{i}.csv', 'r') as file:\n",
-    "        station_data = file.read().splitlines()\n",
-    "    lon.append(station_data[1])\n",
-    "    lat.append(station_data[3])\n",
-    "\n",
-    "    P, T, S = np.loadtxt(f'./results/CTD_station_{i}.csv', delimiter=',', skiprows=7, unpack=True)\n",
-    "    z20.append(P[T < 20][0])\n",
-    "\n",
-    "# Look up or calculate z20 or plot the profile and determine from there\n",
-    "z20"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<Axes: >"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAGdCAYAAACGtNCDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzrklEQVR4nO3de3xU9Z3/8feEkEkImdEQQogEiFVAwWKKtKCIQQSNFHXtemN/SrStdEmiNmprrNVoF+MVcaWKWgwiwroqInUpiMslUoFCSIR6QegGiEAErU1IkIRkvr8/IlOO5DZnJjOT4fXs4zzKuXzP+cwhmM98P9/vOQ5jjBEAAMC3okIdAAAACC8kBwAAwILkAAAAWJAcAAAAC5IDAABgQXIAAAAsSA4AAIAFyQEAALCIDnUAHeHxeLRv3z4lJCTI4XCEOhwAQBgzxujQoUNKTU1VVFTnfAc+cuSIGhoaAnKumJgYxcbGBuRcgdIlkoN9+/YpLS0t1GEAALqQyspK9evXL+DnPXLkiNIH9FTVgaaAnC8lJUUVFRVhlSB0ieQgISFBUvNftMvlCnE0AIBwVlNTo7S0NO/vjkBraGhQ1YEmVZQOkCvBv56JmkMepY/YrYaGBpIDXx0rJbhcLpIDAECHdHYZ2pUQ5XdyEK66RHIAAEC4aTIeNfn56sIm4wlMMAFGcgAAgA0eGXnkX3bgb/vOEpn9IQAAdDJPgP7ni5KSEk2ePFmpqalyOBxasmSJZX92drYcDodlGTVqlM+fjeQAAIAuoq6uTsOHD9fs2bNbPeayyy7T/v37vcuyZct8vg5lBQAAbGgyRk3Gv7KAr+2zsrKUlZXV5jFOp1MpKSn+hEXPAQAAdhwbc+DvIjVPvzx+qa+vtx3XmjVrlJycrEGDBunnP/+5Dhw44PM5SA4AAAixtLQ0ud1u71JUVGTrPFlZWXr11Ve1atUqPfnkk9q0aZMuvvhin5MNygoAANjgkVFTgGYrfPchf06n09b5rrvuOu+fhw0bpvPOO08DBgzQ//zP/+jqq6/u8HlOmuTANFZKR8skOaSYkXJ0868eg5Z9/c03+qByjxqamnRW794aktQ71CFFpPqGRm36cLcO1X6jvsluDT+7H+8d6QQej0db136sA3u+lDspQRmXfF8xzu6hDivieDwebXv/E32x66ASEntqxITvKyY2JtRhtSuQUxk76yF/ffv21YABA7Rjxw6f2vmUHBQVFWnx4sX69NNPFRcXp/PPP1+PPvqoBg8e3GqbNWvWaNy4cSds/+STTzRkyBCfgrXDeP4uU32vVL9a8v4lRsk4L5XD/R9yRHXO4zVPNg1NTSp6f60Wbtuqo55/Ts3JSOmrJyZepvRTTw1hdJHDGKM3l5XpD4v+rNrD/+wmPK3PKfrV9IkacU7/EEYXWf7ypzI9Pf1FHdh90LstIbGnfvrwFE26dUIII4ssW97bqqemPa+qin/WxXueEq+pD12nK3MuI+n101dffaXKykr17dvXp3Y+jTlYu3atcnJytGHDBq1cuVKNjY2aOHGi6urq2m27fft2y9SKM88806dA7TCewzJf/T+pfq1kye48Uv0Kmb9ny5jAvFXrZGaMUf6KP2n+h+WWxECStn5RpWte/y9V1R4KUXSR5b+WbtasuassiYEk7TtQrfwHX9eHn3weosgiy5b3tuq+yUU6uOdLy/ZDf6/VrF+8oD8+tyJEkUWWD9d+pHsvn6EvjkvAJKn2H3X6/W0v6a2nfZ+CF0zHZiv4u/iitrZW5eXlKi8vlyRVVFSovLxce/bsUW1tre666y6tX79eu3bt0po1azR58mQlJSXpX/7lX3y6jk/JwfLly5Wdna2hQ4dq+PDhKi4u1p49e1RaWtpu2+TkZKWkpHiXbt26+RSoLUfekpr+JqmlN2d5pMZt0hH+kftr6xdVWrbjsxY715qMUfWRI3qxAz8jaFttXb1eXPTnFvcZY2SM9OzLa4McVeQxxui5/HmSaf5zS/5Q8KqOHLY/mhzNXvzVAnk8RsbT8n1+6b5FOnzomyBH1XGeAC2+2Lx5szIyMpSRkSFJys/PV0ZGhu6//35169ZN27Zt05VXXqlBgwZp6tSpGjRokNavX+/zS6j8mq1QXV0tSUpMTGz32IyMDPXt21fjx4/X6tWr/blsh5nDb7RzRJTMN+0dg/Ys/uRjdWuj66/JGL3+8V9b/Q8tOqZk4w41NDS2ut9jjD76bL/2Vv0jeEFFoF0fVWrXXyvb/Hk9XPONNr5DwuuPz3fs1/ZNO1tNDCSp/nC9/rzkL0GMKvxlZmZ++2XAusybN09xcXFasWKFDhw4oIaGBu3evVvz5s1TWlqaz9exPSDRGKP8/HyNGTNGw4YNa/W4vn376oUXXtCIESNUX1+vV155RePHj9eaNWs0duzYFtvU19dbpl3U1NTYC9JzUGpzsIhHavrC3rnhdfDwYXna+cVf29Cgox6PYoLRYxShvvpHnbpFOdTUxn9MJenv/6jTaSmnBCeoCPR1B5IrR5RDfycJ80tH7nNUt6gOHRcqTQGYreBv+85iOznIzc3V1q1btW7dujaPGzx4sGXA4ujRo1VZWaknnnii1eSgqKhIDz74oN3Q/imqTzsJQpTUzbdBGjhRn/h4RTkcbdbOXE4niYGfkk7t2W5iIElJiT2DEE3k6pXa/uBZ4zFKOq39HlO0riP32dPkCev73GQUgLcyBiaWQLNVVsjLy9PSpUu1evVq9evXz+f2o0aNanNaRUFBgaqrq71LZWWlnTDl6HGN2us5cMRdY+vc+KefnD20zcSgm8Oh64edE8SIItNFo85UrLP1fD4qyqHhZ/dT32R3EKOKPAPOTtOZPzhdjqjWS2Xx7h760aQfBDGqyJP6vRSdPXqQotq4z3E9YzX6ypFBjMo3oRhzECw+JQfGGOXm5mrx4sVatWqV0tPTbV20rKyszWkVTqfTO+fTr7mfcVdJ0WdLaukba5TUfYQUy5Qkfw1L7qOrzzpbLf0T7+ZwKKlHD/00Y0TQ44o0PeJi9O83XdTiPofDoW5RDuVMbXk/fPPvT2UrKiqq1QThFzOzu8Q8/HA37cmpioru1up9/vljNyouPjbIUUHyMTnIycnRggULtHDhQiUkJKiqqkpVVVX65pt/jiYtKCjQTTfd5F2fNWuWlixZoh07duijjz5SQUGB3nzzTeXm5gbuU7TC4YiVI3G+FJsl60eNlmKvluPUuXI4eKBJIDxyyUT9+8gfKi7a+s12dFqa3rj2BvWOjw9RZJHlJ1kZuifnUp3q7mHZfnr/Xnrmd9fr7DMpkwXCOReepUff/a3SBqdatvdKPVUFC27TZTef+OwW+O7sUYP0+P8+oAFnW3ugT005RXe9NF2TfzExRJF1jEcONfm5eFr8WhV6DuPDEPLWHkZRXFys7OxsSc3vkj42v1KSHnvsMb3wwgvau3ev4uLiNHToUBUUFOjyyy/vcJA1NTVyu92qrq623Ytgmg5KRz9U8xMSM+SICt86VldW19CgTfv2qr6xUUOSemvAKaeEOqSI1Njk0daPP1dN7RGl9nHrzPRkHhbTCYwx+qz0/3Rg90G5khI0bMyQ4EzDPskYY7SzrEJVFQfk6vXtfY62f58D8TujI+ff/FEf9Uzw7xVFtYc8Om/oF50Wq10+JQeh0tl/0QCAyEFy4L+T5t0KAAAE0rHSgL/nCEckBwAA2BDJyYF//SEAACDi0HMAAIANHuOQx/j3zd/f9p2F5AAAABsoKwAAgJMGPQcAANjQpCg1+fkduylAsQQayQEAADaYAIw5MIw5AAAgcjDmAAAAnDToOQAAwIYmE6Um4+eYgzB9gQHJAQAANnjkkMfPDniPwjM7oKwAAAAs6DkAAMCGSB6QSHIAAIANgRlzQFkBAAB0AfQcAABgQ/OARD9fvERZAQCAyOEJwOOTma0AAAC6BHoOAACwIZIHJJIcAABgg0dREfsQJJIDAABsaDIONfn5VkV/23cWxhwAAAALeg4AALChKQCzFZooKwAAEDk8JkoePwckesJ0QCJlBQAAYEHPAQAANlBWAAAAFh75P9vAE5hQAo6yAgAAXURJSYkmT56s1NRUORwOLVmypNVjp02bJofDoVmzZvl8HZIDAABsOPYQJH8XX9TV1Wn48OGaPXt2m8ctWbJEGzduVGpqqq3PRlkBAAAbAvP4ZN/aZ2VlKSsrq81j9u7dq9zcXK1YsUKTJk2yFRfJAQAAIVZTU2NZdzqdcjqdPp/H4/Hoxhtv1N13362hQ4fajoeyAgAANnjkCMgiSWlpaXK73d6lqKjIVkyPPvqooqOjddttt/n12eg5AADAhkCWFSorK+Vyubzb7fQalJaW6umnn9aWLVvkcPg3i4KeAwAAbDj2nAN/F0lyuVyWxU5y8P777+vAgQPq37+/oqOjFR0drd27d+vOO+/UwIEDfToXPQcAAESAG2+8UZdccoll26WXXqobb7xRN998s0/nIjkAAMAGj3HI4+9DkHxsX1tbq507d3rXKyoqVF5ersTERPXv31+9evWyHN+9e3elpKRo8ODBPl2H5AAAABs8AXh8sq/POdi8ebPGjRvnXc/Pz5ckTZ06VfPmzfMrluORHAAA0EVkZmbK+PAmx127dtm6DskBAAA2BOaVzeE5L4DkAAAAG5rkUJP8G3Pgb/vOEp4pCwAACBl6DgAAsIGyAgAAsGiS/2WBpsCEEnDhmbIAAICQoecAAAAbKCsAAACLQL54KdyQHAAAYIM57pXL/pwjHIVnygIAAEKGngMAAGygrAAAACxC8VbGYAnPlAUAAIQMPQcAANjQFIBXNvvbvrOQHAAAYANlBQAAcNKg5wAAABs8ipLHz+/Y/rbvLCQHAADY0GQcavKzLOBv+87iU8pSVFSkkSNHKiEhQcnJybrqqqu0ffv2Drf/85//rOjoaJ177rm+xgkAAILEp+Rg7dq1ysnJ0YYNG7Ry5Uo1NjZq4sSJqqura7dtdXW1brrpJo0fP952sAAAhItjAxL9XcKRT2WF5cuXW9aLi4uVnJys0tJSjR07ts2206ZN05QpU9StWzctWbLE50ABAAgnJgBvZTRh+oREv6Kqrq6WJCUmJrZ5XHFxsf72t7/pgQce6NB56+vrVVNTY1kAAAgnTXIEZAlHtpMDY4zy8/M1ZswYDRs2rNXjduzYoXvuuUevvvqqoqM71lFRVFQkt9vtXdLS0uyGCQAAfGQ7OcjNzdXWrVu1aNGiVo9pamrSlClT9OCDD2rQoEEdPndBQYGqq6u9S2Vlpd0wAQDoFB4TiHEHof4ULbM1lTEvL09Lly5VSUmJ+vXr1+pxhw4d0ubNm1VWVqbc3FxJksfjkTFG0dHRevfdd3XxxRef0M7pdMrpdNoJDQCAoPAEYMyBv+07i0/JgTFGeXl5euutt7RmzRqlp6e3ebzL5dK2bdss25599lmtWrVKb7zxRrvtAQBA8PmUHOTk5GjhwoV6++23lZCQoKqqKkmS2+1WXFycpOaSwN69ezV//nxFRUWdMB4hOTlZsbGxbY5TAAAg3HnkkMfPAYX+tu8sPiUHzz33nCQpMzPTsr24uFjZ2dmSpP3792vPnj0BCQ4AgHAVyU9I9Lms0J558+a1ub+wsFCFhYW+XBYAAAQR71YAAMAGBiQCAAALj/x//HG4jjkIz5QFAACEDD0HAADYYAIwW8GEac8ByQEAADYE4q2KEfFWRgAA0CySBySGZ1QAAOAEJSUlmjx5slJTU+VwOLRkyRLL/sLCQg0ZMkTx8fE69dRTdckll2jjxo0+X4fkAAAAG/x/6ZLvZYm6ujoNHz5cs2fPbnH/oEGDNHv2bG3btk3r1q3TwIEDNXHiRB08eNCn61BWAADAhlA8PjkrK0tZWVmt7p8yZYplfebMmZo7d662bt2q8ePHd/g6JAcAAIRYTU2NZT0QbyduaGjQCy+8ILfbreHDh/vUlrICAAA2BLKskJaWJrfb7V2Kiopsx/XOO++oZ8+eio2N1VNPPaWVK1cqKSnJp3PQcwAAgA2BnMpYWVkpl8vl3e5Pr8G4ceNUXl6uL7/8Ui+++KKuvfZabdy4UcnJyR0+Bz0HAACEmMvlsiz+JAfx8fE644wzNGrUKM2dO1fR0dGaO3euT+eg5wAAABu6ykOQjDGqr6/3qQ3JAQAANoQiOaitrdXOnTu96xUVFSovL1diYqJ69eqlGTNm6IorrlDfvn311Vdf6dlnn9Xnn3+ua665xqfrkBwAANBFbN68WePGjfOu5+fnS5KmTp2qOXPm6NNPP9XLL7+sL7/8Ur169dLIkSP1/vvva+jQoT5dh+QAAAAbjPx/5bLx8fjMzEwZ03qrxYsX+xXPMSQHAADY0FXGHNhBcgAAgA2RnBwwlREAAFjQcwAAgA2R3HNAcgAAgA2RnBxQVgAAABb0HAAAYIMxDhk/v/n7276zkBwAAGCDRw6/n3Pgb/vOQlkBAABY0HMAAIANkTwgkeQAAAAbInnMAWUFAABgQc8BAAA2UFYAAAAWkVxWIDkAAMAGE4Ceg3BNDhhzAAAALOg5AADABiPJGP/PEY5IDgAAsMEjhxw8IREAAJwM6DkAAMAGZisAAAALj3HIEaHPOaCsAAAALOg5AADABmMCMFshTKcrkBwAAGBDJI85oKwAAAAs6DkAAMCGSO45IDkAAMCGSJ6tQHIAAIANkTwgkTEHAADAgp4DAABsaO458HfMQYCCCTCSAwAAbIjkAYmUFQAAgAU9BwAA2GC+Xfw9RzgiOQAAwAbKCgAA4KRBcgAAgB0mQIsPSkpKNHnyZKWmpsrhcGjJkiXefUePHtWvf/1rnXPOOYqPj1dqaqpuuukm7du3z+ePRnIAAIAd35YV/FnkY1mhrq5Ow4cP1+zZs0/Yd/jwYW3ZskW//e1vtWXLFi1evFifffaZrrjiCp8/GmMOAACwIRRPSMzKylJWVlaL+9xut1auXGnZ9swzz+iHP/yh9uzZo/79+3f4OvQcAAAQoaqrq+VwOHTKKaf41M6n5KCoqEgjR45UQkKCkpOTddVVV2n79u1ttlm3bp0uuOAC9erVS3FxcRoyZIieeuopn4IEACDc+FtSOH62Q01NjWWpr6/3O74jR47onnvu0ZQpU+RyuXxq61NysHbtWuXk5GjDhg1auXKlGhsbNXHiRNXV1bXaJj4+Xrm5uSopKdEnn3yi++67T/fdd59eeOEFnwIFACCsHBsz4O8iKS0tTW6327sUFRX5FdrRo0d1/fXXy+Px6Nlnn/W5vU9jDpYvX25ZLy4uVnJyskpLSzV27NgW22RkZCgjI8O7PnDgQC1evFjvv/++br31Vp8DBgAg0lRWVlq+3TudTtvnOnr0qK699lpVVFRo1apVPvcaSH4OSKyurpYkJSYmdrhNWVmZPvjgA/3Hf/xHq8fU19dbulRqamrsBwkAQCcI5IBEl8tl65f4dx1LDHbs2KHVq1erV69ets5jOzkwxig/P19jxozRsGHD2j2+X79+OnjwoBobG1VYWKif/exnrR5bVFSkBx980G5oAAB0vhA8P7m2tlY7d+70rldUVKi8vFyJiYlKTU3Vv/7rv2rLli1655131NTUpKqqKknNX+JjYmI6fB3byUFubq62bt2qdevWdej4999/X7W1tdqwYYPuuecenXHGGbrhhhtaPLagoED5+fne9ZqaGqWlpdkNFQCAiLB582aNGzfOu37sd+XUqVNVWFiopUuXSpLOPfdcS7vVq1crMzOzw9exlRzk5eVp6dKlKikpUb9+/TrUJj09XZJ0zjnn6IsvvlBhYWGryYHT6fSr3gIAQGcLxbsVMjMzZdqoZbS1zxc+JQfGGOXl5emtt97SmjVrvL/wfWWMCcg0DQAAQipcX6voJ5+Sg5ycHC1cuFBvv/22EhISvLUMt9utuLg4Sc0lgb1792r+/PmSpN///vfq37+/hgwZIqn5uQdPPPGE8vLyAvk5AABAgPiUHDz33HOSdELdori4WNnZ2ZKk/fv3a8+ePd59Ho9HBQUFqqioUHR0tL73ve/pkUce0bRp0/yLHACAEIrkVzb7XFZoz7x58yzreXl59BIAACJPCGYrBAsvXgIAwBbHt4u/5wg/vHgJAABY0HMAAIAdlBUAAIBFBCcHlBUAAIAFPQcAANhx3CuX/TpHGCI5AADAhkC+lTHcUFYAAAAW9BwAAGBHBA9IJDkAAMCOCB5zQFkBAABY0HMAAIANDtO8+HuOcERyAACAHYw5AAAAFow5AAAAJwt6DgAAsIOyAgAAsIjg5ICyAgAAsKDnAAAAOyK454DkAAAAO5itAAAAThb0HAAAYANPSAQAAFYRPOaAsgIAALAgOQAAABaUFQAAsMGhAIw5CEgkgUdyAACAHUxlBAAAJwt6DgAAsCOCZyuQHAAAYEcEJweUFQAAgAU9BwAA2BDJT0ik5wAAADtMgBYflJSUaPLkyUpNTZXD4dCSJUss+xcvXqxLL71USUlJcjgcKi8vt/XRSA4AAOgi6urqNHz4cM2ePbvV/RdccIEeeeQRv65DWQEAADtCMCAxKytLWVlZre6/8cYbJUm7du3yIyiSAwAAbAnkmIOamhrLdqfTKafT6d/J/UBZAQCAEEtLS5Pb7fYuRUVFIY2HngMAAOwI4OOTKysr5XK5vJtD2WsgkRwAAGBPAMccuFwuS3IQaiQHAADYEMnPOSA5AACgi6itrdXOnTu96xUVFSovL1diYqL69++vv//979qzZ4/27dsnSdq+fbskKSUlRSkpKR2+DgMSAQCwIwQPQdq8ebMyMjKUkZEhScrPz1dGRobuv/9+SdLSpUuVkZGhSZMmSZKuv/56ZWRkaM6cOT5dh54DAADsCEBZwdfkIDMzU8a03ig7O1vZ2dn+xSR6DgAAwHfQcwAAgB0R/MpmkgMAAOyI4OSAsgIAALCg5wAAABsi+TkH9BwAAAALkgMAAGBBWQEAADsieEAiyQEAADZE8pgDkgMAAOwK01/u/mLMAQAAsKDnAAAAOxhzAAAAjhfJYw58KisUFRVp5MiRSkhIUHJysq666irvu6Jbs3jxYk2YMEG9e/eWy+XS6NGjtWLFCr+CBgAAncen5GDt2rXKycnRhg0btHLlSjU2NmrixImqq6trtU1JSYkmTJigZcuWqbS0VOPGjdPkyZNVVlbmd/AAAISMCdAShnwqKyxfvtyyXlxcrOTkZJWWlmrs2LEttpk1a5Zl/eGHH9bbb7+tP/7xj8rIyPAtWgAAwkQklxX8GnNQXV0tSUpMTOxwG4/Ho0OHDrXZpr6+XvX19d71mpoa+0ECAACf2J7KaIxRfn6+xowZo2HDhnW43ZNPPqm6ujpde+21rR5TVFQkt9vtXdLS0uyGCQBA54jgsoLt5CA3N1dbt27VokWLOtxm0aJFKiws1Guvvabk5ORWjysoKFB1dbV3qaystBsmAACdI4KTA1tlhby8PC1dulQlJSXq169fh9q89tpr+ulPf6rXX39dl1xySZvHOp1OOZ1OO6EBAAA/+ZQcGGOUl5ent956S2vWrFF6enqH2i1atEi33HKLFi1apEmTJtkKFACAcMKAxG/l5ORo4cKFevvtt5WQkKCqqipJktvtVlxcnKTmksDevXs1f/58Sc2JwU033aSnn35ao0aN8raJi4uT2+0O5GcBACB4IvgJiT6NOXjuuedUXV2tzMxM9e3b17u89tpr3mP279+vPXv2eNeff/55NTY2Kicnx9Lm9ttvD9ynAAAg2Bhz0MyY9j/FvHnzLOtr1qzx5RIAACDEeLcCAAA2MOYAAABYMeYAAACcLOg5AADABsoKAADAirICAAA4WdBzAACAHRHcc0ByAACADY5vF3/PEY4oKwAAAAt6DgAAsIOyAgAAOF4kT2WkrAAAgB0hePFSSUmJJk+erNTUVDkcDi1ZssQakjEqLCxUamqq4uLilJmZqY8++sjnj0ZyAABAF1FXV6fhw4dr9uzZLe5/7LHHNHPmTM2ePVubNm1SSkqKJkyYoEOHDvl0HcoKAADYFeSyQFZWlrKysloOxRjNmjVLv/nNb3T11VdLkl5++WX16dNHCxcu1LRp0zp8HXoOAACw4diYA38XSaqpqbEs9fX1PsdTUVGhqqoqTZw40bvN6XTqoosu0gcffODTuUgOAAAIsbS0NLndbu9SVFTk8zmqqqokSX369LFs79Onj3dfR1FWAADAjgBOZaysrJTL5fJudjqdtk/pcFgfrWSMOWFbe0gOAACwIZBTGV0ulyU5sCMlJUVScw9C3759vdsPHDhwQm9CeygrAAAQAdLT05WSkqKVK1d6tzU0NGjt2rU6//zzfToXPQcAANgRgick1tbWaufOnd71iooKlZeXKzExUf3799cdd9yhhx9+WGeeeabOPPNMPfzww+rRo4emTJni03VIDgAAsCEUT0jcvHmzxo0b513Pz8+XJE2dOlXz5s3Tr371K33zzTeaPn26vv76a/3oRz/Su+++q4SEBJ+uQ3IAAEAXkZmZKWNazygcDocKCwtVWFjo13VIDgAAsIMXLwEAAAuSAwAAcDzeyggAAE4a9BwAAGAHZQUAAHA8hzFytDFzoKPnCEeUFQAAgAU9BwAA2EFZAQAAHI/ZCgAA4KRBzwEAAHZQVgAAAMejrAAAAE4a9BwAAGAHZQUAAHC8SC4rkBwAAGBHBPccMOYAAABY0HMAAIBN4VoW8BfJAQAAdhjTvPh7jjBEWQEAAFjQcwAAgA3MVgAAAFbMVgAAACcLeg4AALDB4Wle/D1HOCI5AADADsoKAADgZEHPAQAANjBbAQAAWEXwQ5BIDgAAsCGSew4YcwAAACzoOQAAwI4Inq1AcgAAgA2UFQAAwEmDngMAAOyI4NkKPvUcFBUVaeTIkUpISFBycrKuuuoqbd++vc02+/fv15QpUzR48GBFRUXpjjvu8CdeAADCwrGygr9LOPIpOVi7dq1ycnK0YcMGrVy5Uo2NjZo4caLq6upabVNfX6/evXvrN7/5jYYPH+53wAAAnMwOHTqkO+64QwMGDFBcXJzOP/98bdq0KaDX8KmssHz5cst6cXGxkpOTVVpaqrFjx7bYZuDAgXr66aclSS+99JLNMAEACDMhmq3ws5/9TH/961/1yiuvKDU1VQsWLNAll1yijz/+WKeddpqfATXza0BidXW1JCkxMTEgwRxTX1+vmpoaywIAQDgJRVnhm2++0ZtvvqnHHntMY8eO1RlnnKHCwkKlp6frueeeC9hns50cGGOUn5+vMWPGaNiwYQELSGoe2+B2u71LWlpaQM8PAEA4+e4X4vr6+haPa2xsVFNTk2JjYy3b4+LitG7duoDFYzs5yM3N1datW7Vo0aKABXNMQUGBqqurvUtlZWXArwEAgF88JjCLpLS0NMuX4qKiohYvmZCQoNGjR+t3v/ud9u3bp6amJi1YsEAbN27U/v37A/bRbE1lzMvL09KlS1VSUqJ+/foFLJhjnE6nnE5nwM8LAEDABHDMQWVlpVwul3dzW78DX3nlFd1yyy067bTT1K1bN/3gBz/QlClTtGXLFj+D+SefkgNjjPLy8vTWW29pzZo1Sk9PD1ggAAB0JQ4F4AmJ3/6/y+WyJAdt+d73vqe1a9eqrq5ONTU16tu3r6677rqA/k72KTnIycnRwoUL9fbbbyshIUFVVVWSJLfbrbi4OEnNJYG9e/dq/vz53nbl5eWSpNraWh08eFDl5eWKiYnR2WefHaCPAQDAySU+Pl7x8fH6+uuvtWLFCj322GMBO7dPycGxkZCZmZmW7cXFxcrOzpbU/NCjPXv2WPZnZGR4/1xaWqqFCxdqwIAB2rVrl+8RAwAQDkL0hMQVK1bIGKPBgwdr586duvvuuzV48GDdfPPN/sVyHJ/LCu2ZN2+erXYAAHQloXrxUnV1tQoKCvT5558rMTFRP/nJTzRjxgx1797dv2COw7sVAADoQq699lpde+21nXoNkgMAAOwI0RMSg4HkAAAAGxzGyOFn2dzf9p3Fr8cnAwCAyEPPAQAAdni+Xfw9RxgiOQAAwAbKCgAA4KRBzwEAAHYwWwEAAFiE6AmJwUByAACADaF6QmIwMOYAAABY0HMAAIAdlBUAAMDxHJ7mxd9zhCPKCgAAwIKeAwAA7KCsAAAALCL4OQeUFQAAgAU9BwAA2BDJ71YgOQAAwI4IHnNAWQEAAFjQcwAAgB1Gkr/PKQjPjgOSAwAA7GDMAQAAsDIKwJiDgEQScIw5AAAAFvQcAABgRwTPViA5AADADo8kRwDOEYYoKwAAAAt6DgAAsIHZCgAAwCqCxxxQVgAAABb0HAAAYEcE9xyQHAAAYEcEJweUFQAAgAU9BwAA2BHBzzkgOQAAwAamMgIAACvGHAAAgFBrbGzUfffdp/T0dMXFxen000/XQw89JI8nsPUJeg4AALDDYySHn9/8Pb61f/TRRzVnzhy9/PLLGjp0qDZv3qybb75Zbrdbt99+u3+xHIfkAAAAO0JQVli/fr2uvPJKTZo0SZI0cOBALVq0SJs3b/Yvju+grAAAQIjV1NRYlvr6+haPGzNmjP73f/9Xn332mSTpww8/1Lp163T55ZcHNB56DgAAsCUAPQdqbp+WlmbZ+sADD6iwsPCEo3/961+rurpaQ4YMUbdu3dTU1KQZM2bohhtu8DMOK5IDAADsCGBZobKyUi6Xy7vZ6XS2ePhrr72mBQsWaOHChRo6dKjKy8t1xx13KDU1VVOnTvUvluOQHAAAEGIul8uSHLTm7rvv1j333KPrr79eknTOOedo9+7dKioqIjkAACDkPEbHygL+naPjDh8+rKgo63DBbt26MZURAICwYDzNi7/n8MHkyZM1Y8YM9e/fX0OHDlVZWZlmzpypW265xb84voPkAACALuKZZ57Rb3/7W02fPl0HDhxQamqqpk2bpvvvvz+g1yE5AADAjhA85yAhIUGzZs3SrFmz/LtuO0gOAACwIwRjDoKF5AAAADsi+MVLEZ8cGGOk+tUyh+dLRz+UFC05M+WIv1mO7meHOjwAAMJORCcHxhiZQ49Ih4sldZPU1LzjyDsyR/4ouZ+UI25SKEMEAHRVRgHoOQhIJAEX2e9WqH/v28RA8iYG3j97ZKrvlmmqCkFgAIAu71hZwd8lDEV0cmDqXlZzj0FrPDKHXwtWOAAAdAkRXVZoHmPQ1MYBHuloeZCCAQBEFI9Hkp8PQQrwkw0DJbKTA0e3duo5DkX6LQAAdJIInq0Q0WUFxVyotssKksN5YXBiAQCgi/ApOSgqKtLIkSOVkJCg5ORkXXXVVdq+fXu77dauXasRI0YoNjZWp59+uubMmWM7YF844m9R22WFWCnuqqDEAgCIMAxIbLZ27Vrl5ORow4YNWrlypRobGzVx4kTV1dW12qaiokKXX365LrzwQpWVlenee+/VbbfdpjfffNPv4NtjotLbOeIbmca9nR4HACACeUxgljDkU8F9+fLllvXi4mIlJyertLRUY8eObbHNnDlz1L9/f+9zoM866yxt3rxZTzzxhH7yk5/Yi7qjau5s/5jqX0q9l7d/HAAAJwm/RuNVV1dLkhITE1s9Zv369Zo4caJl26WXXqq5c+fq6NGj6t69+wlt6uvrVV9f712vqamxF2DD+vaPafo/e+cGAJzUjPHI+PnKZn/bdxbbAxKNMcrPz9eYMWM0bNiwVo+rqqpSnz59LNv69OmjxsZGffnlly22KSoqktvt9i5paWk2o2zs0FEmTGs+AIAwZgJQUgjT3z+2k4Pc3Fxt3bpVixYtavdYh8NhWT/2y/i7248pKChQdXW1d6msrLQZ5Ym9Eh2JDwCAdkXwgERbZYW8vDwtXbpUJSUl6tevX5vHpqSkqKrK+ojiAwcOKDo6Wr169WqxjdPplNPptBPad050sVS/ou1jonn5EgAAx/Op58AYo9zcXC1evFirVq1Senp7swGk0aNHa+XKlZZt7777rs4777wWxxsElPsRtf2cA4d0yuzOjQEAEJk8nsAsYcin5CAnJ0cLFizQwoULlZCQoKqqKlVVVembb77xHlNQUKCbbrrJu/6LX/xCu3fvVn5+vj755BO99NJLmjt3ru66667AfYpWREXFS0mrJYe7hb1xUuISRUW33fMBAECLKCs0e+655yRJmZmZlu3FxcXKzs6WJO3fv1979uzx7ktPT9eyZcv0y1/+Ur///e+Vmpqq//zP/+z8aYzfiopOkfpskqfhk+Y3NJpGKf46RcX8KCjXBwCgq/EpOejIqP558+adsO2iiy7Sli1bfLlUwEXFnCXFPBbSGAAAkcN4PDKOyJzKyFuHAACwwxi183a/Dp4j/ET2i5cAAIDP6DkAAMAOj5EckdlzQHIAAIAdxkjyc8xAmCYHlBUAAIAFPQcAANhgPEbGz7JCuL7bh+QAAAA7jEf+lxWYyggAQMSI5J4DxhwAAACLLtFzcCyzqqmpCXEkAIBwd+x3RWd/K2809X6XBRp1NEDRBFaXSA4OHTokSUpLSwtxJACAruLQoUNyu1t68Z5/YmJilJKSonVVywJyvpSUFMXExATkXIHiMOFa8DiOx+PRvn37lJCQIIfDYfs8NTU1SktLU2VlpVwuVwAj7DzEHBzEHBzEHDxdMe5AxWyM0aFDh5SamqqoqM6pnh85ckQNDQ0BOVdMTIxiY2MDcq5A6RI9B1FRUerXL3CvVna5XF3mH8sxxBwcxBwcxBw8XTHuQMTcGT0Gx4uNjQ27X+iBxIBEAABgQXIAAAAsTqrkwOl06oEHHpDT6Qx1KB1GzMFBzMFBzMHTFePuijFHqi4xIBEAAATPSdVzAAAA2kdyAAAALEgOAACABckBAACwiMjkYMaMGTr//PPVo0cPnXLKKSfs//DDD3XDDTcoLS1NcXFxOuuss/T0009bjtm1a5ccDscJy/Lly8M2Zknatm2bLrroIsXFxem0007TQw891GnPF28vZkm6/fbbNWLECDmdTp177rkn7A/2fQ5U3FL43es9e/Zo8uTJio+PV1JSkm677TbLE9zC7We6IzFLwb3P37VlyxZNmDBBp5xyinr16qVbb71VtbW1lmNauqdz5swJSnwt6UjMHbnvwfbZZ5/pyiuvVFJSklwuly644AKtXr3acky43etI1iWekOirhoYGXXPNNRo9erTmzp17wv7S0lL17t1bCxYsUFpamj744APdeuut6tatm3Jzcy3Hvvfeexo6dKh3PTExMWxjrqmp0YQJEzRu3Dht2rRJn332mbKzsxUfH68777wz6DFLzY8xveWWW7Rx40Zt3bq11XMF6z5LgYk73O51U1OTJk2apN69e2vdunX66quvNHXqVBlj9Mwzz1iODZef6Y7EHOz7fLx9+/bpkksu0XXXXafZs2erpqZGd9xxh7Kzs/XGG29Yji0uLtZll13mXe/sp/O1piMx+/KzEkyTJk3SoEGDtGrVKsXFxWnWrFn68Y9/rL/97W9KSUnxHhcu9zrimQhWXFxs3G53h46dPn26GTdunHe9oqLCSDJlZWWdE1wr/In52WefNW632xw5csS7raioyKSmphqPxxPoUL06EvMDDzxghg8ffsL2UN1nY/yLO9zu9bJly0xUVJTZu3evd9uiRYuM0+k01dXVxpjw+5nuSMyhus/GGPP888+b5ORk09TU5N1WVlZmJJkdO3Z4t0kyb731VqfG0lEdibkj9z3YDh48aCSZkpIS77aamhojybz33nvebeF0ryNdRJYV7Kiurm7xG9QVV1yh5ORkXXDBBSd8Wwi178a8fv16XXTRRZYHiFx66aXat2+fdu3aFYIIOy6c73NLwu1er1+/XsOGDVNqaqolnvr6epWWllqODZd73ZGYQ3mf6+vrFRMTY3lxT1xcnCRp3bp1lmNzc3OVlJSkkSNHas6cOfJ4/HuNr10didmXn5Vg6dWrl8466yzNnz9fdXV1amxs1PPPP68+ffpoxIgRlmPD5V5HOpIDNf9j+e///m9NmzbNu61nz56aOXOm3njjDS1btkzjx4/XddddpwULFoQw0n9qKeaqqir16dPHctyx9aqqqqDG11Hhfp9bE273uqV4Tj31VMXExHjjCbd73ZGYQ3mfL774YlVVVenxxx9XQ0ODvv76a917772SpP3793uP+93vfqfXX39d7733nq6//nrdeeedevjhhzs1Nn9i7sh9DzaHw6GVK1eqrKxMCQkJio2N1VNPPaXly5dbxquE072OdF0mOSgsLGxxMMrxy+bNm30+70cffaQrr7xS999/vyZMmODdnpSUpF/+8pf64Q9/qPPOO08PPfSQpk+frsceeyxsY5Z0wiutzbcDtzr6quvOirk1gbjPoYhbCr973dJ1jTHe7eH4M91ezC0d4+t9tvsZhg4dqpdffllPPvmkevTooZSUFJ1++unq06ePunXr5j3ffffdp9GjR+vcc8/VnXfeqYceekiPP/64rdiCFXNH7nsw4zbGaPr06UpOTtb777+vv/zlL7ryyiv14x//2JKIBeNeo1mXGZCYm5ur66+/vs1jBg4c6NM5P/74Y1188cX6+c9/rvvuu6/d40eNGqU//OEPHT5/sGNOSUk5IfM/cOCAJJ3wTaE1nRGzr3y9z1Lw4w63e52SkqKNGzdatn399dc6evRom/GE8me6IzEH4j5/ly+fYcqUKZoyZYq++OILxcfHy+FwaObMmUpPT2+17ahRo1RTU6MvvvjCdoydGbPdn5XOjHvVqlV655139PXXX3tf1fzss89q5cqVevnll3XPPfe02LYz7jWadZnkICkpSUlJSQE730cffaSLL75YU6dO1YwZMzrUpqysTH379u3wNYId8+jRo3XvvfeqoaFBMTExkqR3331XqampHf4PdqBjtsPX+ywFP+5wu9ejR4/WjBkztH//fu+9e/fdd+V0Ok+o2R4vlD/THYk5EPc5EJ/h2C+el156SbGxsSf02B2vrKxMsbGxrU7ftCOQMdv9WenMuA8fPixJlrESx9bbGlPQGfca3wrhYMhOs3v3blNWVmYefPBB07NnT1NWVmbKysrMoUOHjDHG/PWvfzW9e/c2//Zv/2b279/vXQ4cOOA9x7x588yrr75qPv74Y/Ppp5+axx9/3HTv3t3MnDkzbGP+xz/+Yfr06WNuuOEGs23bNrN48WLjcrnME088EZKYjTFmx44dpqyszEybNs0MGjTIe0x9fb0xJvj3OVBxh9u9bmxsNMOGDTPjx483W7ZsMe+9957p16+fyc3N9Z4j3H6mOxJzsO/zdz3zzDOmtLTUbN++3cyePdvExcWZp59+2rt/6dKl5oUXXjDbtm0zO3fuNC+++KJxuVzmtttuC0p8dmLuyH0PtoMHD5pevXqZq6++2pSXl5vt27ebu+66y3Tv3t2Ul5cbY8LzXkeyiEwOpk6daiSdsKxevdoY0zw9raX9AwYM8J5j3rx55qyzzjI9evQwCQkJZsSIEeaVV14J65iNMWbr1q3mwgsvNE6n06SkpJjCwsJOm/LVXszGGHPRRRe1eExFRYUxJvj3OVBxGxN+93r37t1m0qRJJi4uziQmJprc3FzLFMBw+5nuSMzGBPc+f9eNN95oEhMTTUxMjPn+979v5s+fb9n/pz/9yZx77rmmZ8+epkePHmbYsGFm1qxZ5ujRo0GJryXtxWxMx+57sG3atMlMnDjRJCYmmoSEBDNq1CizbNky7/5wvNeRjFc2AwAAiy4zWwEAAAQHyQEAALAgOQAAABYkBwAAwILkAAAAWJAcAAAAC5IDAABgQXIAAAAsSA4AAIAFyQEAALAgOQAAABYkBwAAwOL/A6PXmD1DzIqeAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 640x480 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import pandas as pd\n",
-    "import geopandas as gpd\n",
-    "\n",
-    "df = pd.DataFrame({'lat': lat, 'lon': lon, 'z20': z20})\n",
-    "gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(lon, lat))\n",
-    "gdf.plot(column='z20', legend=True, aspect=None) #try aspect='equal' if your map is distorted"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.640692"
-      ]
-     },
-     "execution_count": 37,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Warm Water Volume - East (5°N-5°S, 120°W-80°W)\n",
-    "(40 * 111000) * (10 * 111000) * 130 / 1e15 "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "https://colab.research.google.com/drive/1dabU91WECy5cglb2mVC-8SG4muFNlQrw?usp=sharing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "import matplotlib.pyplot as plt\n",
-    "# Open output and read to x, y, z\n",
-    "ds = xr.open_zarr(\"../results/UnderwayData.zarr\")\n",
-    "time = ds[\"time\"][0].values\n",
-    "x = ds[\"lon\"][:].squeeze()\n",
-    "y = ds[\"lat\"][:].squeeze()\n",
-    "z = ds[\"z\"][:].squeeze()\n",
-    "T = ds[\"temperature\"][:].squeeze()\n",
-    "S = ds[\"salinity\"][:].squeeze()\n",
-    "ds.close()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div><svg style=\"position: absolute; width: 0; height: 0; overflow: hidden\">\n",
-       "<defs>\n",
-       "<symbol id=\"icon-database\" viewBox=\"0 0 32 32\">\n",
-       "<path d=\"M16 0c-8.837 0-16 2.239-16 5v4c0 2.761 7.163 5 16 5s16-2.239 16-5v-4c0-2.761-7.163-5-16-5z\"></path>\n",
-       "<path d=\"M16 17c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
-       "<path d=\"M16 26c-8.837 0-16-2.239-16-5v6c0 2.761 7.163 5 16 5s16-2.239 16-5v-6c0 2.761-7.163 5-16 5z\"></path>\n",
-       "</symbol>\n",
-       "<symbol id=\"icon-file-text2\" viewBox=\"0 0 32 32\">\n",
-       "<path d=\"M28.681 7.159c-0.694-0.947-1.662-2.053-2.724-3.116s-2.169-2.030-3.116-2.724c-1.612-1.182-2.393-1.319-2.841-1.319h-15.5c-1.378 0-2.5 1.121-2.5 2.5v27c0 1.378 1.122 2.5 2.5 2.5h23c1.378 0 2.5-1.122 2.5-2.5v-19.5c0-0.448-0.137-1.23-1.319-2.841zM24.543 5.457c0.959 0.959 1.712 1.825 2.268 2.543h-4.811v-4.811c0.718 0.556 1.584 1.309 2.543 2.268zM28 29.5c0 0.271-0.229 0.5-0.5 0.5h-23c-0.271 0-0.5-0.229-0.5-0.5v-27c0-0.271 0.229-0.5 0.5-0.5 0 0 15.499-0 15.5 0v7c0 0.552 0.448 1 1 1h7v19.5z\"></path>\n",
-       "<path d=\"M23 26h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
-       "<path d=\"M23 22h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
-       "<path d=\"M23 18h-14c-0.552 0-1-0.448-1-1s0.448-1 1-1h14c0.552 0 1 0.448 1 1s-0.448 1-1 1z\"></path>\n",
-       "</symbol>\n",
-       "</defs>\n",
-       "</svg>\n",
-       "<style>/* CSS stylesheet for displaying xarray objects in jupyterlab.\n",
-       " *\n",
-       " */\n",
-       "\n",
-       ":root {\n",
-       "  --xr-font-color0: var(--jp-content-font-color0, rgba(0, 0, 0, 1));\n",
-       "  --xr-font-color2: var(--jp-content-font-color2, rgba(0, 0, 0, 0.54));\n",
-       "  --xr-font-color3: var(--jp-content-font-color3, rgba(0, 0, 0, 0.38));\n",
-       "  --xr-border-color: var(--jp-border-color2, #e0e0e0);\n",
-       "  --xr-disabled-color: var(--jp-layout-color3, #bdbdbd);\n",
-       "  --xr-background-color: var(--jp-layout-color0, white);\n",
-       "  --xr-background-color-row-even: var(--jp-layout-color1, white);\n",
-       "  --xr-background-color-row-odd: var(--jp-layout-color2, #eeeeee);\n",
-       "}\n",
-       "\n",
-       "html[theme=dark],\n",
-       "body[data-theme=dark],\n",
-       "body.vscode-dark {\n",
-       "  --xr-font-color0: rgba(255, 255, 255, 1);\n",
-       "  --xr-font-color2: rgba(255, 255, 255, 0.54);\n",
-       "  --xr-font-color3: rgba(255, 255, 255, 0.38);\n",
-       "  --xr-border-color: #1F1F1F;\n",
-       "  --xr-disabled-color: #515151;\n",
-       "  --xr-background-color: #111111;\n",
-       "  --xr-background-color-row-even: #111111;\n",
-       "  --xr-background-color-row-odd: #313131;\n",
-       "}\n",
-       "\n",
-       ".xr-wrap {\n",
-       "  display: block !important;\n",
-       "  min-width: 300px;\n",
-       "  max-width: 700px;\n",
-       "}\n",
-       "\n",
-       ".xr-text-repr-fallback {\n",
-       "  /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n",
-       "  display: none;\n",
-       "}\n",
-       "\n",
-       ".xr-header {\n",
-       "  padding-top: 6px;\n",
-       "  padding-bottom: 6px;\n",
-       "  margin-bottom: 4px;\n",
-       "  border-bottom: solid 1px var(--xr-border-color);\n",
-       "}\n",
-       "\n",
-       ".xr-header > div,\n",
-       ".xr-header > ul {\n",
-       "  display: inline;\n",
-       "  margin-top: 0;\n",
-       "  margin-bottom: 0;\n",
-       "}\n",
-       "\n",
-       ".xr-obj-type,\n",
-       ".xr-array-name {\n",
-       "  margin-left: 2px;\n",
-       "  margin-right: 10px;\n",
-       "}\n",
-       "\n",
-       ".xr-obj-type {\n",
-       "  color: var(--xr-font-color2);\n",
-       "}\n",
-       "\n",
-       ".xr-sections {\n",
-       "  padding-left: 0 !important;\n",
-       "  display: grid;\n",
-       "  grid-template-columns: 150px auto auto 1fr 20px 20px;\n",
-       "}\n",
-       "\n",
-       ".xr-section-item {\n",
-       "  display: contents;\n",
-       "}\n",
-       "\n",
-       ".xr-section-item input {\n",
-       "  display: none;\n",
-       "}\n",
-       "\n",
-       ".xr-section-item input + label {\n",
-       "  color: var(--xr-disabled-color);\n",
-       "}\n",
-       "\n",
-       ".xr-section-item input:enabled + label {\n",
-       "  cursor: pointer;\n",
-       "  color: var(--xr-font-color2);\n",
-       "}\n",
-       "\n",
-       ".xr-section-item input:enabled + label:hover {\n",
-       "  color: var(--xr-font-color0);\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary {\n",
-       "  grid-column: 1;\n",
-       "  color: var(--xr-font-color2);\n",
-       "  font-weight: 500;\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary > span {\n",
-       "  display: inline-block;\n",
-       "  padding-left: 0.5em;\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary-in:disabled + label {\n",
-       "  color: var(--xr-font-color2);\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary-in + label:before {\n",
-       "  display: inline-block;\n",
-       "  content: '►';\n",
-       "  font-size: 11px;\n",
-       "  width: 15px;\n",
-       "  text-align: center;\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary-in:disabled + label:before {\n",
-       "  color: var(--xr-disabled-color);\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary-in:checked + label:before {\n",
-       "  content: '▼';\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary-in:checked + label > span {\n",
-       "  display: none;\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary,\n",
-       ".xr-section-inline-details {\n",
-       "  padding-top: 4px;\n",
-       "  padding-bottom: 4px;\n",
-       "}\n",
-       "\n",
-       ".xr-section-inline-details {\n",
-       "  grid-column: 2 / -1;\n",
-       "}\n",
-       "\n",
-       ".xr-section-details {\n",
-       "  display: none;\n",
-       "  grid-column: 1 / -1;\n",
-       "  margin-bottom: 5px;\n",
-       "}\n",
-       "\n",
-       ".xr-section-summary-in:checked ~ .xr-section-details {\n",
-       "  display: contents;\n",
-       "}\n",
-       "\n",
-       ".xr-array-wrap {\n",
-       "  grid-column: 1 / -1;\n",
-       "  display: grid;\n",
-       "  grid-template-columns: 20px auto;\n",
-       "}\n",
-       "\n",
-       ".xr-array-wrap > label {\n",
-       "  grid-column: 1;\n",
-       "  vertical-align: top;\n",
-       "}\n",
-       "\n",
-       ".xr-preview {\n",
-       "  color: var(--xr-font-color3);\n",
-       "}\n",
-       "\n",
-       ".xr-array-preview,\n",
-       ".xr-array-data {\n",
-       "  padding: 0 5px !important;\n",
-       "  grid-column: 2;\n",
-       "}\n",
-       "\n",
-       ".xr-array-data,\n",
-       ".xr-array-in:checked ~ .xr-array-preview {\n",
-       "  display: none;\n",
-       "}\n",
-       "\n",
-       ".xr-array-in:checked ~ .xr-array-data,\n",
-       ".xr-array-preview {\n",
-       "  display: inline-block;\n",
-       "}\n",
-       "\n",
-       ".xr-dim-list {\n",
-       "  display: inline-block !important;\n",
-       "  list-style: none;\n",
-       "  padding: 0 !important;\n",
-       "  margin: 0;\n",
-       "}\n",
-       "\n",
-       ".xr-dim-list li {\n",
-       "  display: inline-block;\n",
-       "  padding: 0;\n",
-       "  margin: 0;\n",
-       "}\n",
-       "\n",
-       ".xr-dim-list:before {\n",
-       "  content: '(';\n",
-       "}\n",
-       "\n",
-       ".xr-dim-list:after {\n",
-       "  content: ')';\n",
-       "}\n",
-       "\n",
-       ".xr-dim-list li:not(:last-child):after {\n",
-       "  content: ',';\n",
-       "  padding-right: 5px;\n",
-       "}\n",
-       "\n",
-       ".xr-has-index {\n",
-       "  font-weight: bold;\n",
-       "}\n",
-       "\n",
-       ".xr-var-list,\n",
-       ".xr-var-item {\n",
-       "  display: contents;\n",
-       "}\n",
-       "\n",
-       ".xr-var-item > div,\n",
-       ".xr-var-item label,\n",
-       ".xr-var-item > .xr-var-name span {\n",
-       "  background-color: var(--xr-background-color-row-even);\n",
-       "  margin-bottom: 0;\n",
-       "}\n",
-       "\n",
-       ".xr-var-item > .xr-var-name:hover span {\n",
-       "  padding-right: 5px;\n",
-       "}\n",
-       "\n",
-       ".xr-var-list > li:nth-child(odd) > div,\n",
-       ".xr-var-list > li:nth-child(odd) > label,\n",
-       ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n",
-       "  background-color: var(--xr-background-color-row-odd);\n",
-       "}\n",
-       "\n",
-       ".xr-var-name {\n",
-       "  grid-column: 1;\n",
-       "}\n",
-       "\n",
-       ".xr-var-dims {\n",
-       "  grid-column: 2;\n",
-       "}\n",
-       "\n",
-       ".xr-var-dtype {\n",
-       "  grid-column: 3;\n",
-       "  text-align: right;\n",
-       "  color: var(--xr-font-color2);\n",
-       "}\n",
-       "\n",
-       ".xr-var-preview {\n",
-       "  grid-column: 4;\n",
-       "}\n",
-       "\n",
-       ".xr-index-preview {\n",
-       "  grid-column: 2 / 5;\n",
-       "  color: var(--xr-font-color2);\n",
-       "}\n",
-       "\n",
-       ".xr-var-name,\n",
-       ".xr-var-dims,\n",
-       ".xr-var-dtype,\n",
-       ".xr-preview,\n",
-       ".xr-attrs dt {\n",
-       "  white-space: nowrap;\n",
-       "  overflow: hidden;\n",
-       "  text-overflow: ellipsis;\n",
-       "  padding-right: 10px;\n",
-       "}\n",
-       "\n",
-       ".xr-var-name:hover,\n",
-       ".xr-var-dims:hover,\n",
-       ".xr-var-dtype:hover,\n",
-       ".xr-attrs dt:hover {\n",
-       "  overflow: visible;\n",
-       "  width: auto;\n",
-       "  z-index: 1;\n",
-       "}\n",
-       "\n",
-       ".xr-var-attrs,\n",
-       ".xr-var-data,\n",
-       ".xr-index-data {\n",
-       "  display: none;\n",
-       "  background-color: var(--xr-background-color) !important;\n",
-       "  padding-bottom: 5px !important;\n",
-       "}\n",
-       "\n",
-       ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n",
-       ".xr-var-data-in:checked ~ .xr-var-data,\n",
-       ".xr-index-data-in:checked ~ .xr-index-data {\n",
-       "  display: block;\n",
-       "}\n",
-       "\n",
-       ".xr-var-data > table {\n",
-       "  float: right;\n",
-       "}\n",
-       "\n",
-       ".xr-var-name span,\n",
-       ".xr-var-data,\n",
-       ".xr-index-name div,\n",
-       ".xr-index-data,\n",
-       ".xr-attrs {\n",
-       "  padding-left: 25px !important;\n",
-       "}\n",
-       "\n",
-       ".xr-attrs,\n",
-       ".xr-var-attrs,\n",
-       ".xr-var-data,\n",
-       ".xr-index-data {\n",
-       "  grid-column: 1 / -1;\n",
-       "}\n",
-       "\n",
-       "dl.xr-attrs {\n",
-       "  padding: 0;\n",
-       "  margin: 0;\n",
-       "  display: grid;\n",
-       "  grid-template-columns: 125px auto;\n",
-       "}\n",
-       "\n",
-       ".xr-attrs dt,\n",
-       ".xr-attrs dd {\n",
-       "  padding: 0;\n",
-       "  margin: 0;\n",
-       "  float: left;\n",
-       "  padding-right: 10px;\n",
-       "  width: auto;\n",
-       "}\n",
-       "\n",
-       ".xr-attrs dt {\n",
-       "  font-weight: normal;\n",
-       "  grid-column: 1;\n",
-       "}\n",
-       "\n",
-       ".xr-attrs dt:hover span {\n",
-       "  display: inline-block;\n",
-       "  background: var(--xr-background-color);\n",
-       "  padding-right: 10px;\n",
-       "}\n",
-       "\n",
-       ".xr-attrs dd {\n",
-       "  grid-column: 2;\n",
-       "  white-space: pre-wrap;\n",
-       "  word-break: break-all;\n",
-       "}\n",
-       "\n",
-       ".xr-icon-database,\n",
-       ".xr-icon-file-text2,\n",
-       ".xr-no-icon {\n",
-       "  display: inline-block;\n",
-       "  vertical-align: middle;\n",
-       "  width: 1em;\n",
-       "  height: 1.5em !important;\n",
-       "  stroke-width: 0;\n",
-       "  stroke: currentColor;\n",
-       "  fill: currentColor;\n",
-       "}\n",
-       "</style><pre class='xr-text-repr-fallback'>&lt;xarray.Dataset&gt; Size: 40B\n",
-       "Dimensions:      (trajectory: 1, obs: 1)\n",
-       "Coordinates:\n",
-       "  * obs          (obs) int32 4B 0\n",
-       "  * trajectory   (trajectory) int64 8B 42\n",
-       "Data variables:\n",
-       "    lat          (trajectory, obs) float32 4B dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;\n",
-       "    lon          (trajectory, obs) float32 4B dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;\n",
-       "    salinity     (trajectory, obs) float32 4B dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;\n",
-       "    temperature  (trajectory, obs) float32 4B dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;\n",
-       "    time         (trajectory, obs) datetime64[ns] 8B dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;\n",
-       "    z            (trajectory, obs) float32 4B dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;\n",
-       "Attributes:\n",
-       "    Conventions:            CF-1.6/CF-1.7\n",
-       "    feature_type:           trajectory\n",
-       "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-       "    parcels_mesh:           spherical\n",
-       "    parcels_version:        3.0.2</pre><div class='xr-wrap' style='display:none'><div class='xr-header'><div class='xr-obj-type'>xarray.Dataset</div></div><ul class='xr-sections'><li class='xr-section-item'><input id='section-26e225eb-bc4b-400e-9409-bfdcc05d3f81' class='xr-section-summary-in' type='checkbox' disabled ><label for='section-26e225eb-bc4b-400e-9409-bfdcc05d3f81' class='xr-section-summary'  title='Expand/collapse section'>Dimensions:</label><div class='xr-section-inline-details'><ul class='xr-dim-list'><li><span class='xr-has-index'>trajectory</span>: 1</li><li><span class='xr-has-index'>obs</span>: 1</li></ul></div><div class='xr-section-details'></div></li><li class='xr-section-item'><input id='section-d9aaaa52-f7b5-4add-9d9a-828df82babf5' class='xr-section-summary-in' type='checkbox'  checked><label for='section-d9aaaa52-f7b5-4add-9d9a-828df82babf5' class='xr-section-summary' >Coordinates: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>obs</span></div><div class='xr-var-dims'>(obs)</div><div class='xr-var-dtype'>int32</div><div class='xr-var-preview xr-preview'>0</div><input id='attrs-3c04dbe2-d38b-4d8e-a210-b9b724a1f6c0' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-3c04dbe2-d38b-4d8e-a210-b9b724a1f6c0' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-c80b73ae-3be0-497c-8975-da733523fd03' class='xr-var-data-in' type='checkbox'><label for='data-c80b73ae-3be0-497c-8975-da733523fd03' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([0], dtype=int32)</pre></div></li><li class='xr-var-item'><div class='xr-var-name'><span class='xr-has-index'>trajectory</span></div><div class='xr-var-dims'>(trajectory)</div><div class='xr-var-dtype'>int64</div><div class='xr-var-preview xr-preview'>42</div><input id='attrs-d36a61f3-b034-4c94-95fc-20c42f011fe2' class='xr-var-attrs-in' type='checkbox' disabled><label for='attrs-d36a61f3-b034-4c94-95fc-20c42f011fe2' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-a9da7487-4ef1-4692-a968-ee84281d180d' class='xr-var-data-in' type='checkbox'><label for='data-a9da7487-4ef1-4692-a968-ee84281d180d' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'></dl></div><div class='xr-var-data'><pre>array([42])</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-b1b8d030-cd22-4ed8-8445-5cb95772bcc0' class='xr-section-summary-in' type='checkbox'  checked><label for='section-b1b8d030-cd22-4ed8-8445-5cb95772bcc0' class='xr-section-summary' >Data variables: <span>(6)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-var-name'><span>lat</span></div><div class='xr-var-dims'>(trajectory, obs)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;</div><input id='attrs-3d402c6d-a614-4686-8f8f-72f6027cbd1e' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-3d402c6d-a614-4686-8f8f-72f6027cbd1e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-337ef805-32b8-4f04-912f-1fc988602b59' class='xr-var-data-in' type='checkbox'><label for='data-337ef805-32b8-4f04-912f-1fc988602b59' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>axis :</span></dt><dd>Y</dd><dt><span>long_name :</span></dt><dd></dd><dt><span>standard_name :</span></dt><dd>latitude</dd><dt><span>units :</span></dt><dd>degrees_north</dd></dl></div><div class='xr-var-data'><table>\n",
-       "    <tr>\n",
-       "        <td>\n",
-       "            <table style=\"border-collapse: collapse;\">\n",
-       "                <thead>\n",
-       "                    <tr>\n",
-       "                        <td> </td>\n",
-       "                        <th> Array </th>\n",
-       "                        <th> Chunk </th>\n",
-       "                    </tr>\n",
-       "                </thead>\n",
-       "                <tbody>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Bytes </th>\n",
-       "                        <td> 4 B </td>\n",
-       "                        <td> 4 B </td>\n",
-       "                    </tr>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Shape </th>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Dask graph </th>\n",
-       "                        <td colspan=\"2\"> 1 chunks in 2 graph layers </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Data type </th>\n",
-       "                        <td colspan=\"2\"> float32 numpy.ndarray </td>\n",
-       "                    </tr>\n",
-       "                </tbody>\n",
-       "            </table>\n",
-       "        </td>\n",
-       "        <td>\n",
-       "        <svg width=\"170\" height=\"170\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"0\" y1=\"120\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,120.0 0.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"60.000000\" y=\"140.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1</text>\n",
-       "  <text x=\"140.000000\" y=\"60.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,60.000000)\">1</text>\n",
-       "</svg>\n",
-       "        </td>\n",
-       "    </tr>\n",
-       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span>lon</span></div><div class='xr-var-dims'>(trajectory, obs)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;</div><input id='attrs-d3794d21-3b54-48c7-b50d-a6f536bfb4c7' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-d3794d21-3b54-48c7-b50d-a6f536bfb4c7' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-aaf1b937-9098-424e-8090-514d21a948de' class='xr-var-data-in' type='checkbox'><label for='data-aaf1b937-9098-424e-8090-514d21a948de' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>axis :</span></dt><dd>X</dd><dt><span>long_name :</span></dt><dd></dd><dt><span>standard_name :</span></dt><dd>longitude</dd><dt><span>units :</span></dt><dd>degrees_east</dd></dl></div><div class='xr-var-data'><table>\n",
-       "    <tr>\n",
-       "        <td>\n",
-       "            <table style=\"border-collapse: collapse;\">\n",
-       "                <thead>\n",
-       "                    <tr>\n",
-       "                        <td> </td>\n",
-       "                        <th> Array </th>\n",
-       "                        <th> Chunk </th>\n",
-       "                    </tr>\n",
-       "                </thead>\n",
-       "                <tbody>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Bytes </th>\n",
-       "                        <td> 4 B </td>\n",
-       "                        <td> 4 B </td>\n",
-       "                    </tr>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Shape </th>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Dask graph </th>\n",
-       "                        <td colspan=\"2\"> 1 chunks in 2 graph layers </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Data type </th>\n",
-       "                        <td colspan=\"2\"> float32 numpy.ndarray </td>\n",
-       "                    </tr>\n",
-       "                </tbody>\n",
-       "            </table>\n",
-       "        </td>\n",
-       "        <td>\n",
-       "        <svg width=\"170\" height=\"170\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"0\" y1=\"120\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,120.0 0.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"60.000000\" y=\"140.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1</text>\n",
-       "  <text x=\"140.000000\" y=\"60.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,60.000000)\">1</text>\n",
-       "</svg>\n",
-       "        </td>\n",
-       "    </tr>\n",
-       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span>salinity</span></div><div class='xr-var-dims'>(trajectory, obs)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;</div><input id='attrs-18b5b7f0-f374-4264-b612-396bc728b9a3' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-18b5b7f0-f374-4264-b612-396bc728b9a3' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-bf3074a0-5134-40e5-bfba-63b838427498' class='xr-var-data-in' type='checkbox'><label for='data-bf3074a0-5134-40e5-bfba-63b838427498' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd></dd><dt><span>standard_name :</span></dt><dd>salinity</dd><dt><span>units :</span></dt><dd>unknown</dd></dl></div><div class='xr-var-data'><table>\n",
-       "    <tr>\n",
-       "        <td>\n",
-       "            <table style=\"border-collapse: collapse;\">\n",
-       "                <thead>\n",
-       "                    <tr>\n",
-       "                        <td> </td>\n",
-       "                        <th> Array </th>\n",
-       "                        <th> Chunk </th>\n",
-       "                    </tr>\n",
-       "                </thead>\n",
-       "                <tbody>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Bytes </th>\n",
-       "                        <td> 4 B </td>\n",
-       "                        <td> 4 B </td>\n",
-       "                    </tr>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Shape </th>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Dask graph </th>\n",
-       "                        <td colspan=\"2\"> 1 chunks in 2 graph layers </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Data type </th>\n",
-       "                        <td colspan=\"2\"> float32 numpy.ndarray </td>\n",
-       "                    </tr>\n",
-       "                </tbody>\n",
-       "            </table>\n",
-       "        </td>\n",
-       "        <td>\n",
-       "        <svg width=\"170\" height=\"170\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"0\" y1=\"120\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,120.0 0.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"60.000000\" y=\"140.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1</text>\n",
-       "  <text x=\"140.000000\" y=\"60.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,60.000000)\">1</text>\n",
-       "</svg>\n",
-       "        </td>\n",
-       "    </tr>\n",
-       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span>temperature</span></div><div class='xr-var-dims'>(trajectory, obs)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;</div><input id='attrs-2dd72712-97a9-4495-8841-d25595cef03e' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-2dd72712-97a9-4495-8841-d25595cef03e' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-1faaf322-3a15-49f9-9bc4-af8e60edfd84' class='xr-var-data-in' type='checkbox'><label for='data-1faaf322-3a15-49f9-9bc4-af8e60edfd84' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd></dd><dt><span>standard_name :</span></dt><dd>temperature</dd><dt><span>units :</span></dt><dd>unknown</dd></dl></div><div class='xr-var-data'><table>\n",
-       "    <tr>\n",
-       "        <td>\n",
-       "            <table style=\"border-collapse: collapse;\">\n",
-       "                <thead>\n",
-       "                    <tr>\n",
-       "                        <td> </td>\n",
-       "                        <th> Array </th>\n",
-       "                        <th> Chunk </th>\n",
-       "                    </tr>\n",
-       "                </thead>\n",
-       "                <tbody>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Bytes </th>\n",
-       "                        <td> 4 B </td>\n",
-       "                        <td> 4 B </td>\n",
-       "                    </tr>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Shape </th>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Dask graph </th>\n",
-       "                        <td colspan=\"2\"> 1 chunks in 2 graph layers </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Data type </th>\n",
-       "                        <td colspan=\"2\"> float32 numpy.ndarray </td>\n",
-       "                    </tr>\n",
-       "                </tbody>\n",
-       "            </table>\n",
-       "        </td>\n",
-       "        <td>\n",
-       "        <svg width=\"170\" height=\"170\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"0\" y1=\"120\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,120.0 0.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"60.000000\" y=\"140.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1</text>\n",
-       "  <text x=\"140.000000\" y=\"60.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,60.000000)\">1</text>\n",
-       "</svg>\n",
-       "        </td>\n",
-       "    </tr>\n",
-       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span>time</span></div><div class='xr-var-dims'>(trajectory, obs)</div><div class='xr-var-dtype'>datetime64[ns]</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;</div><input id='attrs-f9039433-d8c3-46f9-a850-55a7ab17ad59' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-f9039433-d8c3-46f9-a850-55a7ab17ad59' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-09e53e12-98df-4d2e-882b-e36750e7e203' class='xr-var-data-in' type='checkbox'><label for='data-09e53e12-98df-4d2e-882b-e36750e7e203' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>axis :</span></dt><dd>T</dd><dt><span>long_name :</span></dt><dd></dd><dt><span>standard_name :</span></dt><dd>time</dd></dl></div><div class='xr-var-data'><table>\n",
-       "    <tr>\n",
-       "        <td>\n",
-       "            <table style=\"border-collapse: collapse;\">\n",
-       "                <thead>\n",
-       "                    <tr>\n",
-       "                        <td> </td>\n",
-       "                        <th> Array </th>\n",
-       "                        <th> Chunk </th>\n",
-       "                    </tr>\n",
-       "                </thead>\n",
-       "                <tbody>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Bytes </th>\n",
-       "                        <td> 8 B </td>\n",
-       "                        <td> 8 B </td>\n",
-       "                    </tr>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Shape </th>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Dask graph </th>\n",
-       "                        <td colspan=\"2\"> 1 chunks in 2 graph layers </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Data type </th>\n",
-       "                        <td colspan=\"2\"> datetime64[ns] numpy.ndarray </td>\n",
-       "                    </tr>\n",
-       "                </tbody>\n",
-       "            </table>\n",
-       "        </td>\n",
-       "        <td>\n",
-       "        <svg width=\"170\" height=\"170\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"0\" y1=\"120\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,120.0 0.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"60.000000\" y=\"140.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1</text>\n",
-       "  <text x=\"140.000000\" y=\"60.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,60.000000)\">1</text>\n",
-       "</svg>\n",
-       "        </td>\n",
-       "    </tr>\n",
-       "</table></div></li><li class='xr-var-item'><div class='xr-var-name'><span>z</span></div><div class='xr-var-dims'>(trajectory, obs)</div><div class='xr-var-dtype'>float32</div><div class='xr-var-preview xr-preview'>dask.array&lt;chunksize=(1, 1), meta=np.ndarray&gt;</div><input id='attrs-c0d29665-b36f-48a3-a4f5-ae8829dcd48c' class='xr-var-attrs-in' type='checkbox' ><label for='attrs-c0d29665-b36f-48a3-a4f5-ae8829dcd48c' title='Show/Hide attributes'><svg class='icon xr-icon-file-text2'><use xlink:href='#icon-file-text2'></use></svg></label><input id='data-64ea9768-5c55-4081-9321-57dd53f67de7' class='xr-var-data-in' type='checkbox'><label for='data-64ea9768-5c55-4081-9321-57dd53f67de7' title='Show/Hide data repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-var-attrs'><dl class='xr-attrs'><dt><span>long_name :</span></dt><dd></dd><dt><span>positive :</span></dt><dd>down</dd><dt><span>standard_name :</span></dt><dd>depth</dd><dt><span>units :</span></dt><dd>m</dd></dl></div><div class='xr-var-data'><table>\n",
-       "    <tr>\n",
-       "        <td>\n",
-       "            <table style=\"border-collapse: collapse;\">\n",
-       "                <thead>\n",
-       "                    <tr>\n",
-       "                        <td> </td>\n",
-       "                        <th> Array </th>\n",
-       "                        <th> Chunk </th>\n",
-       "                    </tr>\n",
-       "                </thead>\n",
-       "                <tbody>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Bytes </th>\n",
-       "                        <td> 4 B </td>\n",
-       "                        <td> 4 B </td>\n",
-       "                    </tr>\n",
-       "                    \n",
-       "                    <tr>\n",
-       "                        <th> Shape </th>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                        <td> (1, 1) </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Dask graph </th>\n",
-       "                        <td colspan=\"2\"> 1 chunks in 2 graph layers </td>\n",
-       "                    </tr>\n",
-       "                    <tr>\n",
-       "                        <th> Data type </th>\n",
-       "                        <td colspan=\"2\"> float32 numpy.ndarray </td>\n",
-       "                    </tr>\n",
-       "                </tbody>\n",
-       "            </table>\n",
-       "        </td>\n",
-       "        <td>\n",
-       "        <svg width=\"170\" height=\"170\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
-       "\n",
-       "  <!-- Horizontal lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"120\" y2=\"0\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"0\" y1=\"120\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Vertical lines -->\n",
-       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"120\" style=\"stroke-width:2\" />\n",
-       "\n",
-       "  <!-- Colored Rectangle -->\n",
-       "  <polygon points=\"0.0,0.0 120.0,0.0 120.0,120.0 0.0,120.0\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
-       "\n",
-       "  <!-- Text -->\n",
-       "  <text x=\"60.000000\" y=\"140.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >1</text>\n",
-       "  <text x=\"140.000000\" y=\"60.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,140.000000,60.000000)\">1</text>\n",
-       "</svg>\n",
-       "        </td>\n",
-       "    </tr>\n",
-       "</table></div></li></ul></div></li><li class='xr-section-item'><input id='section-f9b3e022-1961-4128-a835-6f2829d683d8' class='xr-section-summary-in' type='checkbox'  ><label for='section-f9b3e022-1961-4128-a835-6f2829d683d8' class='xr-section-summary' >Indexes: <span>(2)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><ul class='xr-var-list'><li class='xr-var-item'><div class='xr-index-name'><div>obs</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-d273173a-fd72-453d-9988-284d967d4e89' class='xr-index-data-in' type='checkbox'/><label for='index-d273173a-fd72-453d-9988-284d967d4e89' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([0], dtype=&#x27;int32&#x27;, name=&#x27;obs&#x27;))</pre></div></li><li class='xr-var-item'><div class='xr-index-name'><div>trajectory</div></div><div class='xr-index-preview'>PandasIndex</div><div></div><input id='index-b1e0804a-4162-4593-ba9a-3b627e3f8cee' class='xr-index-data-in' type='checkbox'/><label for='index-b1e0804a-4162-4593-ba9a-3b627e3f8cee' title='Show/Hide index repr'><svg class='icon xr-icon-database'><use xlink:href='#icon-database'></use></svg></label><div class='xr-index-data'><pre>PandasIndex(Index([42], dtype=&#x27;int64&#x27;, name=&#x27;trajectory&#x27;))</pre></div></li></ul></div></li><li class='xr-section-item'><input id='section-760a1f4e-ee08-4dbd-ae45-e95fd1489b8b' class='xr-section-summary-in' type='checkbox'  checked><label for='section-760a1f4e-ee08-4dbd-ae45-e95fd1489b8b' class='xr-section-summary' >Attributes: <span>(5)</span></label><div class='xr-section-inline-details'></div><div class='xr-section-details'><dl class='xr-attrs'><dt><span>Conventions :</span></dt><dd>CF-1.6/CF-1.7</dd><dt><span>feature_type :</span></dt><dd>trajectory</dd><dt><span>ncei_template_version :</span></dt><dd>NCEI_NetCDF_Trajectory_Template_v2.0</dd><dt><span>parcels_mesh :</span></dt><dd>spherical</dd><dt><span>parcels_version :</span></dt><dd>3.0.2</dd></dl></div></li></ul></div></div>"
-      ],
-      "text/plain": [
-       "<xarray.Dataset> Size: 40B\n",
-       "Dimensions:      (trajectory: 1, obs: 1)\n",
-       "Coordinates:\n",
-       "  * obs          (obs) int32 4B 0\n",
-       "  * trajectory   (trajectory) int64 8B 42\n",
-       "Data variables:\n",
-       "    lat          (trajectory, obs) float32 4B dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-       "    lon          (trajectory, obs) float32 4B dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-       "    salinity     (trajectory, obs) float32 4B dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-       "    temperature  (trajectory, obs) float32 4B dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-       "    time         (trajectory, obs) datetime64[ns] 8B dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-       "    z            (trajectory, obs) float32 4B dask.array<chunksize=(1, 1), meta=np.ndarray>\n",
-       "Attributes:\n",
-       "    Conventions:            CF-1.6/CF-1.7\n",
-       "    feature_type:           trajectory\n",
-       "    ncei_template_version:  NCEI_NetCDF_Trajectory_Template_v2.0\n",
-       "    parcels_mesh:           spherical\n",
-       "    parcels_version:        3.0.2"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ds"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.collections.PathCollection at 0x144b10550>"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x1000 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots(1, 1, figsize=(10, 10))\n",
-    "ax.scatter(x, y, c=T, s=20, marker=\"o\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py3_parcels",
-   "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.11.3"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/src/submit.sh b/src/submit.sh
deleted file mode 100644
index 7873fa87..00000000
--- a/src/submit.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash -l
-#
-#SBATCH -J VSC              # the name of your job   
-#SBATCH -p short            # request the short partition, job takes less than 3 hours  
-#SBATCH -t 3:00:00          # time in hh:mm:ss you want to reserve for the job
-#SBATCH -n 1                # the number of cores you want to use for the job, SLURM automatically determines how many nodes are needed
-#SBATCH -o log%j.o        # the name of the file where the standard output will be written to. %j will be the jobid determined by SLURM
-#SBATCH -e log%j.e        # the name of the file where potential errors will be written to. %j will be the jobid determined by SLURM
-
-conda activate parcels
-srun ./cruise_simulation_CTD.py           
diff --git a/virtualship.py b/virtualship.py
deleted file mode 100644
index 6ac71b70..00000000
--- a/virtualship.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from virtual_ship.virtual_ship_configuration import VirtualShipConfiguration
-from virtual_ship.sailship import sailship
-
-if __name__ == "__main__":
-    config = VirtualShipConfiguration("student_input.json")
-    sailship(config)