water-column-sonar-processing 0.0.9__py3-none-any.whl → 26.1.9__py3-none-any.whl

water_column_sonar_processing/cruise/create_empty_zarr_store.py

@@ -1,21 +1,13 @@
 import os
+import tempfile
 
-import numcodecs
 import numpy as np
 
-from water_column_sonar_processing.aws import DynamoDBManager
-from water_column_sonar_processing.aws import S3Manager
+from water_column_sonar_processing.utility import Constants
+from water_column_sonar_processing.aws import DynamoDBManager, S3Manager
 from water_column_sonar_processing.model import ZarrManager
 from water_column_sonar_processing.utility import Cleaner
 
-numcodecs.blosc.use_threads = False
-numcodecs.blosc.set_nthreads(1)
-
-# TEMPDIR = "/tmp"
-# TODO: when ready switch to version 3 of model spec
-# ZARR_V3_EXPERIMENTAL_API = 1
-# creates the latlon data: foo = ep.consolidate.add_location(ds_Sv, echodata)
-
 
 # TODO: change name to "CreateLocalEmptyZarrStore"
 class CreateEmptyZarrStore:
@@ -24,65 +16,37 @@ class CreateEmptyZarrStore:
         self,
     ):
         self.__overwrite = True
-        self.input_bucket_name = os.environ.get("INPUT_BUCKET_NAME")
-        self.output_bucket_name = os.environ.get("OUTPUT_BUCKET_NAME")
-
-    #######################################################
-
-    # TODO: move this to the s3_manager
-    def upload_zarr_store_to_s3(
-        self,
-        local_directory: str,
-        object_prefix: str,
-        cruise_name: str,
-    ) -> None:
-        print("uploading model store to s3")
-        s3_manager = S3Manager()
-        #
-        print("Starting upload with thread pool executor.")
-        # # 'all_files' is passed a list of lists: [[local_path, s3_key], [...], ...]
-        all_files = []
-        for subdir, dirs, files in os.walk(
-            f"{local_directory}/{cruise_name}.zarr_manager"
-        ):
-            for file in files:
-                local_path = os.path.join(subdir, file)
-                # 'level_2/Henry_B._Bigelow/HB0806/EK60/HB0806.model/.zattrs'
-                s3_key = f'{object_prefix}/{cruise_name}.model{local_path.split(f"{cruise_name}.model")[-1]}'
-                all_files.append([local_path, s3_key])
-        #
-        # print(all_files)
-        s3_manager.upload_files_with_thread_pool_executor(
-            all_files=all_files,
-        )
-        print("Done uploading with thread pool executor.")
-        # TODO: move to common place
+        # self.input_bucket_name = os.environ.get("INPUT_BUCKET_NAME")
+        # self.output_bucket_name = os.environ.get("OUTPUT_BUCKET_NAME")
 
     #######################################################
+    @staticmethod
     def create_cruise_level_zarr_store(
-        self,
+        output_bucket_name: str,
         ship_name: str,
         cruise_name: str,
         sensor_name: str,
         table_name: str,
-        tempdir: str,
     ) -> None:
+        """
+        Initialize zarr store for the entire cruise which aggregates all the raw data.
+        All cruises will be resampled at 20 cm depth.
+        # tempdir="/tmp", # TODO: create better tmp directory for testing
+        """
+        tempdir = tempfile.TemporaryDirectory()
         try:
-            # HB0806 - 123, HB0903 - 220
             dynamo_db_manager = DynamoDBManager()
             s3_manager = S3Manager()
 
             df = dynamo_db_manager.get_table_as_df(
                 table_name=table_name,
-                ship_name=ship_name,
                 cruise_name=cruise_name,
-                sensor_name=sensor_name,
             )
 
             # TODO: filter the dataframe just for enums >= LEVEL_1_PROCESSING
             # df[df['PIPELINE_STATUS'] < PipelineStatus.LEVEL_1_PROCESSING] = np.nan
 
-            # TODO: VERIFY GEOJSON EXISTS as prerequisite!!!
+            # TODO: VERIFY GEOJSON EXISTS as prerequisite!!! ...no more geojson needed
 
             print(f"DataFrame shape: {df.shape}")
             cruise_channels = list(
@@ -94,89 +58,64 @@ class CreateEmptyZarrStore:
                 df["NUM_PING_TIME_DROPNA"].dropna().astype(int)
             )
 
