diff --git a/book/_toc.yml b/book/_toc.yml
index fca3173..72c7030 100644
--- a/book/_toc.yml
+++ b/book/_toc.yml
@@ -15,9 +15,8 @@ parts:
 - caption: Ocean Data Science
   chapters:
     - file: chapters/ocean_science
-    - file: chapters/shallowprofiler
     - file: chapters/data
-    - file: chapters/data2
+    - file: chapters/shallowprofiler
     - file: chapters/anomaly
     - file: chapters/anomaly2
     - file: chapters/anomaly3
diff --git a/book/chapters/data.ipynb b/book/chapters/data.ipynb
index 783625a..3453903 100644
--- a/book/chapters/data.ipynb
+++ b/book/chapters/data.ipynb
@@ -19,96 +19,119 @@
     "- Platform metadata: When a profiler is ascending / descending / at rest?\n",
     "- Sensor data: What is the temperature as a function of depth for a given profile?\n",
     "\n",
+    "\n",
     "### Profile metadata\n",
     "\n",
-    "Profiles are not acquired instantaneously. Rather they take on the order of an \n",
-    "hour to complete (where again there are typically nine profiles run per day). \n",
-    "We treat this hour as an observation or an *observational moment*.\n",
     "\n",
+    "Profiles are not acquired instantaneously. One profile takes on the order of an hour\n",
+    "as the Science Pod rises with positive buoyancy about 180 meters to near the surface\n",
+    "and then is winched back down to the shallow profiler platform. \n",
+    "Typically nine profiles run per day. As a baseline we can view each profile \n",
+    "as an *observation* of the state of the epipelagic water column.\n",
+    "Correspondingly, charts of sensor data do not feature a time axis. Rather the vertical \n",
+    "axis is depth with the surface at the top. The horizontal axis is then the sensor \n",
+    "parameter: Temperature, salinity, dissolved oxygen, fluorescence etcetera.\n",
     "\n",
-    "### Sensor data\n",
     "\n",
+    "Isolating sensor data from a particular profile is a necessary task. This is done\n",
+    "in terms of time boundaries, typically start of ascent to end of ascent. This information\n",
+    "in stored as profile timestamp metadata. (Sensor data includes timestamps and depth but\n",
+    "no information on the state of the science pod.) \n",
+    "A single profiles is viewed as three consecutive stages: Rest, Ascent, and Descent.\n",
+    "The Rest stage consists of the Science Pod parked at the platform at a depth of 200 meters. \n",
     "\n",
-    "There are about 31 million seconds in a year; and the sampling rate for many\n",
-    "shallow profilers is about one sample per second. As a result some data volume\n",
-    "management is necessary. A workable time range for high sample rate data is\n",
-    "somewhere between one day and one month.\n",
     "\n",
+    "Profile stage metadata describing the timestamps is stored in a CSV file in this\n",
+    "repository. That information is read in to memory as a pandas DataFrame for reference \n",
+    "in time-boxing profiles.\n",
     "\n",
-    "The following are data management considerations:\n",
+    "\n",
+    "### Sensor data\n",
     "\n",
     "\n",
-    "- large datasets can be saved externally to the Jupyter Book repository\n",
+    "There are about 31 million seconds in a year; and the sampling rate for many\n",
+    "shallow profilers is about one sample per second. As a result some data volume\n",
+    "management is necessary. We can, for example, work with smaller blocks of time, \n",
+    "typically somewhere between one day and one month.\n",
+    "\n",
+    "\n",
+    "### Summary of data management considerations\n",
+    "\n",
+    "\n",
+    "- Profile metadata is relatively small volume, resides within this Book/Repository\n",
+    "- Sensor data volume can be understood in terms of measurements\n",
+    "    - One measurement per second is typical\n",
+    "    - 31 million seconds per year\n",
+    "    - Each sensor measurement is { sensed value, pressure/depth, timestamp }\n",
+    "        - Sensor data also includes some quality control; typically ignored (dropped) here\n",
+    "    - There are about 22 sensor values\n",
+    "        - Most measurements are made on *ascent*, some on *descent* as noted\n",
+    "        - Three of these are from a fluorometer instrument\n",
+    "        - Two of these are nitrate measurements\n",
+    "        - Seven of these are spectral irradiance channels\n",
+    "        - Not included: Spectrophotometer data\n",
+    "    - Water density is a measurement derived from temperature, pressure and salinity\n",
+    "    - Data goes back as far as 2015\n",
+    "        - There are gaps in the data owing to maintenance etcetera\n",
+    "    - There are three shallow profiler sites\n",
+    "        - Coastal Endurance \"Oregon Offshore\" in 500m depth, distal edge of the continental shelf\n",
+    "        - RCA \"Oregon Slope Base\" at 3000m depth, bottom of the continental shelf break\n",
+    "        - RCA \"Axial Base\" at 2100m depth, further out in the Pacific at the base of Axial Seamount\n",
+    "- Moderate-size datasets can be stored in this repository\n",
+    "- Large datasets can be saved external to the repository\n",
     "    - GitHub recommends a maximum file size of 50MB\n",
-    "    - We would like to do virtual or *lazy* loading of data structures\n",
-    "        - This means the data are not actually read from an external source until needed\n",
-    "    - We have two means of reducing data volume\n",
-    "        - Strip away excess data not of interest\n",
-    "        - sub-sample profile\n",
-    "\n"
+    "- We can take advantage of virtual or *lazy* loading of data structures\n",
+    "    - The data are not literally read into memory from local storage\n",
+    "    - Rather a description of the data is read into memory from remote or external storage\n",
+    "        - This allows for virtual data reduction before actual data is read\n",
+    "        - There are two means of reducing data volume\n",
+    "            - Strip away excess data that is not of immediate interest\n",
+    "            - sub-sample profile data at different vertical resolutions"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Inbound data structure\n",
-    "\n",
-    "\n",
-    "\n",
-    "There are two levels of source data time resolution: 1-minute average sampling\n",
-    "and full resolution sampling; which amounts to about 1 sample per second. \n",
-    "The 1-minute-per-sample data will be smoother via \n",
-    "averaging with the tradeoff of coarser depth resolution.\n",
-    "\n",
-    "\n",
-    "Again: Inbound data from OOI is kept outside this repo: In its own `/data/rca` \n",
-    "folder. This inbound data folder structure is as follows:\n",
-    "\n",
+    "### Repository folder structure\n",
     "\n",
     "\n",
     "```\n",
-    "$HOME/../data/rca/\n",
-    "                  OregonSlopeBase/\n",
-    "                                  platform/                (pc01a)\n",
-    "                                           [missing: velocity]\n",
-    "                                  profiler/                (sf01a)\n",
-    "                                           par/    \n",
-    "                                           do/\n",
-    "                                           vel/\n",
-    "                                           ctd/\n",
-    "                                           fluor/\n",
-    "                                           nitrate/\n",
-    "                                           pco2/\n",
-    "                                           ph/\n",
-    "                                           spkir/\n",
-    "                                           fullres_ctd/ etcetera\n",
-    "                  OregonOffshore/\n",
-    "                                  platform/                (pc01b)\n",
-    "                                  profiler/                (sf01b)\n",
-    "                  AxialBase/ \n",
-    "                                  platform/               (pc03a)\n",
-    "                                  profiler/               (sf03a)\n",
-    "\n",
+    "~/book/_toc.yml               -- table of contents --\n",
+    "       img/                   -- contains resource images --\n",
+    "       chapters/              -- Jupyter notebooks map to book chapters --\n",
+    "                data/               -- repo data storage space --\n",
+    "                     modis/              -- Data from the MODIS satellite system\n",
+    "                     argo/               -- Data from the ARGO drifter program\n",
+    "                     roms/               -- Data from the Regional Ocean Modeling System (ROMS)\n",
+    "                     rca/                -- Data from the regional cabled array--\n",
+    "                         profiles/       -- Profile metadata folder--\n",
+    "                                  axb/         -- Site subdirectories --\n",
+    "                                  oos/\n",
+    "                                  osb/\n",
+    "                                      2019.csv     -- Profile metadata for 2019 at the OSB site --\n",
+    "                         sensors/        -- Sensor (measurement) data from shallow profilers / platforms\n",
+    "                                 axb/            -- Axial Base site\n",
+    "                                 oos/            -- Oregon Offshore site\n",
+    "                                 osb/            -- Oregons Slope Base site\n",
+    "                                     ctd_jan22_temperature.nc       -- instrument = CTD, jan22 = time range, sensor = temperature\n",
     "```\n",
     "\n",
-    "Please note that 1-minute-sample data goes into folders with no prefix; and \n",
-    "full resolution (1-second-sample) data folders have the `fullres_` prefix \n",
-    "as in `fullres_ctd`.\n",
-    "\n",
     "\n",
-    "There are two resources for shallow profiler data:\n",
+    "### Data systems \n",
     "\n",
     "\n",
-    "- [Ocean Observatories Initiative **Data Explorer**](https://dataexplorer.oceanobservatories.org/)\n",
-    "- [Interactive Oceans **Data Portal**](https://interactiveoceans.washington.edu) which is specific to the Regional Cabled Array"
+    "Shallow profiler data was originally pulled from the [OOI Data Explorer](https://dataexplorer.oceanobservatories.org/).\n",
+    "This practice is now deprecated in favor of the [Interactive Oceans **Data Portal**](https://interactiveoceans.washington.edu).\n",
+    "The latter system includes shallow profiler data held on cloud object storage. The access pattern is described below.\n",
+    "The **Interactive Oceans** website has built-in data exploration and is very educator-friendly. "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Terms used\n",
+    "### Terminology\n",
     "\n",
     "\n",
     "* Regional Cabled Array (RCA): A cabled observatory on the sea floor and in select locations rising up through the water column: off the coast of Oregon\n",
@@ -129,15 +152,15 @@
     "#### Sensor dictionary with abbreviations\n",
     "\n",
     "\n",
-    "- This table is alphabetized by short abbreviation for the moment\n",
-    "\n",
-    "\n",
-    "- The instrument name corresponds to the folder structure given above\n",
-    "\n",
-    "\n",
-    "- Spectral irradiance is abbreviated `spkir` in the OOI nomenclature and this\n",
-    "is retained here. The instrument brings in seven spectral channels (sensors)\n",
-    "with wavelengths in *nm* as indicated.\n",
+    "The following table lists sensors in relation to instruments. \n",
+    "Short abbreviations are included. They are sometimes used in the code to \n",
+    "make it easier to read. \n",
+    "Spectral irradiance is abbreviated `spkir` in OOI nomenclature. This \n",
+    "data is broken out by wavelength channel (7 total) into separate sensors.\n",
+    "The `spec` instrument is a spectrophotometer with 83 channels. This \n",
+    "is treated separate from the main collection of shallow profiler sensors. \n",
+    "The `current` instrument is a platform-mounted current sensor providing\n",
+    "three-dimensional estimates of current with depth.\n",
     "\n",
     "\n",
     "```\n",
@@ -172,58 +195,6 @@
     "```"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Data download\n",
-    "\n",
-    "\n",
-    "As noted above: [OOI](https://oceanobservatories.org) \n",
-    "provides data access via the [Data Explorer](https://dataexplorer.oceanobservatories.org/).\n",
-    "An alternative resource particular to the *OOI cabled array* is the\n",
-    "[Cabled Array data server](https://interactiveoceans.washington.edu).\n",
-    "This site is oriented towards built-in data exploration and is very educator-friendly. \n",
-    "\n",
-    "\n",
-    "#### Example download\n",
-    "\n",
-    "\n",
-    "- [Data access page in the Data Explorer](https://dataexplorer.oceanobservatories.org/#go-to-data-access)\n",
-    "- Access Array Data, Oregon Margin, Profiling Assets, All Instrument Types, All Parameters, Go\n",
-    "    - A very dense page with charts, tabs, multiple scroll bars and so forth\n",
-    "    - Exploration of the various tabs encouraged\n",
-    "        - **Data**, **Inventory**, **Downloads**, **Annotations**, **Deployments**\n",
-    "    - > **Downloads** tab\n",
-    "    - Full resolution data: 1 second per sample\n",
-    "        - Choose link '*full resolution downloads*'\n",
-    "        - Page of fluorometer datasets in deployment sequence: time ranges shown\n",
-    "        - Select Downloads > THREDDS Catalog > Dataset > page listing files\n",
-    "        - Deployment 8, FLORT for the triplet\n",
-    "        - Check the time range in the filename for best match to March 2021\n",
-    "        - Click to go to yet another page, this one for \"ACCESS\" and multiple choices\n",
-    "            - Select HTTPServer to download the NetCDF data file: 600+ MB\n",
-    "    - 1Min resolution: 1 minute per sample\n",
-    "        - Green **Download** button for various streams / sensors \n",
-    "        - Three format options: ERDDAP (+ 3 sub-options), CSV and NetCDF\n",
-    "            - NetCDF URL gives a shareable download link\n",
-    "            - NetCDF **Download** button > 1Min downsampled data\n",
-    "                - These datasets extend over the full OOI program duration: 2014 to present\n",
-    "            - Data description text + chart symbol (left) produces a curtain plot\n",
-    "\n",
-    "\n",
-    "Full resolution data is sub-divided into consecutive time ranges called \"deployments\". \n",
-    "The resulting NetCDF files have these distinctions compared to the 1Min data:\n",
-    "\n",
-    "\n",
-    "- Data is sampled at about one sample per second\n",
-    "- Sensors are combined in NetCDF files\n",
-    "    - For example a CTD file includes salinity, temperature, pressure, density and conductivity\n",
-    "- The data files are much larger on average\n",
-    "- The sample dimension is `obs` (observation number) rather than `row`\n",
-    "    - However the swap procedure is the same: Swap in `time`\n"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -231,31 +202,7 @@
     "#### Code note\n",
     "\n",
     "\n",