-            # [3] calculate the max/min measurement resolutions for the whole cruise
-            cruise_min_echo_range = float(
-                np.min(df["MIN_ECHO_RANGE"].dropna().astype(float))
-            )
+            # [4] max measurement resolution for the whole cruise
+            cruise_max_echo_range = np.max(df["MAX_ECHO_RANGE"].dropna().astype(float))
 
-            # [4] calculate the maximum of the max depth values
-            cruise_max_echo_range = float(
-                np.max(df["MAX_ECHO_RANGE"].dropna().astype(float))
-            )
-            print(
-                f"cruise_min_echo_range: {cruise_min_echo_range}, cruise_max_echo_range: {cruise_max_echo_range}"
-            )
+            print(f"cruise_max_echo_range: {cruise_max_echo_range}")
 
             # [5] get number of channels
             cruise_frequencies = [
                 float(i) for i in df["FREQUENCIES"].dropna().values.flatten()[0]
             ]
-            print(cruise_frequencies)
 
             new_width = int(consolidated_zarr_width)
-            print(f"new_width: {new_width}")
-            #################################################################
-            store_name = f"{cruise_name}.model"
-            print(store_name)
             ################################################################
-            # Delete existing model store if it exists
-            zarr_prefix = os.path.join("level_2", ship_name, cruise_name, sensor_name)
+            # Delete any existing stores
+            zarr_prefix = os.path.join(
+                str(Constants.LEVEL_2.value), ship_name, cruise_name, sensor_name
+            )
             child_objects = s3_manager.get_child_objects(
-                bucket_name=self.output_bucket_name,
+                bucket_name=output_bucket_name,
                 sub_prefix=zarr_prefix,
             )
+
             if len(child_objects) > 0:
                 s3_manager.delete_nodd_objects(
+                    bucket_name=output_bucket_name,
                     objects=child_objects,
                 )
             ################################################################
             # Create new model store
             zarr_manager = ZarrManager()
-            new_height = len(
-                zarr_manager.get_depth_values(
-                    min_echo_range=cruise_min_echo_range,
-                    max_echo_range=cruise_max_echo_range,
-                )
-            )
-            print(f"new_height: {new_height}")
-
             zarr_manager.create_zarr_store(
-                path=tempdir,
+                path=tempdir.name,
                 ship_name=ship_name,
                 cruise_name=cruise_name,
                 sensor_name=sensor_name,
                 frequencies=cruise_frequencies,
                 width=new_width,
-                min_echo_range=cruise_min_echo_range,
                 max_echo_range=cruise_max_echo_range,
+                # cruise_min_epsilon=cruise_min_epsilon,
                 calibration_status=True,
             )
             #################################################################
-            self.upload_zarr_store_to_s3(
-                local_directory=tempdir,
+            # TODO: would be more elegant to create directly into s3 bucket
+            s3_manager.upload_zarr_store_to_s3(
+                output_bucket_name=output_bucket_name,
+                local_directory=tempdir.name,
                 object_prefix=zarr_prefix,
                 cruise_name=cruise_name,
             )
-            # https://noaa-wcsd-zarr-pds.s3.amazonaws.com/index.html
             #################################################################
-            # Verify count of the files uploaded
-            # count = self.__get_file_count(store_name=store_name)
-            # #
-            # raw_zarr_files = self.__get_s3_files(  # TODO: just need count
-            #     bucket_name=self.__output_bucket,
-            #     sub_prefix=os.path.join(zarr_prefix, store_name),
-            # )
-            # if len(raw_zarr_files) != count:
-            #     print(f'Problem writing {store_name} with proper count {count}.')
-            #     raise Exception("File count doesnt equal number of s3 Zarr store files.")
-            # else:
-            #     print("File counts match.")
+            # TODO: verify count of the files uploaded
             #################################################################
-            # Success
             # TODO: update enum in dynamodb
+            print("Done creating cruise level zarr store.")
             #################################################################
         except Exception as err:
-            print(f"Problem trying to create new cruise model store: {err}")
+            raise RuntimeError(
+                f"Problem trying to create new cruise model store, {err}"
+            )
         finally:
             cleaner = Cleaner()
             cleaner.delete_local_files()

water_column_sonar_processing/cruise/datatree_manager.py

@@ -0,0 +1,21 @@
+# ### https://xarray-datatree.readthedocs.io/en/latest/data-structures.html
+# import xarray as xr
+# from datatree import DataTree
+#
+#
+# class DatatreeManager:
+#     #######################################################
+#     def __init__(
+#         self,
+#     ):
+#         self.dtype = "float32"
+#
+#     #################################################################
+#     def create_datatree(
+#         self,
+#         input_ds,
+#     ) -> None:
+#         ds1 = xr.Dataset({"foo": "orange"})
+#         dt = DataTree(name="root", dataset=ds1)  # create root node
+#         # ds2 = xr.Dataset({"bar": 0}, coords={"y": ("y", [0, 1, 2])})
+#         return dt

water_column_sonar_processing/cruise/resample_regrid.py

@@ -1,23 +1,14 @@
 import gc
-import os
+import warnings
 from pathlib import Path
 
-import numcodecs
 import numpy as np
-import pandas as pd
 import xarray as xr
 
 from water_column_sonar_processing.aws import DynamoDBManager
-from water_column_sonar_processing.geometry import GeometryManager
 from water_column_sonar_processing.model import ZarrManager
 
-numcodecs.blosc.use_threads = False
-numcodecs.blosc.set_nthreads(1)
-
-
-# TODO: when ready switch to version 3 of model spec
-#  ZARR_V3_EXPERIMENTAL_API = 1
-#  creates the latlon data: foo = ep.consolidate.add_location(ds_Sv, echodata)
+warnings.simplefilter("ignore", category=RuntimeWarning)
 
 
 class ResampleRegrid:
@@ -26,68 +17,55 @@ class ResampleRegrid:
         self,
     ):
         self.__overwrite = True