-    "This notebook refers to functions in the companion module file `data.py`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Jupyter Notebook running Python 3\n"
-     ]
-    }
-   ],
-   "source": [
-    "from matplotlib import pyplot as plt\n",
-    "\n",
-    "from data import *\n",
-    "\n",
-    "print('\\nJupyter Notebook running Python {}'.format(sys.version_info[0]))"
+    "This notebook refers to functions in modules `data.py` and `shallowprofiler.py`."
    ]
   },
   {
@@ -264,136 +211,27 @@
     "tags": []
    },
    "source": [
-    "```\n",
-    "operating on '../../../data/rca/OregonSlopeBase/profiler/ctd/ooi-rs01sbps-sf01a-2a-ctdpfa102_6974_57e0_dbda.nc' and so on\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "###### Uncomment the line of code below and run this cell once per each month-long in-repo sensor data file\n",
-    "# Example output file: 'axb_nitrate_jan22_nitrate.nc' gives site, instrument, sensor and time range\n",
-    "# spkir requires only one output file; but seven sensor re-names: To 'spkir412nm' etcetera.\n",
-    "\n",
-    "# if not ReformatDataFile(False): print('ReformatDataFile() returned False')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "#### Test dataset\n",
-    "\n",
-    "On 10/16/23 the 1min datasets (repo-external /data folder) from OOI were processed for storage\n",
-    "and use in this repository. The file naming convention is \n",
-    "\n",
-    "\n",
-    "**`<site>_<instrument>_<month>_<sensor>.nc`**.\n",
-    "\n",
-    "\n",
-    "Hence for the Oregon Slope Base profiler we have `osb_spkir_jan22_spkir412nm.nc` using the OOI abbreviation\n",
-    "for spectral irradiance **`spkir`**. The instrument is spkir and the sensor is spkir412nm. \n",
-    "\n",
-    "\n",
-    "\n",
-    "Note that the sensor and instrument are the same in this case; \n",
-    "but in a confusing twist: Spectral irradiance is expressed as seven wavelengths. So that is a special \n",
-    "case in the subsequent data dictionary build. Simpler sensors are `par`, `do`, `nitrate`, `pco2` and `ph`.\n",
-    "For all of these the instrument and sensor names are the same. \n",
-    "In the case of the fluorometer, current velocity and CTD `instruments` there are multiple sensors:\n",
-    "The sensor name is not the same as the instrument.\n",
-    "\n",
-    "\n",
-    "Data reduction:\n",
-    "\n",
-    "\n",
-    "- Jan 1 to Feb 1 2021 in prog\n",
-    "- Apr 1 to May 1 2021 done\n",
-    "- Jul 1 to Aug 1 2021 done\n",
-    "- Oct 1 to Nov 1 2021 in prog\n",
-    "- Jan 1 to Feb 1 2022 done\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Jupyter Notebook running Python 3\n"
-     ]
-    }
-   ],
-   "source": [
-    "from shallowprofiler import sensors\n",
+    "***Tasks***\n",
     "\n",
-    "date_id = 'apr21'\n",
-    "site_id = 'osb'\n",
     "\n",
-    "data_file_list = []\n",
-    "for s in sensors:\n",
-    "    data_file_list.append(site_id + '_' + s[1] + '_' + date_id + '_' + s[0] + '.nc')   # example: 'osb_ctd_jul21_temperature.nc'"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Data review\n",
+    "- This section does not demonstrate profile use; but it should\n",
+    "- This section effectively does the profile-from-data chart twice; once is enough\n",
+    "- Mothball the ReformatDataFile() function in `data.py` which is part of the old Data Explorer procedure.\n",
+    "- Move ProfilerDepthChart() to a module file\n",
+    "- Deal with the code artifact below on WriteProfile()\n",
     "\n",
     "\n",
-    "The above cell generates time-bounded NetCDF measurement data files for in-repo output. \n",
-    "To review these files and their *XArray Dataset data variable* names: Activate and run the\n",
-    "following code. The cell below captures these names into a list of lists.\n",
-    "    \n",
     "```\n",
-    "data_prefix = '../data/'\n",
-    "for f in data_file_list:\n",
-    "    ds = xr.open_dataset(data_prefix + f)\n",
-    "    print(ds)\n",
-    "    r = input('enter to continue')\n",
+    "# def WriteProfile(date_id):\n",
+    "#     fnm = '../data/osb_ctd_' + date_id + '_pressure.nc'                       \n",
+    "#     a0, a1, d0, d1, r0, r1 = ProfileGenerator(fnm, 'z', True)\n",
+    "    # last 2 days chart check: xr.open_dataset(fnm)['z'][-1440*2:-1].plot()\n",
+    "#     if not ProfileWriter('../profiles/osb_profiles_' + date_id + '.csv', a0, a1, d0, d1, r0, r1): print('ProfileWriter() is False')\n",
+    "#    \n",
+    "# for date_id in ['apr21', 'jul21', 'jan22']: WriteProfile(date_id)               # !!!!! hard coded flag\n",
     "```"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# The relative path to the data files from the Notebooks folder is up one level, then to the data folder\n",
-    "data_prefix = './rca/sensors/data/'\n",
-    "\n",
-    "# The data variables corresponding to the jan22_data files defined above\n",
-    "month_data_vars = [\n",
-    "    ['pressure'],['temperature'],['density'], ['salinity'], ['conductivity'],\n",
-    "    ['fdom'], ['chlora'], ['bb'],\n",
-    "    ['spkir412nm', 'spkir443nm', 'spkir490nm', 'spkir510nm', 'spkir555nm', 'spkir620nm', 'spkir683nm'],\n",
-    "    ['nitrate'],\n",
-    "    ['pco2'],\n",
-    "    ['do'],\n",
-    "    ['par'],\n",
-    "    ['ph'],\n",
-    "    ['up'], ['east'], ['north']\n",
-    "    ]"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -401,29 +239,22 @@
     "## Profiles\n",
     "\n",
     "\n",
-    "The final task of this notebook is to produce a table of profile metadata. \n",
-    "\n",
-    "\n",
-    "Profile timing is driven by the RCA engineering system, producing some variability in profile\n",
-    "timing. Also shallow profilers occasionally go out of service. Using profile time/depth data we\n",
-    "produce a table of timestamps corresponding to 3-part profile cycles: Ascent, Descent and Rest. \n",
-    "This table is used in subsequent analysis to isolate individual profiles.\n",
-    "\n",
+    "This section describes loading profile metadata: Pre-generated and stored in this \n",
+    "repository at relative path `./data/rca/profiles/<site-abbrev>`. \n",
     "\n",
-    "The following cell illustrates a typical day of profiling cycles.\n",
     "\n",
-    "\n",
-    "- The time scale for January 10 is in UTM hours\n",
-    "- Nine profiles are run, two of which are noticeably longer in duration\n",
-    "- The two longer profiles at midnight and noon associate with nitrate, pCO2 and pH measurement\n",
-    "    - These have built-in pauses for equilibration during descent\n",
-    "- During the *rest* intervals the profiler is secured in an anchored platform\n",
+    "- Time is UTM/Zulu.\n",
+    "- Typically nine profiles run per day, two of which are noticeably longer in duration\n",
+    "- The two longer profiles are at midnight and noon local time\n",
+    "    - They are associated with nitrate, pCO2 and pH measurement\n",
+    "    - These have built-in pauses on descent for equilibration\n",
+    "- During *rest* intervals the profiler is secured to the platform at 200m depth\n",
     "    - The platform has its own set of instruments"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 2,
    "metadata": {
     "tags": []
    },
@@ -432,12 +263,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Some relevant-in-time profiles\n"
+      "\n",
+      "Jupyter Notebook running Python 3\n",
+      "\n",
+      "Jupyter Notebook running Python 3\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x400 with 1 Axes>"
       ]
@@ -447,44 +291,30 @@
     }
    ],
    "source": [
-    "# Show two typical days of profiling depths with time\n",
+    "from matplotlib import pyplot as plt\n",
+    "from shallowprofiler import sensors\n",
+    "from data import *\n",
     "\n",
-    "def ProfilerDepthChart(t0, t1, fnm, annotate=False):\n",
+    "print('\\nJupyter Notebook running Python {}'.format(sys.version_info[0]))\n",
+    "\n",
+    "\n",
+    "def ProfilerDepthChart(t0, t1, fnm):\n",
     "    ds = xr.open_dataset(fnm).sel(time=slice(dt64(t0), dt64(t1)))\n",
     "    fig, axs = plt.subplots(figsize=(12,4), tight_layout=True)\n",
     "    axs.plot(ds.time, ds.z, marker='.', ms=11., color='k', mfc='r', linewidth='.0001')\n",
     "    axs.set(ylim = (-210., 0.), title='Shallow profiler depth over two days', ylabel='depth (m)', xlabel='Hours (UTM)')\n",
-    "    if annotate:\n",
-    "        axs.text(dt64('2021-03-31 22:15'), -184, 'AT')\n",
-    "        axs.text(dt64('2021-03-31 22:05'), -193, 'REST')\n",
-    "        axs.text(dt64('2021-04-01 07:40'), -205, 'midnight')\n",
-    "        axs.text(dt64('2021-04-01 21:30'), -205, 'noon')\n",
-    "        axs.text(dt64('2021-04-01 09:05'), -20, 'slow')\n",
-    "        axs.text(dt64('2021-04-01 09:05'), -30, 'descent')\n",
-    "        axs.text(dt64('2021-04-01 22:30'), -20, 'slow')\n",
-    "        axs.text(dt64('2021-04-01 22:30'), -30, 'descent')\n",
+    "    axs.text(dt64('2021-12-31 22:15'), -184, 'AT')\n",
+    "    axs.text(dt64('2021-12-31 22:05'), -193, 'REST')\n",
+    "    axs.text(dt64('2022-01-01 07:40'), -205, 'midnight')\n",
+    "    axs.text(dt64('2022-01-01 21:30'), -205, 'noon')\n",
+    "    axs.text(dt64('2022-01-01 09:05'), -20, 'slow')\n",
+    "    axs.text(dt64('2022-01-01 09:05'), -30, 'descent')\n",
+    "    axs.text(dt64('2022-01-01 22:30'), -20, 'slow')\n",
+    "    axs.text(dt64('2022-01-01 22:30'), -30, 'descent')\n",
     "    return True\n",
+    "    \n",
     "\n",
-    "ProfilerDepthChart('2021-04-01', '2021-04-03', data_prefix + data_file_list[0], True)  # index [0] is arbitrary; any dataset will include z data\n",
-    "\n",
-    "print('Some relevant-in-time profiles')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# def WriteProfile(date_id):\n",
-    "#     fnm = '../data/osb_ctd_' + date_id + '_pressure.nc'                       \n",
-    "#     a0, a1, d0, d1, r0, r1 = ProfileGenerator(fnm, 'z', True)\n",
-    "    # last 2 days chart check: xr.open_dataset(fnm)['z'][-1440*2:-1].plot()\n",
-    "#     if not ProfileWriter('../profiles/osb_profiles_' + date_id + '.csv', a0, a1, d0, d1, r0, r1): print('ProfileWriter() is False')\n",
-    "#    \n",
-    "# for date_id in ['apr21', 'jul21', 'jan22']: WriteProfile(date_id)               # !!!!! hard coded flag"
+    "ProfilerDepthChart('2022-01-01', '2022-01-03', './data/rca/sensors/osb/ctd_jan22_conductivity.nc')  # index [0] is arbitrary; any dataset will include z data"
    ]
   },
   {
@@ -511,7 +341,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "metadata": {
     "tags": []
    },
@@ -520,7 +350,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "...April 2021 Oregon Slope Base daily profiles...\n"
+      "...January 2022 Oregon Slope Base daily profiles...\n"
      ]
     },
     {
@@ -529,13 +359,13 @@
        "True"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1500x300 with 3 Axes>"
       ]
@@ -550,7 +380,7 @@
     "# !!!!! flag move to charts\n",
     "\n",
     "def VisualizeProfiles(date_id, n_days, year_id, month_id, month_name, site_name):\n",
-    "    ds = xr.open_dataset('./rca/sensors/data/osb_ctd_' + date_id + '_pressure.nc')\n",
+    "    ds = xr.open_dataset('./data/rca/sensors/osb/ctd_jan22_conductivity.nc')\n",
     "    fig, axs = plt.subplots(n_days, 1, figsize=(15,n_days), tight_layout=True)\n",
     "\n",
     "    for i in range(n_days):\n",
@@ -565,7 +395,7 @@
     "    return True\n",
     "\n",
     "\n",