-        self.input_bucket_name = os.environ.get("INPUT_BUCKET_NAME")
-        self.output_bucket_name = os.environ.get("OUTPUT_BUCKET_NAME")
         self.dtype = "float32"
 
     #################################################################
     def interpolate_data(
         self,
-        input_xr,
-        ping_times,
-        all_cruise_depth_values,
+        input_xr: xr.Dataset,
+        ping_times: np.ndarray,
+        all_cruise_depth_values: np.ndarray,  # includes water_level offset
     ) -> np.ndarray:
-        print("Interpolating data.")
+        """
+        Input dataset is passed in along with times and depth values to regrid to.
+        """
+        print("Interpolating dataset.")
         try:
             data = np.empty(
-                (
+                (  # Depth / Time / Frequency
                     len(all_cruise_depth_values),
                     len(ping_times),
-                    len(input_xr.frequency_nominal),
+                    len(input_xr.frequency_nominal.values),
                 ),
                 dtype=self.dtype,
             )
 
             data[:] = np.nan
 
-            regrid_resample = xr.DataArray(
+            regrid_resample = xr.DataArray(  # where data will be written to
                 data=data,
-                dims=("depth", "time", "frequency"),
                 coords={
                     "depth": all_cruise_depth_values,
                     "time": ping_times,
                     "frequency": input_xr.frequency_nominal.values,
                 },
+                dims=("depth", "time", "frequency"),
+                name="Sv",
             )
 
             channels = input_xr.channel.values
             for channel in range(
                 len(channels)
-            ):  # TODO: leaving off here, need to subset for just indices in time axis
-                print(
-                    np.nanmax(
-                        input_xr.echo_range.sel(
-                            channel=input_xr.channel[channel]
-                        ).values
-                    )
-                )
-                #
+            ):  # ?TODO: leaving off here, need to subset for just indices in time axis
+                gc.collect()
                 max_depths = np.nanmax(
-                    a=input_xr.echo_range.sel(channel=input_xr.channel[channel]).values,
+                    a=input_xr.depth.sel(channel=input_xr.channel[channel]).values,
                     axis=1,
                 )
-                superset_of_max_depths = set(
-                    np.nanmax(
-                        input_xr.echo_range.sel(
-                            channel=input_xr.channel[channel]
-                        ).values,
-                        1,
-                    )
-                )
+                superset_of_max_depths = set(max_depths)
                 set_of_max_depths = list(
                     {x for x in superset_of_max_depths if x == x}
-                )  # removes nan's
-                # iterate through partitions of data with similar depths and resample
+                )  # To speed things up resample in groups denoted by max_depth
                 for select_max_depth in set_of_max_depths:
                     # TODO: for nan just skip and leave all nan's
                     select_indices = [
@@ -96,34 +74,35 @@ class ResampleRegrid:
                         if max_depths[i] == select_max_depth
                     ]
 
-                    # now create new DataArray with proper dimension and indices
-                    # data_select = input_xr.Sv.sel(
-                    #     channel=input_xr.channel[channel]
-                    # ).values[select_indices, :].T  # TODO: dont like this transpose
                     data_select = input_xr.Sv.sel(channel=input_xr.channel[channel])[
                         select_indices, :
                     ].T.values
-                    # change from ".values[select_indices, :].T" to "[select_indices, :].values.T"
 
                     times_select = input_xr.ping_time.values[select_indices]
-                    depths_select = input_xr.echo_range.sel(
-                        channel=input_xr.channel[channel]
-                    ).values[
-                        select_indices[0], :
-                    ]  # '0' because all others in group should be same
+                    depths_all = input_xr.depth.sel(
+                        channel=input_xr.channel[channel],
+                        ping_time=input_xr.ping_time[select_indices[0]],
+                    ).values
+                    depths_select = depths_all[~np.isnan(depths_all)]
 
                     da_select = xr.DataArray(
-                        data=data_select,
+                        data=data_select[: len(depths_select), :],
                         dims=("depth", "time"),
                         coords={
                             "depth": depths_select,
                             "time": times_select,
                         },
-                    ).dropna(dim="depth")
-                    resampled = da_select.interp(
-                        depth=all_cruise_depth_values, method="nearest"
                     )
-                    # write to the resample array
+
+                    resampled = (
+                        da_select.interp(  # TODO: problem here w D20070712-T152416.raw
+                            depth=all_cruise_depth_values,
+                            method="nearest",
+                            assume_sorted=True,
+                        )
+                    )
+
+                    ### write to outptut ###
                     regrid_resample.loc[
                         dict(
                             time=times_select,
@@ -131,11 +110,15 @@ class ResampleRegrid:
                         )
                     ] = resampled
                     print(f"updated {len(times_select)} ping times")
+                    gc.collect()
+            return (
+                regrid_resample.values.copy()
+            )  # gets passed back wo depth, might need to include?
         except Exception as err:
-            print(f"Problem finding the dynamodb table: {err}")
-            raise err
-        print("Done interpolating data.")
-        return regrid_resample
+            raise RuntimeError(f"Problem finding the dynamodb table, {err}")
+        finally:
+            gc.collect()
+            print("Done interpolating dataset.")
 
     #################################################################
     def resample_regrid(
@@ -144,66 +127,79 @@ class ResampleRegrid:
         cruise_name,
         sensor_name,
         table_name,
+        bucket_name,
+        override_select_files=None,
+        # override_cruise_min_epsilon=None,
+        endpoint_url=None,
     ) -> None:
         """
-        The goal here is to interpolate the data against the depth values already populated
+        The goal here is to interpolate the dataset against the depth values already populated
         in the existing file level model stores. We open the cruise-level store with model for
         read/write operations. We open the file-level store with Xarray to leverage tools for
-        resampling and subsetting the data.
+        resampling and subsetting the dataset.
         """
-        print("Interpolating data.")
+        print("Resample Regrid, Interpolating dataset.")
         try:
             zarr_manager = ZarrManager()
-            # s3_manager = S3Manager()
-            geo_manager = GeometryManager()
-            # get model store
+            # geo_manager = GeometryManager()
+
             output_zarr_store = zarr_manager.open_s3_zarr_store_with_zarr(
                 ship_name=ship_name,
                 cruise_name=cruise_name,
                 sensor_name=sensor_name,
-                # zarr_synchronizer=?  # TODO: pass in for parallelization
+                output_bucket_name=bucket_name,
+                endpoint_url=endpoint_url,
             )
 
-            # get dynamo stuff
             dynamo_db_manager = DynamoDBManager()
             cruise_df = dynamo_db_manager.get_table_as_df(
-                ship_name=ship_name,
                 cruise_name=cruise_name,
-                sensor_name=sensor_name,
                 table_name=table_name,
             )
 
             #########################################################
             #########################################################
-            # TODO: iterate files here
             all_file_names = cruise_df["FILE_NAME"]
+
+            if override_select_files is not None:
+                all_file_names = override_select_files
+
+            # Iterate files
             for file_name in all_file_names:
                 gc.collect()
                 file_name_stem = Path(file_name).stem
-                # file_name_stem = "D20070724-T151330"
                 print(f"Processing file: {file_name_stem}.")