-    "VisualizeProfiles('apr21', 3, '2021', '04', 'April', 'Oregon Slope Base')\n"
+    "VisualizeProfiles('jan22', 3, '2022', '01', 'January', 'Oregon Slope Base')\n"
    ]
   },
   {
@@ -582,6 +412,482 @@
     "```\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sensor Data\n",
+    "\n",
+    "\n",
+    "This section connects to existing sensor datasets, data found within the repository corresponding to\n",
+    "the Oregon Slope Base ('osb') site during January 2022. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-rw-r--r-- 1 rob rob 894104 Jun 16 17:20 ./data/rca/sensors/osb/ctd_jan22_conductivity.nc\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "base_path = './data/rca/sensors/'\n",
+    "date_id   = 'jan22'\n",
+    "site_id   = 'osb'\n",
+    "\n",
+    "data_file_list = []\n",
+    "for s in sensors:\n",
+    "    data_file_list.append(base_path + site_id + '/' + s[1] + '_' + date_id + '_' + s[0] + '.nc')   # example result: 'osb/ctd_jan22_temperature.nc'\n",
+    "\n",
+    "!ls -al ./data/rca/sensors/osb/ctd_jan22_conductivity.nc\n",
+    "\n",
+    "# relative path to data files is base_path + site_id + '/'\n",
+    "# The data variables corresponding to the jan22_data filenames in data_file_list[]:\n",
+    "month_data_vars = [\n",
+    "    ['pressure'],['temperature'],['density'], ['salinity'], ['conductivity'],\n",
+    "    ['fdom'], ['chlora'], ['bb'],\n",
+    "    ['spkir412nm', 'spkir443nm', 'spkir490nm', 'spkir510nm', 'spkir555nm', 'spkir620nm', 'spkir683nm'],\n",
+    "    ['nitrate'],\n",
+    "    ['pco2'],\n",
+    "    ['do'],\n",
+    "    ['par'],\n",
+    "    ['ph'],\n",
+    "    ['up'], ['east'], ['north']\n",
+    "    ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dataset check\n",
+    "\n",
+    "\n",
+    "The above cell creates `data_file_list`: A list of time-bounded NetCDF sensor measurement files (in-repo). \n",
+    "To review these files in more detail:\n",
+    "    \n",
+    "\n",
+    "```\n",
+    "ds = xr.open_dataset(data_file_list[0])\n",
+    "print(ds)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "List Oregon Slope Base Profiler streams:\n",
+      "\n",
+      "ooi-data/RS01SBPS-SF01A-2A-CTDPFA102-streamed-ctdpf_sbe43_sample\n",
+      "ooi-data/RS01SBPS-SF01A-2D-PHSENA101-streamed-phsen_data_record\n",
+      "ooi-data/RS01SBPS-SF01A-3A-FLORTD101-streamed-flort_d_data_record\n",
+      "ooi-data/RS01SBPS-SF01A-3B-OPTAAD101-streamed-optaa_sample\n",
+      "ooi-data/RS01SBPS-SF01A-3C-PARADA101-streamed-parad_sa_sample\n",
+      "ooi-data/RS01SBPS-SF01A-3D-SPKIRA101-streamed-spkir_data_record\n",
+      "ooi-data/RS01SBPS-SF01A-4A-NUTNRA101-streamed-nutnr_a_dark_sample\n",
+      "ooi-data/RS01SBPS-SF01A-4A-NUTNRA101-streamed-nutnr_a_sample\n",
+      "ooi-data/RS01SBPS-SF01A-4B-VELPTD102-streamed-velpt_velocity_data\n",
+      "ooi-data/RS01SBPS-SF01A-4F-PCO2WA101-streamed-pco2w_a_sami_data_record\n",
+      "\n",
+      "Translation:\n",
+      "  CTDPF / ctdpf                 CTD\n",
+      "  PHSEN / phsen                 pH\n",
+      "  FLORT / flort                 Fluorometer { FDOM, Chlor-A, Backscatter }\n",
+      "  OPTAA / optaa                 Spectrophotometer\n",
+      "  PARAD / parad                 PAR\n",
+      "  SPKIR / spkir                 Spectral Irradiance\n",
+      "  NUTNR / nutnr_a_dark_sample   Nitrate: Dark sample (explain please)\n",
+      "  NUTNR / nutnr_a_sample        Nitrate: ...\n",
+      "  VELPT / velpt                 Velocity (current) ambiguous: on SCIP or affixed to platform?\n",
+      "  PCO2W / pco2w                 pCO2\n",
+      "\n",
+      "\n",
+      "Full stream name: ooi-data/CE04OSPS-SF01B-2A-CTDPFA107-streamed-ctdpf_sbe43_sample\n",
+      "\n",
+      "Field breakout: CE 04 OS PS SF 01 B 2A CTDPF A 107 ctdpf_sbe43_sample\n",
+      "\n",
+      "The first field has CE for Coastal Endurance or RS for Regional Cabled Array.\n",
+      "Fields 5, 6 and 7 give us shallow profiler site and choice of profiler or platform.\n",
+      "\n",
+      "    PC 01 B --> Oregon Offshore 200m Platform\n",
+      "    SF 01 B --> Oregon Offshore Profiler\n",
+      "    PC 01 A --> Oregon Slope Base Profiler\n",
+      "    SF 01 A --> Oregon Slope Base Profiler\n",
+      "    PC 03 A --> Axial Base 200m Platform\n",
+      "    SF 03 A --> Axial Base Profiler\n",
+      "\n",
+      "Non-shallow-profiler examples:\n",
+      "  DP O3 A is the Axial Base Deep Profiler\n",
+      "  LJ 01 A is the Oregon Slope Base Seafloor\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# this cell connects to the RCA Zarr filesystem on the cloud and lists available data streams\n",
+    "\n",
+    "import netCDF4\n",
+    "import xarray as xr\n",
+    "import s3fs\n",
+    "\n",
+    "fs = s3fs.S3FileSystem(anon=True)\n",
+    "\n",
+    "streamlist = fs.listdir('ooi-data', detail = False)\n",
+    "\n",
+    "def InstrumentBreakout(s):\n",
+    "    print('Field breakout:', s[9:11], s[11:13], s[13:15], s[15:17], s[18:20], s[20:22], s[22:23], s[24:26], \\\n",
+    "          s[27:32], s[32:33], s[33:36], s[46:])\n",
+    "\n",
+    "print('List Oregon Slope Base Profiler streams:\\n')\n",
+    "for s in streamlist:\n",
+    "    if 'SF01A' in s: print(s)\n",
+    "print()\n",
+    "print('Translation:')\n",
+    "print('  CTDPF / ctdpf                 CTD')\n",
+    "print('  PHSEN / phsen                 pH')\n",
+    "print('  FLORT / flort                 Fluorometer { FDOM, Chlor-A, Backscatter }')\n",
+    "print('  OPTAA / optaa                 Spectrophotometer') \n",
+    "print('  PARAD / parad                 PAR')\n",
+    "print('  SPKIR / spkir                 Spectral Irradiance')\n",
+    "print('  NUTNR / nutnr_a_dark_sample   Nitrate: Dark sample (explain please)')\n",
+    "print('  NUTNR / nutnr_a_sample        Nitrate: ...')\n",
+    "print('  VELPT / velpt                 Velocity (current) ambiguous: on SCIP or affixed to platform?')\n",
+    "print('  PCO2W / pco2w                 pCO2')\n",
+    "print()\n",
+    "\n",
+    "stream_choice = 15       # the 15th element in the file list corresponds to the Shallow Profiler, Oregon Slope Base site\n",
+    "\n",
+    "print()\n",
+    "print('Full stream name:', streamlist[stream_choice])\n",
+    "print()\n",
+    "InstrumentBreakout(streamlist[stream_choice])\n",
+    "print()\n",
+    "print('The first field has CE for Coastal Endurance or RS for Regional Cabled Array.')\n",
+    "print('Fields 5, 6 and 7 give us shallow profiler site and choice of profiler or platform.')\n",
+    "print()\n",
+    "indenter = 4\n",
+    "print(' '*indenter + 'PC 01 B --> Oregon Offshore 200m Platform')\n",
+    "print(' '*indenter + 'SF 01 B --> Oregon Offshore Profiler')\n",
+    "print(' '*indenter + 'PC 01 A --> Oregon Slope Base Profiler')\n",
+    "print(' '*indenter + 'SF 01 A --> Oregon Slope Base Profiler')\n",
+    "print(' '*indenter + 'PC 03 A --> Axial Base 200m Platform')\n",
+    "print(' '*indenter + 'SF 03 A --> Axial Base Profiler')\n",
+    "print()\n",
+    "print('Non-shallow-profiler examples:')\n",
+    "print('  DP O3 A is the Axial Base Deep Profiler')\n",
+    "print('  LJ 01 A is the Oregon Slope Base Seafloor')\n",
+    "print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "OSB CTD stream: ooi-data/RS01SBPS-SF01A-2A-CTDPFA102-streamed-ctdpf_sbe43_sample\n",
+      "\n",
+      "site data is now lazy-loaded\n",
+      "<xarray.DataArray 'time' ()>\n",
+      "array('2024-07-06T11:12:59.607388672', dtype='datetime64[ns]')\n",
+      "Coordinates:\n",
+      "    time     datetime64[ns] 2024-07-06T11:12:59.607388672\n",
+      "Attributes:\n",
+      "    axis:           T\n",
+      "    long_name:      time\n",
+      "    standard_name:  time\n"
+     ]
+    }
+   ],
+   "source": [
+    "osb_profiler_streams = [sname for sname in streamlist if 'SF01A' in sname]\n",
+    "for s in osb_profiler_streams: \n",
+    "    if 'ctdpf' in s: osb_sp_ctd = s\n",
+    "\n",
+    "print('OSB CTD stream:', osb_sp_ctd)\n",
+    "print()\n",
+    "\n",
+    "def loadData(stream_name):\n",
+    "    fs = s3fs.S3FileSystem(anon=True)\n",
+    "    zarr_store = fs.get_mapper(stream_name)\n",
+    "    ds = xr.open_zarr(zarr_store, consolidated=True)\n",
+    "    return ds\n",
+    "\n",
+    "siteData = loadData(osb_sp_ctd)\n",
+    "# siteData\n",
+    "print('site data is now lazy-loaded')\n",
+    "\n",
+    "print(siteData.time[-1])\n",
+    "\n",
+    "from shallowprofiler import *\n",
+    "from charts import *\n",
+    "\n",
+    "profiles = ReadProfileMetadata()    # this is an error: Hardcoded for Jan 2022\n",
+    "how_many_charts = 3\n",
+    "profile_list = [n for n in range(how_many_charts)]   # quick check: use d['temperature'].z.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: b'/home/rob/oceanography/book/chapters/rca/sensors/data/osb_ctd_jan22_conductivity.nc'",
+     "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/argo-env2/lib/python3.11/site-packages/xarray/backends/file_manager.py:211\u001b[0m, in \u001b[0;36mCachingFileManager._acquire_with_cache_info\u001b[0;34m(self, needs_lock)\u001b[0m\n\u001b[1;32m    210\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 211\u001b[0m     file \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cache[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_key]\n\u001b[1;32m    212\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/argo-env2/lib/python3.11/site-packages/xarray/backends/lru_cache.py:56\u001b[0m, in \u001b[0;36mLRUCache.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m     55\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n\u001b[0;32m---> 56\u001b[0m     value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cache[key]\n\u001b[1;32m     57\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cache\u001b[38;5;241m.\u001b[39mmove_to_end(key)\n",
+      "\u001b[0;31mKeyError\u001b[0m: [<class 'netCDF4._netCDF4.Dataset'>, ('/home/rob/oceanography/book/chapters/rca/sensors/data/osb_ctd_jan22_conductivity.nc',), 'r', (('clobber', True), ('diskless', False), ('format', 'NETCDF4'), ('persist', False)), 'fffbd075-1a5d-4ac9-8644-054921505643']",
+      "\nDuring handling of the above exception, another exception occurred:\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 29\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m sensor \u001b[38;5;129;01min\u001b[39;00m sensors:          \u001b[38;5;66;03m# sensor is a list of 2 strings [sensor_str, instrument_str]\u001b[39;00m\n\u001b[1;32m     28\u001b[0m     f \u001b[38;5;241m=\u001b[39m AssembleDataFilename(relative_path, sitestring, sensor[\u001b[38;5;241m1\u001b[39m], monthstring, sensor[\u001b[38;5;241m0\u001b[39m])\n\u001b[0;32m---> 29\u001b[0m     d[sensor[\u001b[38;5;241m0\u001b[39m]] \u001b[38;5;241m=\u001b[39m GetSensorTuple(sensor[\u001b[38;5;241m0\u001b[39m], f)\n",
+      "Cell \u001b[0;32mIn[7], line 19\u001b[0m, in \u001b[0;36mGetSensorTuple\u001b[0;34m(s, f)\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mGetSensorTuple\u001b[39m(s, f):\n\u001b[1;32m     15\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m'''\u001b[39;00m\n\u001b[1;32m     16\u001b[0m \u001b[38;5;124;03m    s is the sensor identifier string like 'temperature'\u001b[39;00m\n\u001b[1;32m     17\u001b[0m \u001b[38;5;124;03m    f is the source filename like './../data/osb_ctd_jan22_temperature.nc' \u001b[39;00m\n\u001b[1;32m     18\u001b[0m \u001b[38;5;124;03m    '''\u001b[39;00m\n\u001b[0;32m---> 19\u001b[0m     df_sensor    \u001b[38;5;241m=\u001b[39m xr\u001b[38;5;241m.\u001b[39mopen_dataset(f)[s]\n\u001b[1;32m     20\u001b[0m     df_z         \u001b[38;5;241m=\u001b[39m xr\u001b[38;5;241m.\u001b[39mopen_dataset(f)[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mz\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m     21\u001b[0m     range_lo     \u001b[38;5;241m=\u001b[39m ranges[s][\u001b[38;5;241m0\u001b[39m]\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/api.py:566\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    554\u001b[0m decoders \u001b[38;5;241m=\u001b[39m _resolve_decoders_kwargs(\n\u001b[1;32m    555\u001b[0m     decode_cf,\n\u001b[1;32m    556\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    562\u001b[0m     decode_coords\u001b[38;5;241m=\u001b[39mdecode_coords,\n\u001b[1;32m    563\u001b[0m )\n\u001b[1;32m    565\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--> 566\u001b[0m backend_ds \u001b[38;5;241m=\u001b[39m backend\u001b[38;5;241m.\u001b[39mopen_dataset(\n\u001b[1;32m    567\u001b[0m     filename_or_obj,\n\u001b[1;32m    568\u001b[0m     drop_variables\u001b[38;5;241m=\u001b[39mdrop_variables,\n\u001b[1;32m    569\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mdecoders,\n\u001b[1;32m    570\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m    571\u001b[0m )\n\u001b[1;32m    572\u001b[0m ds \u001b[38;5;241m=\u001b[39m _dataset_from_backend_dataset(\n\u001b[1;32m    573\u001b[0m     backend_ds,\n\u001b[1;32m    574\u001b[0m     filename_or_obj,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    584\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m    585\u001b[0m )\n\u001b[1;32m    586\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ds\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:590\u001b[0m, in \u001b[0;36mNetCDF4BackendEntrypoint.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, format, clobber, diskless, persist, lock, autoclose)\u001b[0m\n\u001b[1;32m    569\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    570\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    571\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    587\u001b[0m     autoclose\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    588\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Dataset:\n\u001b[1;32m    589\u001b[0m     filename_or_obj \u001b[38;5;241m=\u001b[39m _normalize_path(filename_or_obj)\n\u001b[0;32m--> 590\u001b[0m     store \u001b[38;5;241m=\u001b[39m NetCDF4DataStore\u001b[38;5;241m.\u001b[39mopen(\n\u001b[1;32m    591\u001b[0m         filename_or_obj,\n\u001b[1;32m    592\u001b[0m         mode\u001b[38;5;241m=\u001b[39mmode,\n\u001b[1;32m    593\u001b[0m         \u001b[38;5;28mformat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mformat\u001b[39m,\n\u001b[1;32m    594\u001b[0m         group\u001b[38;5;241m=\u001b[39mgroup,\n\u001b[1;32m    595\u001b[0m         clobber\u001b[38;5;241m=\u001b[39mclobber,\n\u001b[1;32m    596\u001b[0m         diskless\u001b[38;5;241m=\u001b[39mdiskless,\n\u001b[1;32m    597\u001b[0m         persist\u001b[38;5;241m=\u001b[39mpersist,\n\u001b[1;32m    598\u001b[0m         lock\u001b[38;5;241m=\u001b[39mlock,\n\u001b[1;32m    599\u001b[0m         autoclose\u001b[38;5;241m=\u001b[39mautoclose,\n\u001b[1;32m    600\u001b[0m     )\n\u001b[1;32m    602\u001b[0m     store_entrypoint \u001b[38;5;241m=\u001b[39m StoreBackendEntrypoint()\n\u001b[1;32m    603\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m close_on_error(store):\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:391\u001b[0m, in \u001b[0;36mNetCDF4DataStore.open\u001b[0;34m(cls, filename, mode, format, group, clobber, diskless, persist, lock, lock_maker, autoclose)\u001b[0m\n\u001b[1;32m    385\u001b[0m kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m(\n\u001b[1;32m    386\u001b[0m     clobber\u001b[38;5;241m=\u001b[39mclobber, diskless\u001b[38;5;241m=\u001b[39mdiskless, persist\u001b[38;5;241m=\u001b[39mpersist, \u001b[38;5;28mformat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mformat\u001b[39m\n\u001b[1;32m    387\u001b[0m )\n\u001b[1;32m    388\u001b[0m manager \u001b[38;5;241m=\u001b[39m CachingFileManager(\n\u001b[1;32m    389\u001b[0m     netCDF4\u001b[38;5;241m.\u001b[39mDataset, filename, mode\u001b[38;5;241m=\u001b[39mmode, kwargs\u001b[38;5;241m=\u001b[39mkwargs\n\u001b[1;32m    390\u001b[0m )\n\u001b[0;32m--> 391\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m(manager, group\u001b[38;5;241m=\u001b[39mgroup, mode\u001b[38;5;241m=\u001b[39mmode, lock\u001b[38;5;241m=\u001b[39mlock, autoclose\u001b[38;5;241m=\u001b[39mautoclose)\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:338\u001b[0m, in \u001b[0;36mNetCDF4DataStore.__init__\u001b[0;34m(self, manager, group, mode, lock, autoclose)\u001b[0m\n\u001b[1;32m    336\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_group \u001b[38;5;241m=\u001b[39m group\n\u001b[1;32m    337\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode \u001b[38;5;241m=\u001b[39m mode\n\u001b[0;32m--> 338\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mformat \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mds\u001b[38;5;241m.\u001b[39mdata_model\n\u001b[1;32m    339\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_filename \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mds\u001b[38;5;241m.\u001b[39mfilepath()\n\u001b[1;32m    340\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mis_remote \u001b[38;5;241m=\u001b[39m is_remote_uri(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_filename)\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:400\u001b[0m, in \u001b[0;36mNetCDF4DataStore.ds\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    398\u001b[0m \u001b[38;5;129m@property\u001b[39m\n\u001b[1;32m    399\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mds\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 400\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_acquire()\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/netCDF4_.py:394\u001b[0m, in \u001b[0;36mNetCDF4DataStore._acquire\u001b[0;34m(self, needs_lock)\u001b[0m\n\u001b[1;32m    393\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_acquire\u001b[39m(\u001b[38;5;28mself\u001b[39m, needs_lock\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[0;32m--> 394\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_manager\u001b[38;5;241m.\u001b[39macquire_context(needs_lock) \u001b[38;5;28;01mas\u001b[39;00m root:\n\u001b[1;32m    395\u001b[0m         ds \u001b[38;5;241m=\u001b[39m _nc4_require_group(root, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_group, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode)\n\u001b[1;32m    396\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m ds\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/contextlib.py:137\u001b[0m, in \u001b[0;36m_GeneratorContextManager.__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    135\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39margs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkwds, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc\n\u001b[1;32m    136\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 137\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgen)\n\u001b[1;32m    138\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[1;32m    139\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgenerator didn\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt yield\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/file_manager.py:199\u001b[0m, in \u001b[0;36mCachingFileManager.acquire_context\u001b[0;34m(self, needs_lock)\u001b[0m\n\u001b[1;32m    196\u001b[0m \u001b[38;5;129m@contextlib\u001b[39m\u001b[38;5;241m.\u001b[39mcontextmanager\n\u001b[1;32m    197\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21macquire_context\u001b[39m(\u001b[38;5;28mself\u001b[39m, needs_lock\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m    198\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Context manager for acquiring a file.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 199\u001b[0m     file, cached \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_acquire_with_cache_info(needs_lock)\n\u001b[1;32m    200\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    201\u001b[0m         \u001b[38;5;28;01myield\u001b[39;00m file\n",
+      "File \u001b[0;32m~/miniconda3/envs/argo-env2/lib/python3.11/site-packages/xarray/backends/file_manager.py:217\u001b[0m, in \u001b[0;36mCachingFileManager._acquire_with_cache_info\u001b[0;34m(self, needs_lock)\u001b[0m\n\u001b[1;32m    215\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[1;32m    216\u001b[0m     kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmode\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode\n\u001b[0;32m--> 217\u001b[0m file \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_opener(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_args, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    218\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_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[1;32m    219\u001b[0m     \u001b[38;5;66;03m# ensure file doesn't get overridden when opened again\u001b[39;00m\n\u001b[1;32m    220\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+      "File \u001b[0;32msrc/netCDF4/_netCDF4.pyx:2463\u001b[0m, in \u001b[0;36mnetCDF4._netCDF4.Dataset.__init__\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32msrc/netCDF4/_netCDF4.pyx:2026\u001b[0m, in \u001b[0;36mnetCDF4._netCDF4._ensure_nc_success\u001b[0;34m()\u001b[0m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: b'/home/rob/oceanography/book/chapters/rca/sensors/data/osb_ctd_jan22_conductivity.nc'"
+     ]
+    }
+   ],
+   "source": [
+    "# This cell assembles a data dictionary \"d\" from the old-style datasets (that live within the repo)\n",
+    "\n",
+    "d = {}\n",
+    "\n",
+    "relative_path = 'rca/sensors/data/'\n",
+    "sitestring = 'osb'                    # available: osb = Oregon Slope Base\n",
+    "monthstring = 'jan22'                 # available: apr21, jul21, jan22\n",
+    "\n",
+    "# error: apr21 and jul21 seem to fail on pCO2 despite data files present\n",
+    "\n",
+    "def AssembleDataFilename(relative_path, site, instrument, time, sensor): \n",
+    "    return relative_path + site + '_' + instrument + '_' + time + '_' + sensor + '.nc'\n",
+    "\n",
+    "def GetSensorTuple(s, f):\n",
+    "    '''\n",
+    "    s is the sensor identifier string like 'temperature'\n",
+    "    f is the source filename like './../data/osb_ctd_jan22_temperature.nc' \n",
+    "    '''\n",
+    "    df_sensor    = xr.open_dataset(f)[s]\n",
+    "    df_z         = xr.open_dataset(f)['z']\n",
+    "    range_lo     = ranges[s][0]\n",
+    "    range_hi     = ranges[s][1]\n",
+    "    sensor_color = colors[s]\n",
+    "    return (df_sensor, df_z, range_lo, range_hi, sensor_color)\n",
+    "\n",
+    "\n",
+    "for sensor in sensors:          # sensor is a list of 2 strings [sensor_str, instrument_str]\n",
+    "    f = AssembleDataFilename(relative_path, sitestring, sensor[1], monthstring, sensor[0])\n",
+    "    d[sensor[0]] = GetSensorTuple(sensor[0], f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# temperature and salinity\n",
+    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['salinity']], profile_list, \n",
+    "                          d['temperature'][0], d['temperature'][1], 'Temperature', colors['temperature'],    'ascent',\n",
+    "                          d['salinity'][0],       d['salinity'][1],    'Salinity',  colors['salinity'], 'ascent', 6, 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ChartSensor(profiles, [7., 11.], [0, 1, 2], ds.sea_water_temperature, -ds.sea_water_pressure, 'temperature', 'red', 'ascent', 8, 6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ChartSensor(profiles, [7., 11.], [0, 1, 2], ds.sea_water_temperature, -ds.sea_water_pressure, 'temperature', 'red', 'descent', 8, 6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# temperature: ascent versus descent\n",
+    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
+    "                          d['temperature'][0], d['temperature'][1], 'T-Ascent',   colors['temperature'],    'ascent',\n",
+    "                          d['temperature'][0], d['temperature'][1], 'T-Descent',  'green',                  'descent', 6, 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t0, t1 = '2022-01-01T00', '2022-12-31T23'\n",
+    "ds = siteData.sel(time=slice(t0, t1))\n",
+    "ds.time[0], ds.time[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def SPDataReduce(ds, t0, t1, keepers, rename):\n",
+    "    \"\"\"\n",
+    "    From a zarr Dataset for a shallow profiler stream ('ds') write a NetCDF file with just \n",
+    "    time/sensor-value/depth over a time period typically no longer than a month.\n",
+    "      - check that the dimension and coordinate is 'time'\n",
+    "      - drop or rename data vars\n",
+    "      - drop attributes\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    if not len(ds.dims) == 1: \n",
+    "        return False, \"Dataset dims count is not 1 (as assumed)\"\n",
+    "    if not list(dict(ds.dims))[0] == 'time': \n",
+    "        return False, \"Dataset dim is not 'time' (as assumed)\"\n",
+    "    if not len(ds.coords) == 1: \n",
+    "        return False, \"Dataset coords count is not 1 (as assumed)\"\n",
+    "    if not list(dict(ds.coords))[0] == 'time': \n",
+    "        return False, \"Dataset coord is not 'time' (as assumed)\"\n",
+    "    \n",
+    "    ds = ds.sel(time=slice(t0, t1))\n",
+    "    \n",
+    "    for s in ds.data_vars:\n",
+    "        if not s in keepers: ds = ds.drop(s)                              # drop extraneous data vars\n",
+    "    for s in ds.data_vars: ds = ds.rename({s:rename[keepers.index(s)]})   # rename the others\n",
+    "    a = [s for s in ds.attrs]\n",
+    "    for p in a: ds.attrs.pop(p)\n",
+    "    return ds, 'looks ok'\n",
+    "\n",
+    "t0, t1 = '2022-01-01T00', '2022-01-31T23'\n",
+    "\n",
+    "ds_reduced, reply = SPDataReduce(ds, t0, t1, ['sea_water_temperature', 'sea_water_pressure'], \n",
+    "                                 ['temperature', 'depth'], )\n",
+    "print(reply)\n",
+    "print(ds_reduced)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds_reduced.to_netcdf('osb_temp_jan_2022.nc') "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# temperature: ascent versus descent\n",
+    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
+    "                          ds_reduced.temperature, -ds_reduced.depth,\n",
+    "                          'T-Ascent',   colors['temperature'],    'ascent',\n",
+    "                          ds_reduced.temperature, -ds_reduced.depth,\n",
+    "                          'T-Descent',  'green',                  'descent', 6, 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# temperature: ascent versus descent\n",
+    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
+    "                          ds_reduced.temperature, -ds_reduced.depth,\n",
+    "                          'Zarr Data',   colors['temperature'],    'ascent',\n",
+    "                          d['temperature'][0], d['temperature'][1], 'OOI Data',   'blue',    'ascent', 6, 4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```\n",
+    "df   = ds.to_dataframe()\n",
+    "vals = [xr.DataArray(data=df[c], dims=['time'], coords={'time':df.index}, attrs=ds[c].attrs) for c in df.columns]\n",
+    "ds   = xr.Dataset(dict(zip(df.columns, vals)), attrs=ds.attrs)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds_read = xr.open_dataset('./data/osb_temp_jan_2022.nc')\n",
+    "\n",
+    "# temperature: ascent versus descent\n",
+    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
+    "                          ds_read.temperature, -ds_read.depth,\n",
+    "                          'Zarr Data',   colors['temperature'],    'ascent',\n",
+    "                          d['temperature'][0], d['temperature'][1], 'OOI Data',   'blue',    'ascent', 6, 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -606,7 +912,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/book/chapters/data.py b/book/chapters/data.py
index 21e69f0..1df307f 100644
--- a/book/chapters/data.py
+++ b/book/chapters/data.py
@@ -27,7 +27,7 @@ def ReformatDataFile(verbose=False):
     
     print('\n\nSpecify input NetCDF data file\n')
 
-    dataLoc         = os.getcwd() + '/../../../data/rca'                  # !!!!! adjusted relative path for
+    dataLoc         = os.getcwd() + '/data/rca'                  # !!!!! adjusted relative path for
     osb             = 'OregonSlopeBase'                                   #   repo relocated 'one layer down' (GeoSMART)
     oos             = 'OregonOffshore'
     axb             = 'AxialBase'
diff --git a/book/chapters/rca/sensors/data/argo_osb_200km_2010_2024_bgc_25profiles.csv b/book/chapters/data/argo/osb_200km_2010_2024_bgc_25profiles.csv
similarity index 100%
rename from book/chapters/rca/sensors/data/argo_osb_200km_2010_2024_bgc_25profiles.csv
rename to book/chapters/data/argo/osb_200km_2010_2024_bgc_25profiles.csv
diff --git a/book/chapters/rca/profiles/README.md b/book/chapters/data/rca/profiles/README.md
similarity index 100%
rename from book/chapters/rca/profiles/README.md
rename to book/chapters/data/rca/profiles/README.md
diff --git a/book/chapters/rca/profiles/axb/2015.csv b/book/chapters/data/rca/profiles/axb/2015.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2015.csv
rename to book/chapters/data/rca/profiles/axb/2015.csv
diff --git a/book/chapters/rca/profiles/axb/2016.csv b/book/chapters/data/rca/profiles/axb/2016.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2016.csv
rename to book/chapters/data/rca/profiles/axb/2016.csv
diff --git a/book/chapters/rca/profiles/axb/2017.csv b/book/chapters/data/rca/profiles/axb/2017.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2017.csv
rename to book/chapters/data/rca/profiles/axb/2017.csv
diff --git a/book/chapters/rca/profiles/axb/2018.csv b/book/chapters/data/rca/profiles/axb/2018.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2018.csv
rename to book/chapters/data/rca/profiles/axb/2018.csv
diff --git a/book/chapters/rca/profiles/axb/2019.csv b/book/chapters/data/rca/profiles/axb/2019.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2019.csv
rename to book/chapters/data/rca/profiles/axb/2019.csv
diff --git a/book/chapters/rca/profiles/axb/2020.csv b/book/chapters/data/rca/profiles/axb/2020.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2020.csv
rename to book/chapters/data/rca/profiles/axb/2020.csv
diff --git a/book/chapters/rca/profiles/axb/2021.csv b/book/chapters/data/rca/profiles/axb/2021.csv
similarity index 100%
rename from book/chapters/rca/profiles/axb/2021.csv
rename to book/chapters/data/rca/profiles/axb/2021.csv
diff --git a/book/chapters/rca/profiles/oos/2015.csv b/book/chapters/data/rca/profiles/oos/2015.csv
similarity index 100%
rename from book/chapters/rca/profiles/oos/2015.csv
rename to book/chapters/data/rca/profiles/oos/2015.csv
diff --git a/book/chapters/rca/profiles/oos/2016.csv b/book/chapters/data/rca/profiles/oos/2016.csv
similarity index 100%
rename from book/chapters/rca/profiles/oos/2016.csv
rename to book/chapters/data/rca/profiles/oos/2016.csv
diff --git a/book/chapters/rca/profiles/oos/2017.csv b/book/chapters/data/rca/profiles/oos/2017.csv
similarity index 100%
rename from book/chapters/rca/profiles/oos/2017.csv
rename to book/chapters/data/rca/profiles/oos/2017.csv
diff --git a/book/chapters/rca/profiles/oos/2018.csv b/book/chapters/data/rca/profiles/oos/2018.csv
similarity index 100%
rename from book/chapters/rca/profiles/oos/2018.csv
rename to book/chapters/data/rca/profiles/oos/2018.csv
diff --git a/book/chapters/rca/profiles/oos/2019.csv b/book/chapters/data/rca/profiles/oos/2019.csv
similarity index 100%
rename from book/chapters/rca/profiles/oos/2019.csv
rename to book/chapters/data/rca/profiles/oos/2019.csv
diff --git a/book/chapters/rca/profiles/oos/2020.csv b/book/chapters/data/rca/profiles/oos/2020.csv
similarity index 100%
rename from book/chapters/rca/profiles/oos/2020.csv
rename to book/chapters/data/rca/profiles/oos/2020.csv
diff --git a/book/chapters/rca/profiles/osb/2015.csv b/book/chapters/data/rca/profiles/osb/2015.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2015.csv
rename to book/chapters/data/rca/profiles/osb/2015.csv
diff --git a/book/chapters/rca/profiles/osb/2016.csv b/book/chapters/data/rca/profiles/osb/2016.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2016.csv
rename to book/chapters/data/rca/profiles/osb/2016.csv
diff --git a/book/chapters/rca/profiles/osb/2017.csv b/book/chapters/data/rca/profiles/osb/2017.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2017.csv
rename to book/chapters/data/rca/profiles/osb/2017.csv
diff --git a/book/chapters/rca/profiles/osb/2018.csv b/book/chapters/data/rca/profiles/osb/2018.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2018.csv
rename to book/chapters/data/rca/profiles/osb/2018.csv
diff --git a/book/chapters/rca/profiles/osb/2019.csv b/book/chapters/data/rca/profiles/osb/2019.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2019.csv
rename to book/chapters/data/rca/profiles/osb/2019.csv
diff --git a/book/chapters/rca/profiles/osb/2020.csv b/book/chapters/data/rca/profiles/osb/2020.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2020.csv
rename to book/chapters/data/rca/profiles/osb/2020.csv
diff --git a/book/chapters/rca/profiles/osb/2021.csv b/book/chapters/data/rca/profiles/osb/2021.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/2021.csv
rename to book/chapters/data/rca/profiles/osb/2021.csv
diff --git a/book/chapters/rca/profiles/osb/april2021.csv b/book/chapters/data/rca/profiles/osb/april2021.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/april2021.csv
rename to book/chapters/data/rca/profiles/osb/april2021.csv
diff --git a/book/chapters/rca/profiles/osb/january2022.csv b/book/chapters/data/rca/profiles/osb/january2022.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/january2022.csv
rename to book/chapters/data/rca/profiles/osb/january2022.csv
diff --git a/book/chapters/rca/profiles/osb/july2021.csv b/book/chapters/data/rca/profiles/osb/july2021.csv
similarity index 100%
rename from book/chapters/rca/profiles/osb/july2021.csv
rename to book/chapters/data/rca/profiles/osb/july2021.csv
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jan22_conductivity.nc b/book/chapters/data/rca/sensors/osb/ctd_jan22_conductivity.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_ctd_jan22_conductivity.nc
rename to book/chapters/data/rca/sensors/osb/ctd_jan22_conductivity.nc
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jan22_density.nc b/book/chapters/data/rca/sensors/osb/ctd_jan22_density.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_ctd_jan22_density.nc
rename to book/chapters/data/rca/sensors/osb/ctd_jan22_density.nc
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jan22_pressure.nc b/book/chapters/data/rca/sensors/osb/ctd_jan22_pressure.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_ctd_jan22_pressure.nc
rename to book/chapters/data/rca/sensors/osb/ctd_jan22_pressure.nc
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jan22_salinity.nc b/book/chapters/data/rca/sensors/osb/ctd_jan22_salinity.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_ctd_jan22_salinity.nc
rename to book/chapters/data/rca/sensors/osb/ctd_jan22_salinity.nc
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jan22_temperature.nc b/book/chapters/data/rca/sensors/osb/ctd_jan22_temperature.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_ctd_jan22_temperature.nc
rename to book/chapters/data/rca/sensors/osb/ctd_jan22_temperature.nc
diff --git a/book/chapters/rca/sensors/data/osb_do_jan22_do.nc b/book/chapters/data/rca/sensors/osb/do_jan22_do.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_do_jan22_do.nc
rename to book/chapters/data/rca/sensors/osb/do_jan22_do.nc
diff --git a/book/chapters/rca/sensors/data/osb_fluor_jan22_bb.nc b/book/chapters/data/rca/sensors/osb/fluor_jan22_bb.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_fluor_jan22_bb.nc
rename to book/chapters/data/rca/sensors/osb/fluor_jan22_bb.nc
diff --git a/book/chapters/rca/sensors/data/osb_fluor_jan22_chlora.nc b/book/chapters/data/rca/sensors/osb/fluor_jan22_chlora.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_fluor_jan22_chlora.nc
rename to book/chapters/data/rca/sensors/osb/fluor_jan22_chlora.nc
diff --git a/book/chapters/rca/sensors/data/osb_fluor_jan22_fdom.nc b/book/chapters/data/rca/sensors/osb/fluor_jan22_fdom.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_fluor_jan22_fdom.nc
rename to book/chapters/data/rca/sensors/osb/fluor_jan22_fdom.nc
diff --git a/book/chapters/rca/sensors/data/osb_nitrate_jan22_nitrate.nc b/book/chapters/data/rca/sensors/osb/nitrate_jan22_nitrate.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_nitrate_jan22_nitrate.nc
rename to book/chapters/data/rca/sensors/osb/nitrate_jan22_nitrate.nc
diff --git a/book/chapters/rca/sensors/data/osb_par_jan22_par.nc b/book/chapters/data/rca/sensors/osb/par_jan22_par.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_par_jan22_par.nc
rename to book/chapters/data/rca/sensors/osb/par_jan22_par.nc
diff --git a/book/chapters/rca/sensors/data/osb_pco2_jan22_pco2.nc b/book/chapters/data/rca/sensors/osb/pco2_jan22_pco2.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_pco2_jan22_pco2.nc
rename to book/chapters/data/rca/sensors/osb/pco2_jan22_pco2.nc
diff --git a/book/chapters/rca/sensors/data/osb_ph_jan22_ph.nc b/book/chapters/data/rca/sensors/osb/ph_jan22_ph.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_ph_jan22_ph.nc
rename to book/chapters/data/rca/sensors/osb/ph_jan22_ph.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir412nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir412nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir412nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir412nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir443nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir443nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir443nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir443nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir490nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir490nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir490nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir490nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir510nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir510nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir510nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir510nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir555nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir555nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir555nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir555nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir620nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir620nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir620nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir620nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir683nm.nc b/book/chapters/data/rca/sensors/osb/spkir_jan22_spkir683nm.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_spkir_jan22_spkir683nm.nc
rename to book/chapters/data/rca/sensors/osb/spkir_jan22_spkir683nm.nc
diff --git a/book/chapters/rca/sensors/data/osb_vel_jan22_east.nc b/book/chapters/data/rca/sensors/osb/vel_jan22_east.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_vel_jan22_east.nc
rename to book/chapters/data/rca/sensors/osb/vel_jan22_east.nc
diff --git a/book/chapters/rca/sensors/data/osb_vel_jan22_north.nc b/book/chapters/data/rca/sensors/osb/vel_jan22_north.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_vel_jan22_north.nc
rename to book/chapters/data/rca/sensors/osb/vel_jan22_north.nc
diff --git a/book/chapters/rca/sensors/data/osb_vel_jan22_up.nc b/book/chapters/data/rca/sensors/osb/vel_jan22_up.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/osb_vel_jan22_up.nc
rename to book/chapters/data/rca/sensors/osb/vel_jan22_up.nc
diff --git a/book/chapters/rca/sensors/data/roms_osb_july_2021.nc b/book/chapters/data/roms/roms_osb_july_2021.nc
similarity index 100%
rename from book/chapters/rca/sensors/data/roms_osb_july_2021.nc
rename to book/chapters/data/roms/roms_osb_july_2021.nc
diff --git a/book/chapters/data/osb_temp_jan_2022.nc b/book/chapters/data/tmp/osb_temp_jan_2022.nc
similarity index 100%
rename from book/chapters/data/osb_temp_jan_2022.nc
rename to book/chapters/data/tmp/osb_temp_jan_2022.nc
diff --git a/book/chapters/data2.ipynb b/book/chapters/data2.ipynb
index d22f927..09dd72c 100755
--- a/book/chapters/data2.ipynb
+++ b/book/chapters/data2.ipynb
@@ -1,275 +1,5 @@
 {
  "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "86fb05ee-94d1-4c2d-b29c-19d245bed590",
-   "metadata": {},
-   "source": [
-    "[Jupyter Book](https://geo-smart.github.io/oceanography/intro.html) and [GitHub repo](https://github.com/geo-smart/oceanography).\n",
-    "\n",
-    "\n",
-    "# Data 2\n",
-    "\n",
-    "\n",
-    "needs to merge with Data.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "fc03490e-6875-4e62-af5c-e5978d95dc4e",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "List Oregon Slope Base Profiler streams:\n",
-      "\n",
-      "ooi-data/RS01SBPS-SF01A-2A-CTDPFA102-streamed-ctdpf_sbe43_sample\n",
-      "ooi-data/RS01SBPS-SF01A-2D-PHSENA101-streamed-phsen_data_record\n",
-      "ooi-data/RS01SBPS-SF01A-3A-FLORTD101-streamed-flort_d_data_record\n",
-      "ooi-data/RS01SBPS-SF01A-3B-OPTAAD101-streamed-optaa_sample\n",
-      "ooi-data/RS01SBPS-SF01A-3C-PARADA101-streamed-parad_sa_sample\n",
-      "ooi-data/RS01SBPS-SF01A-3D-SPKIRA101-streamed-spkir_data_record\n",
-      "ooi-data/RS01SBPS-SF01A-4A-NUTNRA101-streamed-nutnr_a_dark_sample\n",
-      "ooi-data/RS01SBPS-SF01A-4A-NUTNRA101-streamed-nutnr_a_sample\n",
-      "ooi-data/RS01SBPS-SF01A-4B-VELPTD102-streamed-velpt_velocity_data\n",
-      "ooi-data/RS01SBPS-SF01A-4F-PCO2WA101-streamed-pco2w_a_sami_data_record\n",
-      "\n",
-      "Translation:\n",
-      "  CTDPF / ctdpf                 CTD\n",
-      "  PHSEN / phsen                 pH\n",
-      "  FLORT / flort                 Fluorometer { FDOM, Chlor-A, Backscatter }\n",
-      "  OPTAA / optaa                 Spectrophotometer\n",
-      "  PARAD / parad                 PAR\n",
-      "  SPKIR / spkir                 Spectral Irradiance\n",
-      "  NUTNR / nutnr_a_dark_sample   Nitrate: Dark sample (explain please)\n",
-      "  NUTNR / nutnr_a_sample        Nitrate: ...\n",
-      "  VELPT / velpt                 Velocity (current) ambiguous: on SCIP or affixed to platform?\n",
-      "  PCO2W / pco2w                 pCO2\n",
-      "\n",
-      "\n",
-      "Full stream name: ooi-data/CE04OSPS-SF01B-2A-CTDPFA107-streamed-ctdpf_sbe43_sample\n",
-      "\n",
-      "Field breakout: CE 04 OS PS SF 01 B 2A CTDPF A 107 ctdpf_sbe43_sample\n",
-      "\n",
-      "The first field has CE for Coastal Endurance or RS for Regional Cabled Array.\n",
-      "Fields 5, 6 and 7 give us shallow profiler site and choice of profiler or platform.\n",
-      "\n",
-      "    PC 01 B --> Oregon Offshore 200m Platform\n",
-      "    SF 01 B --> Oregon Offshore Profiler\n",
-      "    PC 01 A --> Oregon Slope Base Profiler\n",
-      "    SF 01 A --> Oregon Slope Base Profiler\n",
-      "    PC 03 A --> Axial Base 200m Platform\n",
-      "    SF 03 A --> Axial Base Profiler\n",
-      "\n",
-      "Non-shallow-profiler examples:\n",
-      "  DP O3 A is the Axial Base Deep Profiler\n",
-      "  LJ 01 A is the Oregon Slope Base Seafloor\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# this cell connects to the RCA Zarr filesystem on the cloud and lists available data streams\n",
-    "\n",
-    "import netCDF4\n",
-    "import xarray as xr\n",
-    "import s3fs\n",
-    "\n",
-    "fs = s3fs.S3FileSystem(anon=True)\n",
-    "\n",
-    "streamlist = fs.listdir('ooi-data', detail = False)\n",
-    "\n",
-    "def InstrumentBreakout(s):\n",
-    "    print('Field breakout:', s[9:11], s[11:13], s[13:15], s[15:17], s[18:20], s[20:22], s[22:23], s[24:26], \\\n",
-    "          s[27:32], s[32:33], s[33:36], s[46:])\n",
-    "\n",
-    "print('List Oregon Slope Base Profiler streams:\\n')\n",
-    "for s in streamlist:\n",
-    "    if 'SF01A' in s: print(s)\n",
-    "print()\n",
-    "print('Translation:')\n",
-    "print('  CTDPF / ctdpf                 CTD')\n",
-    "print('  PHSEN / phsen                 pH')\n",
-    "print('  FLORT / flort                 Fluorometer { FDOM, Chlor-A, Backscatter }')\n",
-    "print('  OPTAA / optaa                 Spectrophotometer') \n",
-    "print('  PARAD / parad                 PAR')\n",
-    "print('  SPKIR / spkir                 Spectral Irradiance')\n",
-    "print('  NUTNR / nutnr_a_dark_sample   Nitrate: Dark sample (explain please)')\n",
-    "print('  NUTNR / nutnr_a_sample        Nitrate: ...')\n",
-    "print('  VELPT / velpt                 Velocity (current) ambiguous: on SCIP or affixed to platform?')\n",
-    "print('  PCO2W / pco2w                 pCO2')\n",
-    "print()\n",
-    "\n",
-    "stream_choice = 15       # the 15th element in the file list corresponds to the Shallow Profiler, Oregon Slope Base site\n",
-    "\n",
-    "print()\n",
-    "print('Full stream name:', streamlist[stream_choice])\n",
-    "print()\n",
-    "InstrumentBreakout(streamlist[stream_choice])\n",
-    "print()\n",
-    "print('The first field has CE for Coastal Endurance or RS for Regional Cabled Array.')\n",
-    "print('Fields 5, 6 and 7 give us shallow profiler site and choice of profiler or platform.')\n",
-    "print()\n",
-    "indenter = 4\n",
-    "print(' '*indenter + 'PC 01 B --> Oregon Offshore 200m Platform')\n",
-    "print(' '*indenter + 'SF 01 B --> Oregon Offshore Profiler')\n",
-    "print(' '*indenter + 'PC 01 A --> Oregon Slope Base Profiler')\n",
-    "print(' '*indenter + 'SF 01 A --> Oregon Slope Base Profiler')\n",
-    "print(' '*indenter + 'PC 03 A --> Axial Base 200m Platform')\n",
-    "print(' '*indenter + 'SF 03 A --> Axial Base Profiler')\n",
-    "print()\n",
-    "print('Non-shallow-profiler examples:')\n",
-    "print('  DP O3 A is the Axial Base Deep Profiler')\n",
-    "print('  LJ 01 A is the Oregon Slope Base Seafloor')\n",
-    "print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "e2f40d77-b640-4f7b-9d7b-48ea8c977ad1",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OSB CTD stream: ooi-data/RS01SBPS-SF01A-2A-CTDPFA102-streamed-ctdpf_sbe43_sample\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "osb_profiler_streams = [sname for sname in streamlist if 'SF01A' in sname]\n",
-    "for s in osb_profiler_streams: \n",
-    "    if 'ctdpf' in s: osb_sp_ctd = s\n",
-    "\n",
-    "print('OSB CTD stream:', osb_sp_ctd)\n",
-    "print()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "a56bc2c6-e16d-49ee-b3cc-8166935f0c42",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "ename": "ValueError",
-     "evalue": "unrecognized engine zarr must be one of: ['netcdf4', 'scipy', 'store']",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[3], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m     ds \u001b[38;5;241m=\u001b[39m xr\u001b[38;5;241m.\u001b[39mopen_zarr(zarr_store, consolidated\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m      5\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m ds\n\u001b[0;32m----> 7\u001b[0m siteData \u001b[38;5;241m=\u001b[39m loadData(osb_sp_ctd)\n\u001b[1;32m      8\u001b[0m \u001b[38;5;66;03m# siteData\u001b[39;00m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msite data is now lazy-loaded\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
-      "Cell \u001b[0;32mIn[3], line 4\u001b[0m, in \u001b[0;36mloadData\u001b[0;34m(stream_name)\u001b[0m\n\u001b[1;32m      2\u001b[0m fs \u001b[38;5;241m=\u001b[39m s3fs\u001b[38;5;241m.\u001b[39mS3FileSystem(anon\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m      3\u001b[0m zarr_store \u001b[38;5;241m=\u001b[39m fs\u001b[38;5;241m.\u001b[39mget_mapper(stream_name)\n\u001b[0;32m----> 4\u001b[0m ds \u001b[38;5;241m=\u001b[39m xr\u001b[38;5;241m.\u001b[39mopen_zarr(zarr_store, consolidated\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ds\n",
-      "File \u001b[0;32m~/miniconda3/envs/oceanography/lib/python3.12/site-packages/xarray/backends/zarr.py:867\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    853\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m    854\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    855\u001b[0m     )\n\u001b[1;32m    857\u001b[0m backend_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m    858\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    859\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    864\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    865\u001b[0m }\n\u001b[0;32m--> 867\u001b[0m ds \u001b[38;5;241m=\u001b[39m open_dataset(\n\u001b[1;32m    868\u001b[0m     filename_or_obj\u001b[38;5;241m=\u001b[39mstore,\n\u001b[1;32m    869\u001b[0m     group\u001b[38;5;241m=\u001b[39mgroup,\n\u001b[1;32m    870\u001b[0m     decode_cf\u001b[38;5;241m=\u001b[39mdecode_cf,\n\u001b[1;32m    871\u001b[0m     mask_and_scale\u001b[38;5;241m=\u001b[39mmask_and_scale,\n\u001b[1;32m    872\u001b[0m     decode_times\u001b[38;5;241m=\u001b[39mdecode_times,\n\u001b[1;32m    873\u001b[0m     concat_characters\u001b[38;5;241m=\u001b[39mconcat_characters,\n\u001b[1;32m    874\u001b[0m     decode_coords\u001b[38;5;241m=\u001b[39mdecode_coords,\n\u001b[1;32m    875\u001b[0m     engine\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mzarr\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    876\u001b[0m     chunks\u001b[38;5;241m=\u001b[39mchunks,\n\u001b[1;32m    877\u001b[0m     drop_variables\u001b[38;5;241m=\u001b[39mdrop_variables,\n\u001b[1;32m    878\u001b[0m     chunked_array_type\u001b[38;5;241m=\u001b[39mchunked_array_type,\n\u001b[1;32m    879\u001b[0m     from_array_kwargs\u001b[38;5;241m=\u001b[39mfrom_array_kwargs,\n\u001b[1;32m    880\u001b[0m     backend_kwargs\u001b[38;5;241m=\u001b[39mbackend_kwargs,\n\u001b[1;32m    881\u001b[0m     decode_timedelta\u001b[38;5;241m=\u001b[39mdecode_timedelta,\n\u001b[1;32m    882\u001b[0m     use_cftime\u001b[38;5;241m=\u001b[39muse_cftime,\n\u001b[1;32m    883\u001b[0m     zarr_version\u001b[38;5;241m=\u001b[39mzarr_version,\n\u001b[1;32m    884\u001b[0m )\n\u001b[1;32m    885\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ds\n",
-      "File \u001b[0;32m~/miniconda3/envs/oceanography/lib/python3.12/site-packages/xarray/backends/api.py:552\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    549\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m from_array_kwargs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    550\u001b[0m     from_array_kwargs \u001b[38;5;241m=\u001b[39m {}\n\u001b[0;32m--> 552\u001b[0m backend \u001b[38;5;241m=\u001b[39m plugins\u001b[38;5;241m.\u001b[39mget_backend(engine)\n\u001b[1;32m    554\u001b[0m decoders \u001b[38;5;241m=\u001b[39m _resolve_decoders_kwargs(\n\u001b[1;32m    555\u001b[0m     decode_cf,\n\u001b[1;32m    556\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    562\u001b[0m     decode_coords\u001b[38;5;241m=\u001b[39mdecode_coords,\n\u001b[1;32m    563\u001b[0m )\n\u001b[1;32m    565\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",
-      "File \u001b[0;32m~/miniconda3/envs/oceanography/lib/python3.12/site-packages/xarray/backends/plugins.py:205\u001b[0m, in \u001b[0;36mget_backend\u001b[0;34m(engine)\u001b[0m\n\u001b[1;32m    203\u001b[0m     engines \u001b[38;5;241m=\u001b[39m list_engines()\n\u001b[1;32m    204\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m engine \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m engines:\n\u001b[0;32m--> 205\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    206\u001b[0m             \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124munrecognized engine \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mengine\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must be one of: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlist\u001b[39m(engines)\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    207\u001b[0m         )\n\u001b[1;32m    208\u001b[0m     backend \u001b[38;5;241m=\u001b[39m engines[engine]\n\u001b[1;32m    209\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(engine, \u001b[38;5;28mtype\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(engine, BackendEntrypoint):\n",
-      "\u001b[0;31mValueError\u001b[0m: unrecognized engine zarr must be one of: ['netcdf4', 'scipy', 'store']"
-     ]
-    }
-   ],
-   "source": [
-    "def loadData(stream_name):\n",
-    "    fs = s3fs.S3FileSystem(anon=True)\n",
-    "    zarr_store = fs.get_mapper(stream_name)\n",
-    "    ds = xr.open_zarr(zarr_store, consolidated=True)\n",
-    "    return ds\n",
-    "\n",
-    "siteData = loadData(osb_sp_ctd)\n",
-    "# siteData\n",
-    "print('site data is now lazy-loaded')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6d82a0a7-c1a0-48dc-ae14-f32a41356e99",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "siteData.time[-1]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "54497e55-6c75-468b-b96f-d87641df4d4f",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Jupyter Notebook running Python 3\n"
-     ]
-    }
-   ],
-   "source": [
-    "from shallowprofiler import *\n",
-    "from charts import *\n",
-    "\n",
-    "profiles = ReadProfileMetadata()    # this is an error: Hardcoded for Jan 2022\n",
-    "how_many_charts = 3\n",
-    "profile_list = [n for n in range(how_many_charts)]   # quick check: use d['temperature'].z.plot()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "72fef540-903a-4b8a-ad7d-8536a422dcbe",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# This cell assembles a data dictionary \"d\" from the old-style datasets (that live within the repo)\n",
-    "\n",
-    "d = {}\n",
-    "\n",
-    "relative_path = 'rca/sensors/data/'\n",
-    "sitestring = 'osb'                    # available: osb = Oregon Slope Base\n",
-    "monthstring = 'jan22'                 # available: apr21, jul21, jan22\n",
-    "\n",
-    "# error: apr21 and jul21 seem to fail on pCO2 despite data files present\n",
-    "\n",
-    "def AssembleDataFilename(relative_path, site, instrument, time, sensor): \n",
-    "    return relative_path + site + '_' + instrument + '_' + time + '_' + sensor + '.nc'\n",
-    "\n",
-    "def GetSensorTuple(s, f):\n",
-    "    '''\n",
-    "    s is the sensor identifier string like 'temperature'\n",
-    "    f is the source filename like './../data/osb_ctd_jan22_temperature.nc' \n",
-    "    '''\n",
-    "    df_sensor    = xr.open_dataset(f)[s]\n",
-    "    df_z         = xr.open_dataset(f)['z']\n",
-    "    range_lo     = ranges[s][0]\n",
-    "    range_hi     = ranges[s][1]\n",
-    "    sensor_color = colors[s]\n",
-    "    return (df_sensor, df_z, range_lo, range_hi, sensor_color)\n",
-    "\n",
-    "\n",
-    "for sensor in sensors:          # sensor is a list of 2 strings [sensor_str, instrument_str]\n",
-    "    f = AssembleDataFilename(relative_path, sitestring, sensor[1], monthstring, sensor[0])\n",
-    "    d[sensor[0]] = GetSensorTuple(sensor[0], f)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -297,12 +27,7 @@
      "output_type": "display_data"
     }
    ],
-   "source": [
-    "# temperature and salinity\n",
-    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['salinity']], profile_list, \n",
-    "                          d['temperature'][0], d['temperature'][1], 'Temperature', colors['temperature'],    'ascent',\n",
-    "                          d['salinity'][0],       d['salinity'][1],    'Salinity',  colors['salinity'], 'ascent', 6, 4)"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -312,9 +37,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "ChartSensor(profiles, [7., 11.], [0, 1, 2], ds.sea_water_temperature, -ds.sea_water_pressure, 'temperature', 'red', 'ascent', 8, 6)"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -324,9 +47,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "ChartSensor(profiles, [7., 11.], [0, 1, 2], ds.sea_water_temperature, -ds.sea_water_pressure, 'temperature', 'red', 'descent', 8, 6)"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -336,12 +57,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "# temperature: ascent versus descent\n",
-    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
-    "                          d['temperature'][0], d['temperature'][1], 'T-Ascent',   colors['temperature'],    'ascent',\n",
-    "                          d['temperature'][0], d['temperature'][1], 'T-Descent',  'green',                  'descent', 6, 4)"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -361,11 +77,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "t0, t1 = '2022-01-01T00', '2022-12-31T23'\n",
-    "ds = siteData.sel(time=slice(t0, t1))\n",
-    "ds.time[0], ds.time[-1]"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -375,41 +87,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "def SPDataReduce(ds, t0, t1, keepers, rename):\n",
-    "    \"\"\"\n",
-    "    From a zarr Dataset for a shallow profiler stream ('ds') write a NetCDF file with just \n",
-    "    time/sensor-value/depth over a time period typically no longer than a month.\n",
-    "      - check that the dimension and coordinate is 'time'\n",
-    "      - drop or rename data vars\n",
-    "      - drop attributes\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    if not len(ds.dims) == 1: \n",
-    "        return False, \"Dataset dims count is not 1 (as assumed)\"\n",
-    "    if not list(dict(ds.dims))[0] == 'time': \n",
-    "        return False, \"Dataset dim is not 'time' (as assumed)\"\n",
-    "    if not len(ds.coords) == 1: \n",
-    "        return False, \"Dataset coords count is not 1 (as assumed)\"\n",
-    "    if not list(dict(ds.coords))[0] == 'time': \n",
-    "        return False, \"Dataset coord is not 'time' (as assumed)\"\n",
-    "    \n",
-    "    ds = ds.sel(time=slice(t0, t1))\n",
-    "    \n",
-    "    for s in ds.data_vars:\n",
-    "        if not s in keepers: ds = ds.drop(s)                              # drop extraneous data vars\n",
-    "    for s in ds.data_vars: ds = ds.rename({s:rename[keepers.index(s)]})   # rename the others\n",
-    "    a = [s for s in ds.attrs]\n",
-    "    for p in a: ds.attrs.pop(p)\n",
-    "    return ds, 'looks ok'\n",
-    "\n",
-    "t0, t1 = '2022-01-01T00', '2022-01-31T23'\n",
-    "\n",
-    "ds_reduced, reply = SPDataReduce(ds, t0, t1, ['sea_water_temperature', 'sea_water_pressure'], \n",
-    "                                 ['temperature', 'depth'], )\n",
-    "print(reply)\n",
-    "print(ds_reduced)"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -419,9 +97,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "ds_reduced.to_netcdf('osb_temp_jan_2022.nc') "
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -431,14 +107,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "# temperature: ascent versus descent\n",
-    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
-    "                          ds_reduced.temperature, -ds_reduced.depth,\n",
-    "                          'T-Ascent',   colors['temperature'],    'ascent',\n",
-    "                          ds_reduced.temperature, -ds_reduced.depth,\n",
-    "                          'T-Descent',  'green',                  'descent', 6, 4)"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -448,25 +117,13 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "# temperature: ascent versus descent\n",
-    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
-    "                          ds_reduced.temperature, -ds_reduced.depth,\n",
-    "                          'Zarr Data',   colors['temperature'],    'ascent',\n",
-    "                          d['temperature'][0], d['temperature'][1], 'OOI Data',   'blue',    'ascent', 6, 4)"
-   ]
+   "source": []
   },
   {
    "cell_type": "markdown",
    "id": "020ecac7-d91e-4d1c-b601-3e87d8f8cfea",
    "metadata": {},
-   "source": [
-    "```\n",
-    "df   = ds.to_dataframe()\n",
-    "    vals = [xr.DataArray(data=df[c], dims=['time'], coords={'time':df.index}, attrs=ds[c].attrs) for c in df.columns]\n",
-    "    ds   = xr.Dataset(dict(zip(df.columns, vals)), attrs=ds.attrs)\n",
-    "    ```"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -476,16 +133,7 @@
     "tags": []
    },
    "outputs": [],
-   "source": [
-    "ds_read = xr.open_dataset('./data/osb_temp_jan_2022.nc')\n",
-    "\n",
-    "\n",
-    "# temperature: ascent versus descent\n",
-    "fig,axs = ChartTwoSensors(profiles, [ranges['temperature'], ranges['temperature']], [0, 1, 2], \n",
-    "                          ds_read.temperature, -ds_read.depth,\n",
-    "                          'Zarr Data',   colors['temperature'],    'ascent',\n",
-    "                          d['temperature'][0], d['temperature'][1], 'OOI Data',   'blue',    'ascent', 6, 4)"
-   ]
+   "source": []
   }
  ],
  "metadata": {
@@ -504,7 +152,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/book/chapters/documentation.ipynb b/book/chapters/documentation.ipynb
index aec27aa..b72a74e 100644
--- a/book/chapters/documentation.ipynb
+++ b/book/chapters/documentation.ipynb
@@ -2141,7 +2141,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "89a502fd",
+   "id": "dd2390ef-90f8-48b4-bc5e-ddf148a54bca",
    "metadata": {},
    "source": [
     "## Part 2 Sensors and Instruments\n",
@@ -2845,6 +2845,58 @@
     "NetCDF-CF. There is one file for every instrument, stream, and deployment.  For more refer to this\n",
     "[Data Download](https://dataexplorer.oceanobservatories.org/help/overview.html#download-data-map-overview) link.\n",
     "\n",
+    "\n",
+    "\n",
+    "#### Deprecated Content on Data Downloads \n",
+    "\n",
+    "\n",
+    "...from the OOI Data Explorer...\n",
+    "\n",
+    "\n",
+    "- [Data access page in the Data Explorer](https://dataexplorer.oceanobservatories.org/#go-to-data-access)\n",
+    "- Access Array Data, Oregon Margin, Profiling Assets, All Instrument Types, All Parameters, Go\n",
+    "    - A very dense page with charts, tabs, multiple scroll bars and so forth\n",
+    "    - Exploration of the various tabs encouraged\n",
+    "        - **Data**, **Inventory**, **Downloads**, **Annotations**, **Deployments**\n",
+    "    - > **Downloads** tab\n",
+    "    - Full resolution data: 1 second per sample\n",
+    "        - Choose link '*full resolution downloads*'\n",
+    "        - Page of fluorometer datasets in deployment sequence: time ranges shown\n",
+    "        - Select Downloads > THREDDS Catalog > Dataset > page listing files\n",
+    "        - Deployment 8, FLORT for the triplet\n",
+    "        - Check the time range in the filename for best match to March 2021\n",
+    "        - Click to go to yet another page, this one for \"ACCESS\" and multiple choices\n",
+    "            - Select HTTPServer to download the NetCDF data file: 600+ MB\n",
+    "    - 1Min resolution: 1 minute per sample\n",
+    "        - Green **Download** button for various streams / sensors \n",
+    "        - Three format options: ERDDAP (+ 3 sub-options), CSV and NetCDF\n",
+    "            - NetCDF URL gives a shareable download link\n",
+    "            - NetCDF **Download** button > 1Min downsampled data\n",
+    "                - These datasets extend over the full OOI program duration: 2014 to present\n",
+    "            - Data description text + chart symbol (left) produces a curtain plot\n",
+    "\n",
+    "\n",
+    "Full resolution data is sub-divided into consecutive time ranges called \"deployments\". \n",
+    "The resulting NetCDF files have these distinctions compared to the 1Min data:\n",
+    "\n",
+    "\n",
+    "- Data is sampled at about one sample per second\n",
+    "- Sensors are combined in NetCDF files\n",
+    "    - For example a CTD file includes salinity, temperature, pressure, density and conductivity\n",
+    "- The data files are much larger on average\n",
+    "- The sample dimension is `obs` (observation number) rather than `row`\n",
+    "    - However the swap procedure is the same: Swap in `time`\n",
+    "    \n",
+    "```\n",
+    "operating on '../../../data/rca/OregonSlopeBase/profiler/ctd/ooi-rs01sbps-sf01a-2a-ctdpfa102_6974_57e0_dbda.nc' and so on\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9df8746-0ece-4ecf-885d-31217c0aa2d9",
+   "metadata": {},
+   "source": [
     "#### [Contents](#Contents)\n",
     "\n",
     "\n",
@@ -3868,7 +3920,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/book/chapters/rca/sensors/data/osb_ctd_apr21_conductivity.nc b/book/chapters/rca/sensors/data/osb_ctd_apr21_conductivity.nc
deleted file mode 100644
index 5f43406..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_apr21_conductivity.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_apr21_density.nc b/book/chapters/rca/sensors/data/osb_ctd_apr21_density.nc
deleted file mode 100644
index 83d12a3..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_apr21_density.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_apr21_pressure.nc b/book/chapters/rca/sensors/data/osb_ctd_apr21_pressure.nc
deleted file mode 100644
index 4ab332a..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_apr21_pressure.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_apr21_salinity.nc b/book/chapters/rca/sensors/data/osb_ctd_apr21_salinity.nc
deleted file mode 100644
index 89c8158..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_apr21_salinity.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_apr21_temperature.nc b/book/chapters/rca/sensors/data/osb_ctd_apr21_temperature.nc
deleted file mode 100644
index 6181c3e..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_apr21_temperature.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jul21_conductivity.nc b/book/chapters/rca/sensors/data/osb_ctd_jul21_conductivity.nc
deleted file mode 100644
index 6b32a42..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_jul21_conductivity.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jul21_density.nc b/book/chapters/rca/sensors/data/osb_ctd_jul21_density.nc
deleted file mode 100644
index f2bd094..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_jul21_density.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jul21_pressure.nc b/book/chapters/rca/sensors/data/osb_ctd_jul21_pressure.nc
deleted file mode 100644
index 303bdef..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_jul21_pressure.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jul21_salinity.nc b/book/chapters/rca/sensors/data/osb_ctd_jul21_salinity.nc
deleted file mode 100644
index 9ceea94..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_jul21_salinity.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ctd_jul21_temperature.nc b/book/chapters/rca/sensors/data/osb_ctd_jul21_temperature.nc
deleted file mode 100644
index 6b8f8f9..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ctd_jul21_temperature.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_do_apr21_do.nc b/book/chapters/rca/sensors/data/osb_do_apr21_do.nc
deleted file mode 100644
index 4e9b425..0000000
Binary files a/book/chapters/rca/sensors/data/osb_do_apr21_do.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_do_jul21_do.nc b/book/chapters/rca/sensors/data/osb_do_jul21_do.nc
deleted file mode 100644
index c46226f..0000000
Binary files a/book/chapters/rca/sensors/data/osb_do_jul21_do.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_fluor_apr21_bb.nc b/book/chapters/rca/sensors/data/osb_fluor_apr21_bb.nc
deleted file mode 100644
index 06532ad..0000000
Binary files a/book/chapters/rca/sensors/data/osb_fluor_apr21_bb.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_fluor_apr21_chlora.nc b/book/chapters/rca/sensors/data/osb_fluor_apr21_chlora.nc
deleted file mode 100644
index da28593..0000000
Binary files a/book/chapters/rca/sensors/data/osb_fluor_apr21_chlora.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_fluor_apr21_fdom.nc b/book/chapters/rca/sensors/data/osb_fluor_apr21_fdom.nc
deleted file mode 100644
index 70c28ed..0000000
Binary files a/book/chapters/rca/sensors/data/osb_fluor_apr21_fdom.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_fluor_jul21_bb.nc b/book/chapters/rca/sensors/data/osb_fluor_jul21_bb.nc
deleted file mode 100644
index e5e5d5e..0000000
Binary files a/book/chapters/rca/sensors/data/osb_fluor_jul21_bb.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_fluor_jul21_chlora.nc b/book/chapters/rca/sensors/data/osb_fluor_jul21_chlora.nc
deleted file mode 100644
index c80f970..0000000
Binary files a/book/chapters/rca/sensors/data/osb_fluor_jul21_chlora.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_fluor_jul21_fdom.nc b/book/chapters/rca/sensors/data/osb_fluor_jul21_fdom.nc
deleted file mode 100644
index 2be5863..0000000
Binary files a/book/chapters/rca/sensors/data/osb_fluor_jul21_fdom.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_nitrate_apr21_nitrate.nc b/book/chapters/rca/sensors/data/osb_nitrate_apr21_nitrate.nc
deleted file mode 100644
index c5be79b..0000000
Binary files a/book/chapters/rca/sensors/data/osb_nitrate_apr21_nitrate.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_nitrate_jul21_nitrate.nc b/book/chapters/rca/sensors/data/osb_nitrate_jul21_nitrate.nc
deleted file mode 100644
index 6f24ccc..0000000
Binary files a/book/chapters/rca/sensors/data/osb_nitrate_jul21_nitrate.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_par_apr21_par.nc b/book/chapters/rca/sensors/data/osb_par_apr21_par.nc
deleted file mode 100644
index cef0a0a..0000000
Binary files a/book/chapters/rca/sensors/data/osb_par_apr21_par.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_par_jul21_par.nc b/book/chapters/rca/sensors/data/osb_par_jul21_par.nc
deleted file mode 100644
index a44623c..0000000
Binary files a/book/chapters/rca/sensors/data/osb_par_jul21_par.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_pco2_apr21_pco2.nc b/book/chapters/rca/sensors/data/osb_pco2_apr21_pco2.nc
deleted file mode 100644
index 27361c6..0000000
Binary files a/book/chapters/rca/sensors/data/osb_pco2_apr21_pco2.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_pco2_jul21_pco2.nc b/book/chapters/rca/sensors/data/osb_pco2_jul21_pco2.nc
deleted file mode 100644
index 27361c6..0000000
Binary files a/book/chapters/rca/sensors/data/osb_pco2_jul21_pco2.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ph_apr21_ph.nc b/book/chapters/rca/sensors/data/osb_ph_apr21_ph.nc
deleted file mode 100644
index 3171dfe..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ph_apr21_ph.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_ph_jul21_ph.nc b/book/chapters/rca/sensors/data/osb_ph_jul21_ph.nc
deleted file mode 100644
index cc0c958..0000000
Binary files a/book/chapters/rca/sensors/data/osb_ph_jul21_ph.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir.nc
deleted file mode 100644
index a71caeb..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir412nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir412nm.nc
deleted file mode 100644
index 3028813..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir412nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir443nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir443nm.nc
deleted file mode 100644
index b98a19e..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir443nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir490nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir490nm.nc
deleted file mode 100644
index c1682d7..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir490nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir510nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir510nm.nc
deleted file mode 100644
index 46d8d29..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir510nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir555nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir555nm.nc
deleted file mode 100644
index 15b9e7f..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir555nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir620nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir620nm.nc
deleted file mode 100644
index 66b21b6..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir620nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir683nm.nc b/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir683nm.nc
deleted file mode 100644
index 65eb9df..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_apr21_spkir683nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir.nc b/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir.nc
deleted file mode 100644
index 13b94e4..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jan22_spkir.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir.nc
deleted file mode 100644
index e9c8ac9..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir412nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir412nm.nc
deleted file mode 100644
index 9be7e52..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir412nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir443nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir443nm.nc
deleted file mode 100644
index 0c698a1..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir443nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir490nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir490nm.nc
deleted file mode 100644
index 74634ae..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir490nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir510nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir510nm.nc
deleted file mode 100644
index 6ca8810..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir510nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir555nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir555nm.nc
deleted file mode 100644
index 1f2c602..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir555nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir620nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir620nm.nc
deleted file mode 100644
index 103dfd7..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir620nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir683nm.nc b/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir683nm.nc
deleted file mode 100644
index 1656095..0000000
Binary files a/book/chapters/rca/sensors/data/osb_spkir_jul21_spkir683nm.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_vel_apr21_east.nc b/book/chapters/rca/sensors/data/osb_vel_apr21_east.nc
deleted file mode 100644
index 0d4c30b..0000000
Binary files a/book/chapters/rca/sensors/data/osb_vel_apr21_east.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_vel_apr21_north.nc b/book/chapters/rca/sensors/data/osb_vel_apr21_north.nc
deleted file mode 100644
index 19672b4..0000000
Binary files a/book/chapters/rca/sensors/data/osb_vel_apr21_north.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_vel_apr21_up.nc b/book/chapters/rca/sensors/data/osb_vel_apr21_up.nc
deleted file mode 100644
index f251740..0000000
Binary files a/book/chapters/rca/sensors/data/osb_vel_apr21_up.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_vel_jul21_east.nc b/book/chapters/rca/sensors/data/osb_vel_jul21_east.nc
deleted file mode 100644
index 79e0eb0..0000000
Binary files a/book/chapters/rca/sensors/data/osb_vel_jul21_east.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_vel_jul21_north.nc b/book/chapters/rca/sensors/data/osb_vel_jul21_north.nc
deleted file mode 100644
index 6ff84d7..0000000
Binary files a/book/chapters/rca/sensors/data/osb_vel_jul21_north.nc and /dev/null differ
diff --git a/book/chapters/rca/sensors/data/osb_vel_jul21_up.nc b/book/chapters/rca/sensors/data/osb_vel_jul21_up.nc
deleted file mode 100644
index 7f81880..0000000
Binary files a/book/chapters/rca/sensors/data/osb_vel_jul21_up.nc and /dev/null differ
diff --git a/book/chapters/shallowprofiler.ipynb b/book/chapters/shallowprofiler.ipynb
index 293cc66..1f01274 100644
--- a/book/chapters/shallowprofiler.ipynb
+++ b/book/chapters/shallowprofiler.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "63f97121-dd06-44b0-9886-e9e996417339",
+   "id": "c16fc22e-086f-40c7-a301-9e0dd1816336",
    "metadata": {},
    "source": [
     "[Jupyter Book](https://geo-smart.github.io/oceanography/intro.html) and [GitHub repo](https://github.com/geo-smart/oceanography).\n",
@@ -11,9 +11,6 @@
     "# Shallow Profiler\n",
     "\n",
     "\n",
-    "[Jupyter Book](https://geo-smart.github.io/oceanography/intro.html), [GitHub repo](https://github.com/geo-smart/oceanography).\n",
-    "\n",
-    "\n",
     "> Wavering between the profit and the loss /\n",
     "In this brief transit where the dreams cross... <br><br>-T.S.Eliot\n",
     "\n",
@@ -44,14 +41,28 @@
     "Multiple *instruments* are visible attached to the SCIP, each bearing\n",
     "one or more *sensors*. Sensors correspond to types of data: Temperature, \n",
     "salinity, chlorophyll fluorescence and so on. \n",
-    "```\n",
-    "\n",
-    "$*\\textrm{ The shallow profiler platform resides at a *site* (geographic location).<br>\n",
-    "Sites are in turn wired together by means of cables resting on the sea floor, forming <br>\n",
-    "an enormous undersea observatory, called the *Regional Cabled Array* or *RCA*. The <br>\n",
-    "RCA is one of several arrays making up the NSF-sponsored Ocean Observatories Initiative.}$\n",
-    "\n",
-    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "016e94dd-f7d4-48dd-aac4-db667d2bcf75",
+   "metadata": {},
+   "source": [
+    "$\\begin{align}{\\textrm{The shallow profiler platform resides at a site (i.e. a geographic location).}}\\end{align}$\n",
+    "<br>\n",
+    "$\\begin{align}{\\textrm{Sites are in turn wired together by means of cables resting on the sea floor}}\\end{align}$\n",
+    "<br>\n",
+    "$\\begin{align}{\\textrm{as an enormous undersea observatory, called the Regional Cabled Array (RCA). The}}\\end{align}$\n",
+    "<br>\n",
+    "$\\begin{align}{\\textrm{RCA is one of several arrays making up the Ocean Observatories Initiative.}}\\end{align}$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "523e2373-197a-493d-a229-b8e75d8f7b10",
+   "metadata": {},
+   "source": [
     "### Technical note\n",
     "\n",
     "The `shallowprofiler_techical.ipynb` notebook goes to some length to sort out the data dictionary for sensors\n",
@@ -82,7 +93,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 2,
    "id": "0dc9ce86-ece0-4a8e-b016-b8604c1c30e2",
    "metadata": {
     "tags": []
@@ -125,7 +136,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "e4ddc842-33a2-4b31-b705-8a01ea9bb1e4",
    "metadata": {
     "tags": []
@@ -154,7 +165,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "8536b017-911e-4d74-ba57-1c4c90d91ba8",
    "metadata": {
     "tags": []
@@ -194,7 +205,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "049d4cff-b1d2-4152-a4ba-41e2891b050d",
    "metadata": {
     "tags": []
@@ -228,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "a10605ea-57a9-4d9e-a593-e36483d06eee",
    "metadata": {
     "tags": []
@@ -262,7 +273,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "ff9ad8cd-eb68-483b-a565-d0299beb91eb",
    "metadata": {
     "tags": []
@@ -296,7 +307,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "1003765c-b69f-4bb0-a67a-ff959ec56197",
    "metadata": {
     "tags": []
@@ -330,7 +341,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "9ce31097-51b2-48d4-8692-bf69b13fa6ae",
    "metadata": {
     "tags": []
@@ -366,7 +377,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "43af628f-3df3-4771-a105-440816f63949",
    "metadata": {
     "tags": []
@@ -400,7 +411,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "8ac0e077-f1fe-413a-873f-8e03dee8c524",
    "metadata": {
     "tags": []
@@ -435,7 +446,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "d24bdc33-b1a8-47ce-b82d-5cd2b41dfcec",
    "metadata": {
     "tags": []
@@ -469,7 +480,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "id": "de6fd9ef-f269-403c-9831-4c183db18564",
    "metadata": {
     "tags": []
@@ -519,7 +530,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "id": "663a8767-a802-4ec4-8b98-43de19ff1bf5",
    "metadata": {
     "tags": []
@@ -582,7 +593,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "id": "b4a46ac1-3a93-4142-9ac9-07e526ef117d",
    "metadata": {
     "tags": []
@@ -597,9 +608,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "id": "fb0913c9-f44f-467c-8fdc-7bb25e08e077",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from ipywidgets import interact, widgets\n",
@@ -608,9 +621,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "id": "cf424214-afb5-4b42-b5f0-0f1d4f1f2496",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "def BundleInteract(sensor_key, time_index, bundle_size):\n",
@@ -668,14 +683,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "id": "a37208cf-a150-4b0a-98ce-2dff447edddd",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d690cbcfceac437285803a0f1b4e19ec",
+       "model_id": "99770cb66295458bb046a10f77b7f562",
        "version_major": 2,
        "version_minor": 0
       },
@@ -742,7 +759,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "id": "d58c9726-6242-4953-8bb4-a78228eef3a6",
    "metadata": {
     "tags": []
@@ -760,7 +777,7 @@
        "<IPython.core.display.Video object>"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -832,7 +849,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/book/chapters/shallowprofiler.py b/book/chapters/shallowprofiler.py
index cd55130..2ec6230 100644
--- a/book/chapters/shallowprofiler.py
+++ b/book/chapters/shallowprofiler.py
@@ -16,7 +16,7 @@ def day_of_month_to_string(d): return str(d) if d > 9 else '0' + str(d)
 print('\nJupyter Notebook running Python {}'.format(sys.version_info[0]))
 
 
-def ReadProfileMetadata(fnm = 'rca/profiles/osb/january2022.csv'):
+def ReadProfileMetadata(fnm = './data/rca/profiles/osb/january2022.csv'):
     """
     Profiles are saved in a CSV file as six events per row: Rest start, Rest end, Ascent start,
     Ascent end, Descent start, Descent end. Each event includes a time and depth. There is event