-                # if f"{file_name_stem}.raw" not in list(cruise_df['FILE_NAME']):
-                #     raise Exception(f"Raw file file_stem not found in dynamodb.")
+
+                if f"{file_name_stem}.raw" not in list(cruise_df["FILE_NAME"]):
+                    raise Exception("Raw file file_stem not found in dynamodb.")
 
                 # status = PipelineStatus['LEVEL_1_PROCESSING']
                 # TODO: filter rows by enum success, filter the dataframe just for enums >= LEVEL_1_PROCESSING
                 #  df[df['PIPELINE_STATUS'] < PipelineStatus.LEVEL_1_PROCESSING] = np.nan
 
                 # Get index from all cruise files. Note: should be based on which are included in cruise.
-                index = cruise_df.index[
-                    cruise_df["FILE_NAME"] == f"{file_name_stem}.raw"
-                ][0]
+                index = int(
+                    cruise_df.index[cruise_df["FILE_NAME"] == f"{file_name_stem}.raw"][
+                        0
+                    ]
+                )
 
-                # get input store
+                # Get input store
                 input_xr_zarr_store = zarr_manager.open_s3_zarr_store_with_xarray(
                     ship_name=ship_name,
                     cruise_name=cruise_name,
                     sensor_name=sensor_name,
                     file_name_stem=file_name_stem,
+                    bucket_name=bucket_name,
+                    endpoint_url=endpoint_url,
                 )
+
+                # This is the vertical offset of the sensor related to the ocean surface
+                # See https://echopype.readthedocs.io/en/stable/data-proc-additional.html
+                # Ignoring water-level for now
                 #########################################################################
-                # [3] Get needed indices
-                # Offset from start index to insert new data. Note that missing values are excluded.
+                # [3] Get needed time indices — along the x-axis
+                # Offset from start index to insert new dataset. Note that missing values are excluded.
                 ping_time_cumsum = np.insert(
                     np.cumsum(
                         cruise_df["NUM_PING_TIME_DROPNA"].dropna().to_numpy(dtype=int)
@@ -214,85 +210,104 @@ class ResampleRegrid:
                 start_ping_time_index = ping_time_cumsum[index]
                 end_ping_time_index = ping_time_cumsum[index + 1]
 
-                min_echo_range = np.nanmin(np.float32(cruise_df["MIN_ECHO_RANGE"]))
-                max_echo_range = np.nanmax(np.float32(cruise_df["MAX_ECHO_RANGE"]))
-
-                print(
-                    "Creating empty ndarray for Sv data."
-                )  # Note: cruise_zarr dimensions are (depth, time, frequency)
-                cruise_sv_subset = np.empty(
-                    shape=output_zarr_store.Sv[
-                        :, start_ping_time_index:end_ping_time_index, :
-                    ].shape
+                max_echo_range = np.max(
+                    cruise_df["MAX_ECHO_RANGE"].dropna().astype(np.float32)
                 )
-                cruise_sv_subset[:, :, :] = np.nan  # (5208, 9778, 4)
+                # cruise_min_epsilon = np.min(
+                #     cruise_df["MIN_ECHO_RANGE"].dropna().astype(float)
+                # ) # TODO: currently overwriting to 0.25 m
 
                 all_cruise_depth_values = zarr_manager.get_depth_values(
-                    min_echo_range=min_echo_range, max_echo_range=max_echo_range
+                    max_echo_range=max_echo_range,
+                    # cruise_min_epsilon=cruise_min_epsilon,
                 )
 
-                print(" ".join(list(input_xr_zarr_store.Sv.dims)))
-                if set(input_xr_zarr_store.Sv.dims) != {
+                if set(
+                    input_xr_zarr_store.Sv.dims
+                ) != {  # Cruise dimensions are: (depth, time, frequency)
                     "channel",
                     "ping_time",
                     "range_sample",
                 }:
                     raise Exception("Xarray dimensions are not as expected.")
 
-                # get geojson
-                indices, geospatial = geo_manager.read_s3_geo_json(
-                    ship_name=ship_name,
-                    cruise_name=cruise_name,
-                    sensor_name=sensor_name,
-                    file_name_stem=file_name_stem,
-                    input_xr_zarr_store=input_xr_zarr_store,
-                )
+                # indices, geospatial = geo_manager.read_s3_geo_json(  # TODO: remove this!!!!
+                #     ship_name=ship_name,
+                #     cruise_name=cruise_name,
+                #     sensor_name=sensor_name,
+                #     file_name_stem=file_name_stem,
+                #     input_xr_zarr_store=input_xr_zarr_store,
+                #     endpoint_url=endpoint_url,
+                #     output_bucket_name=bucket_name,
+                # )
 
-                input_xr = input_xr_zarr_store.isel(ping_time=indices)
+                input_xr = input_xr_zarr_store  # .isel(ping_time=indices)
 
                 ping_times = input_xr.ping_time.values
-                # Date format: numpy.datetime64('2007-07-20T02:10:25.845073920') converts to "1184897425.845074"
-                epoch_seconds = [
-                    (pd.Timestamp(i) - pd.Timestamp("1970-01-01")) / pd.Timedelta("1s")
-                    for i in ping_times
-                ]
-                output_zarr_store.time[start_ping_time_index:end_ping_time_index] = (
-                    epoch_seconds
+                output_zarr_store["time"][start_ping_time_index:end_ping_time_index] = (
+                    input_xr.ping_time.data
                 )
 
-                # --- UPDATING --- #
-
+                # --- UPDATING --- # # TODO: problem, this returns dimensionless array
                 regrid_resample = self.interpolate_data(
                     input_xr=input_xr,
                     ping_times=ping_times,
-                    all_cruise_depth_values=all_cruise_depth_values,
+                    all_cruise_depth_values=all_cruise_depth_values,  # should accommodate the water_level already
                 )
 
                 print(
                     f"start_ping_time_index: {start_ping_time_index}, end_ping_time_index: {end_ping_time_index}"
                 )
-
                 #########################################################################
                 # write Sv values to cruise-level-model-store
-                for channel in range(
-                    len(input_xr.channel.values)
-                ):  # doesn't like being written in one fell swoop :(
-                    output_zarr_store.Sv[
-                        :, start_ping_time_index:end_ping_time_index, channel
-                    ] = regrid_resample[:, :, channel]
 
+                for fff in range(regrid_resample.shape[-1]):
+                    output_zarr_store["Sv"][
+                        : regrid_resample[:, :, fff].shape[0],
+                        start_ping_time_index:end_ping_time_index,
+                        fff,
+                    ] = regrid_resample[:, :, fff]
+                #########################################################################
+                #  in the future. See https://github.com/CI-CMG/water-column-sonar-processing/issues/11
+                if "detected_seafloor_depth" in list(input_xr.variables):
+                    print("Adding detected_seafloor_depth to output")
+                    detected_seafloor_depth = input_xr.detected_seafloor_depth.values
+                    detected_seafloor_depth[detected_seafloor_depth == 0.0] = np.nan
+
+                    # As requested, use the lowest frequencies to determine bottom
+                    detected_seafloor_depths = detected_seafloor_depth[0, :]
+
+                    detected_seafloor_depths[detected_seafloor_depths == 0.0] = np.nan
+                    print(f"min depth measured: {np.nanmin(detected_seafloor_depths)}")
+                    print(f"max depth measured: {np.nanmax(detected_seafloor_depths)}")
+                    output_zarr_store["bottom"][
+                        start_ping_time_index:end_ping_time_index
+                    ] = detected_seafloor_depths
+                #
                 #########################################################################
                 # [5] write subset of latitude/longitude
-                output_zarr_store.latitude[
+                # output_zarr_store["latitude"][
+                #     start_ping_time_index:end_ping_time_index
+                # ] = geospatial.dropna()[
+                #     "latitude"
+                # ].values  # TODO: get from ds_sv directly, dont need geojson anymore
+                # output_zarr_store["longitude"][
+                #     start_ping_time_index:end_ping_time_index
+                # ] = geospatial.dropna()["longitude"].values
+                #########################################################################
+                output_zarr_store["latitude"][
                     start_ping_time_index:end_ping_time_index
-                ] = geospatial.dropna()["latitude"].values
-                output_zarr_store.longitude[
+                ] = input_xr_zarr_store.latitude.dropna(dim="ping_time").values
+                output_zarr_store["longitude"][
                     start_ping_time_index:end_ping_time_index
-                ] = geospatial.dropna()["longitude"].values
+                ] = input_xr_zarr_store.longitude.dropna(dim="ping_time").values
+                #########################################################################
         except Exception as err:
-            print(f"Problem interpolating the data: {err}")
-            raise err
-        print("Done interpolating data.")
+            raise RuntimeError(f"Problem with resample_regrid, {err}")
+        finally:
+            print("Exiting resample_regrid.")
+            # TODO: read across times and verify dataset was written?
+            gc.collect()
 
     #######################################################