diff --git a/src/bmi_DAforcing.py b/src/bmi_DAforcing.py
new file mode 100644
index 000000000..c80424104
--- /dev/null
+++ b/src/bmi_DAforcing.py
@@ -0,0 +1,508 @@
+"""Basic Model Interface implementation for reservoirs."""
+
+import numpy as np
+from bmipy import Bmi
+from pathlib import Path
+
+# Here is the model we want to run
+from model_DAforcing import DAforcing_model
+
+class bmi_DAforcing(Bmi):
+
+    def __init__(self):
+        """Create a Bmi DA forcing model that is ready for initialization."""
+        super(bmi_DAforcing, self).__init__()
+        self._model = None
+        self._values = {}
+        #self._var_units = {}
+        self._var_loc = "node"
+        self._var_grid_id = 0
+        #self._grids = {}
+        #self._grid_type = {}
+
+        self._start_time = 0.0
+        self._end_time = np.finfo("d").max
+        self._time_units = "s"
+
+    #----------------------------------------------
+    # Required, static attributes of the model
+    #----------------------------------------------
+    _att_map = {
+        'model_name':         'DA forcing for Next Generation NWM',
+        'version':            '',
+        'author_name':        '',
+        'grid_type':          'scalar', 
+        'time_step_size':      1,       
+        #'time_step_type':     'donno', #unused  
+        #'step_method':        'none',  #unused
+        #'time_units':         '1 hour' #NJF Have to drop the 1 for NGEN to recognize the unit
+        'time_units':         'seconds' }
+
+    #---------------------------------------------
+    # Input variable names (CSDMS standard names)
+    #---------------------------------------------
+    _input_var_names = [
+        # waterbody static variables
+        #'lake_surface__elevation',
+        #'LkArea',
+        #'WeirE',
+        #'WeirC',
+        #'WeirL',
+        #'dam_length',
+        #'OrificeE',
+        #'OrificeC',
+        #'OrificeA',
+        #'LkMxE',
+        #'waterbody_id',
+        #'ifd',
+        #'upstream_ids',
+        #'res_type',
+        #'da_idx',
+        #'time_step',
+        #'rfc_forecast_persist_seconds',
+        #'synthetic_flag',
+        # dynamic forcing/DA variables        
+        #'lake_water~incoming__volume_flow_rate',
+        # RFC DA inputs
+        #rfc_timeseries_offset_hours,
+        #rfc_gage_id,
+        #rfc_timeseries_folder,
+        'lake_number',   
+        ]
+
+    #---------------------------------------------
+    # Output variable names (CSDMS standard names)
+    #---------------------------------------------
+    _output_var_names = [
+                         #'lake_water~outgoing__volume_flow_rate',
+                         #'lake_surface__elevation',
+                        # RFC DA ouputs
+                        'waterbody_rfc__use_flag', #'use_RFC', 
+                        'waterbody_rfc__observed_volume_flow_rate', #'rfc_timeseries_discharges', 
+                        'waterbody_rfc__timeseries_index', #'rfc_timeseries_idx', 
+                        'waterbody_rfc__timeseries_update_time', #'rfc_timeseries_update_time', 
+                        'waterbody_rfc__da_time_step', #'rfc_da_time_step', 
+                        'waterbody_rfc__total_count', #'rfc_total_counts',
+                        'waterbody_rfc__file_of_observed_volume_flow_rate', #'rfc_timeseries_file',
+                        ]
+
+    #------------------------------------------------------
+    # Create a Python dictionary that maps CSDMS Standard
+    # Names to the model's internal variable names.
+    #------------------------------------------------------
+    #TODO update all these...
+    _var_name_units_map = {
+        #'channel_exit_water_x-section__volume_flow_rate':['streamflow_cms','m3 s-1'],
+        #'channel_water_flow__speed':['streamflow_ms','m s-1'],
+        #'channel_water__mean_depth':['streamflow_m','m'],
+        #'lake_water~incoming__volume_flow_rate':['waterbody_cms','m3 s-1'],
+        #'lake_water~outgoing__volume_flow_rate':['waterbody_cms','m3 s-1'],
+        #'lake_surface__elevation':['waterbody_m','m'],
+        #--------------   Dynamic inputs --------------------------------
+        #'land_surface_water_source__volume_flow_rate':['streamflow_cms','m3 s-1'],
+        #'coastal_boundary__depth':['depth_m', 'm'],
+        #'usgs_gage_observation__volume_flow_rate':['streamflow_cms','m3 s-1'],
+        #'reservoir_usgs_gage_observation__volume_flow_rate':['streamflow_cms','m3 s-1'],
+        #'reservoir_usace_gage_observation__volume_flow_rate':['streamflow_cms','m3 s-1'],
+        #'rfc_gage_observation__volume_flow_rate':['streamflow_cms','m3 s-1'],
+        #'lastobs__volume_flow_rate':['streamflow_cms','m3 s-1']
+        # TODO: RFC unit map
+        'waterbody__type_number': ['',''],
+        'waterbody__lake_number': ['','string'],  #'lake_number':['',''],
+        'waterbody_rfc__use_flag': ['use_RFC','boolean'],     #'use_RFC':['',''], 
+        'waterbody_rfc__observed_volume_flow_rate': ['streamflow_cms in timeseries', 'm3 s-1'], # 'rfc_timeseries_discharges':['streamflow_cms','m3 s-1'], 
+        'waterbody_rfc__timeseries_index': [' ',' '], #'rfc_timeseries_idx':['time_step_count',''], 
+        'waterbody_rfc__timeseries_update_time': ['time', 'sec'],      #'rfc_timeseries_update_time':['time','s'], 
+        'waterbody_rfc__da_time_step': ['', 'sec'],  #'rfc_da_time_step':['time_step','s'], 
+        'waterbody_rfc__total_count': ['','int'],   #'rfc_total_counts':['count',''],
+        'waterbody_rfc__file_of_observed_volume_flow_rate': ['',''],  #'rfc_timeseries_file':['',''],
+        'usace_timeslice_discharge':['streamflow_cms','m3 s-1'],
+        'usace_timeslice_stationId':['',''],
+        'usace_timeslice_time':['time',''],
+    }
+
+    #------------------------------------------------------
+    # A list of static attributes. Not all these need to be used.
+    #------------------------------------------------------
+    _static_attributes_list = []
+
+
+    #------------------------------------------------------------
+    #------------------------------------------------------------
+    # BMI: Model Control Functions
+    #------------------------------------------------------------ 
+    #------------------------------------------------------------
+
+    #-------------------------------------------------------------------
+    def initialize(self, bmi_cfg_file=None):
+        
+        # -------------- Read in the BMI configuration -------------------------#
+        if bmi_cfg_file:
+            bmi_cfg_file = Path(bmi_cfg_file)
+
+        # ------------- Initialize t-route model ------------------------------#
+        self._model = DAforcing_model(bmi_cfg_file) 
+
+        # ----- Create some lookup tabels from the long variable names --------#
+        self._var_name_map_long_first = {long_name:self._var_name_units_map[long_name][0] for \
+                                         long_name in self._var_name_units_map.keys()}
+        self._var_name_map_short_first = {self._var_name_units_map[long_name][0]:long_name for \
+                                          long_name in self._var_name_units_map.keys()}
+        self._var_units_map = {long_name:self._var_name_units_map[long_name][1] for \
+                                          long_name in self._var_name_units_map.keys()}
+        
+
+        # -------------- Initalize all the variables --------------------------# 
+        # -------------- so that they'll be picked up with the get functions --#
+        self._values['waterbody__lake_number'] = np.zeros(1, dtype='<U19')
+        self._values['waterbody__type_number'] = np.zeros(1, dtype=int)
+        '''
+        self._values['use_RFC'] = np.zeros(1, dtype=bool) 
+        self._values['rfc_timeseries_discharges'] = np.zeros(289) 
+        self._values['rfc_timeseries_idx'] = np.zeros(1) 
+        self._values['rfc_timeseries_update_time'] = np.zeros(1) 
+        self._values['rfc_da_time_step'] = np.zeros(1) 
+        self._values['rfc_total_counts'] = np.zeros(1)
+        self._values['rfc_timeseries_file'] = np.zeros(1,  dtype='<U19')
+        self._values['usace_timeslice_discharge'] = np.zeros(5192)
+        self._values['usace_timeslice_stationId'] = np.zeros(5192)
+        self._values['usace_timeslice_time'] = np.zeros(5192)
+        '''
+        '''
+        #FIXME Do this better..., load size of variables from config file??
+        self._values['lake_surface__elevation'] = np.zeros(1)
+        self._values['LkArea'] = np.zeros(1)
+        self._values['WeirE'] = np.zeros(1)
+        self._values['WeirC'] = np.zeros(1)
+        self._values['WeirL'] = np.zeros(1)
+        self._values['dam_length'] = np.zeros(1)
+        self._values['OrificeE'] = np.zeros(1)
+        self._values['OrificeC'] = np.zeros(1)
+        self._values['OrificeA'] = np.zeros(1)
+        self._values['LkMxE'] = np.zeros(1)
+        self._values['waterbody_id'] = np.zeros(1)
+        self._values['ifd'] = np.zeros(1)
+        self._values['upstream_ids'] = np.zeros(1, dtype=int)
+        self._values['reservoir_type'] = np.zeros(1)
+        self._values['lake_water~incoming__volume_flow_rate'] = np.zeros(12)
+        self._values['lake_water~outgoing__volume_flow_rate'] = np.zeros(1)
+
+
+        #TODO: how will we know the size of these arrays?
+        self._values['gage_observations'] = np.zeros(120)
+        self._values['gage_time'] = np.zeros(120)
+
+        self._values['da_idx'] = np.zeros(1, dtype=int)
+        self._values['time_step'] = np.zeros(1)
+        self._values['rfc_forecast_persist_seconds'] = np.zeros(1)
+        self._values['synthetic_flag'] = np.zeros(289)
+        
+        #RFC DA        
+        self._values['rfc_timeseries_offset_hours'] = np.zeros(1)
+        self._values['rfc_forecast_persist_days'] = np.zeros(1)
+        '''
+        '''
+        for var_name in self._input_var_names + self._output_var_names:
+            # ---------- Temporarily set to 3 values ------------------#
+            # ---------- so just set to zero for now ------------------#
+            self._values[var_name] = np.zeros(3)
+        '''
+
+
+    def update(self):
+        """Advance model by one time step."""
+        if self._model._time==0.0:
+            self._model.preprocess_static_vars(self._values) 
+
+        self._model.run(self._values)
+
+    def update_until(self, until):
+        """Update model until a particular time.
+        Parameters
+        ----------
+        until : int
+            Time to run model until in seconds.
+        """
+        n_steps = int(until/self._model._time_step)
+
+        for _ in range(int(n_steps)):
+            self.update()
+
+    def finalize(self):
+        """Finalize model."""
+
+        self._model = None
+    
+    def update_frac(self, time_frac):
+        """Update model by a fraction of a time step.
+        Parameters
+        ----------
+        time_frac : float
+            Fraction fo a time step.
+        """
+        time_step = self.get_time_step()
+        self._model.time_step = time_frac * time_step
+        self.update()
+        self._model.time_step = time_step
+
+    def get_var_type(self, var_name):
+        """Data type of variable.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        Returns
+        -------
+        str
+            Data type.
+        """
+        return str(self.get_value_ptr(var_name).dtype)
+
+    def get_var_units(self, var_name):
+        """Get units of variable.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        Returns
+        -------
+        str
+            Variable units.
+        """
+        return self._var_units[var_name]
+
+    def get_var_nbytes(self, var_name):
+        """Get units of variable.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        Returns
+        -------
+        int
+            Size of data array in bytes.
+        """
+        return self.get_value_ptr(var_name).nbytes
+
+    def get_var_itemsize(self, name):
+        return np.dtype(self.get_var_type(name)).itemsize
+
+    def get_var_location(self, name):
+        return self._var_loc[name]
+
+    def get_var_grid(self, var_name):
+        """Grid id for a variable.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        Returns
+        -------
+        int
+            Grid id.
+        """
+        for grid_id, var_name_list in self._grids.items():
+            if var_name in var_name_list:
+                return grid_id
+
+    def get_grid_rank(self, grid_id):
+        """Rank of grid.
+        Parameters
+        ----------
+        grid_id : int
+            Identifier of a grid.
+        Returns
+        -------
+        int
+            Rank of grid.
+        """
+        return len(self._model.shape)
+
+    def get_grid_size(self, grid_id):
+        """Size of grid.
+        Parameters
+        ----------
+        grid_id : int
+            Identifier of a grid.
+        Returns
+        -------
+        int
+            Size of grid.
+        """
+        return int(np.prod(self._model.shape))
+
+    def get_value_ptr(self, var_name):
+        """Reference to values.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        Returns
+        -------
+        array_like
+            Value array.
+        """
+        return self._values[var_name]
+
+    def get_value(self, var_name):
+        """Copy of values.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        Returns
+        -------
+        output_df : pd.DataFrame
+            Copy of values.
+        """
+        output_df = self.get_value_ptr(var_name)
+        return output_df
+
+    def get_value_at_indices(self, var_name, dest, indices):
+        """Get values at particular indices.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        dest : ndarray
+            A numpy array into which to place the values.
+        indices : array_like
+            Array of indices.
+        Returns
+        -------
+        array_like
+            Values at indices.
+        """
+        dest[:] = self.get_value_ptr(var_name).take(indices)
+        return dest
+
+    def set_value(self, var_name, src):
+        """
+        Set model values
+        
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        src : array_like
+            Array of new values.
+        """
+        val = self.get_value_ptr(var_name)
+        val[:] = src.reshape(val.shape)
+        
+        #self._values[var_name] = src
+
+    def set_value_at_indices(self, name, inds, src):
+        """Set model values at particular indices.
+        Parameters
+        ----------
+        var_name : str
+            Name of variable as CSDMS Standard Name.
+        src : array_like
+            Array of new values.
+        indices : array_like
+            Array of indices.
+        """
+        val = self.get_value_ptr(name)
+        val.flat[inds] = src
+
+    def get_component_name(self):
+        """Name of the component."""
+        return self._name
+
+    def get_input_item_count(self):
+        """Get names of input variables."""
+        return len(self._input_var_names)
+
+    def get_output_item_count(self):
+        """Get names of output variables."""
+        return len(self._output_var_names)
+
+    def get_input_var_names(self):
+        """Get names of input variables."""
+        return self._input_var_names
+
+    def get_output_var_names(self):
+        """Get names of output variables."""
+        return self._output_var_names
+
+    def get_grid_shape(self, grid_id, shape):
+        """Number of rows and columns of uniform rectilinear grid."""
+        var_name = self._grids[grid_id][0]
+        shape[:] = self.get_value_ptr(var_name).shape
+        return shape
+
+    def get_grid_spacing(self, grid_id, spacing):
+        """Spacing of rows and columns of uniform rectilinear grid."""
+        spacing[:] = self._model.spacing
+        return spacing
+
+    def get_grid_origin(self, grid_id, origin):
+        """Origin of uniform rectilinear grid."""
+        origin[:] = self._model.origin
+        return origin
+
+    def get_grid_type(self, grid_id):
+        """Type of grid."""
+        return self._grid_type[grid_id]
+
+    def get_start_time(self):
+        """Start time of model."""
+        return self._start_time
+
+    def get_end_time(self):
+        """End time of model."""
+        return self._end_time
+
+    def get_current_time(self):
+        return self._model._time
+
+    def get_time_step(self):
+        return self._model._time_step
+
+    def get_time_units(self):
+        return self._time_units
+
+    def get_grid_edge_count(self, grid):
+        raise NotImplementedError("get_grid_edge_count")
+
+    def get_grid_edge_nodes(self, grid, edge_nodes):
+        raise NotImplementedError("get_grid_edge_nodes")
+
+    def get_grid_face_count(self, grid):
+        raise NotImplementedError("get_grid_face_count")
+
+    def get_grid_face_nodes(self, grid, face_nodes):
+        raise NotImplementedError("get_grid_face_nodes")
+
+    def get_grid_node_count(self, grid):
+        """Number of grid nodes.
+        Parameters
+        ----------
+        grid : int
+            Identifier of a grid.
+        Returns
+        -------
+        int
+            Size of grid.
+        """
+        return self.get_grid_size(grid)
+
+    def get_grid_nodes_per_face(self, grid, nodes_per_face):
+        raise NotImplementedError("get_grid_nodes_per_face")
+
+    def get_grid_face_edges(self, grid, face_edges):
+        raise NotImplementedError("get_grid_face_edges")
+
+    def get_grid_x(self, grid, x):
+        raise NotImplementedError("get_grid_x")
+
+    def get_grid_y(self, grid, y):
+        raise NotImplementedError("get_grid_y")
+
+    def get_grid_z(self, grid, z):
+        raise NotImplementedError("get_grid_z")
+        
+    def _parse_config(self, cfg):
+        cfg_list = [cfg.get('flag'),cfg.get('file')]
+        return cfg_list
\ No newline at end of file
diff --git a/src/bmi_reservoirs.py b/src/bmi_reservoirs.py
index 8492fcdc5..f6faf212f 100644
--- a/src/bmi_reservoirs.py
+++ b/src/bmi_reservoirs.py
@@ -53,7 +53,7 @@ def __init__(self):
         'OrificeC',
         'OrificeA',
         'LkMxE',
-        'waterbody_id',
+        'hl_link', #  'waterbody_id',
         'ifd',
         'upstream_ids',
         'res_type',
@@ -138,11 +138,11 @@ def initialize(self, bmi_cfg_file=None):
         self._values['OrificeC'] = np.zeros(1)
         self._values['OrificeA'] = np.zeros(1)
         self._values['LkMxE'] = np.zeros(1)
-        self._values['waterbody_id'] = np.zeros(1)
+        self._values['hl_link'] = np.zeros(1)
         self._values['ifd'] = np.zeros(1)
         self._values['upstream_ids'] = np.zeros(1, dtype=int)
         self._values['reservoir_type'] = np.zeros(1)
-        self._values['lake_water~incoming__volume_flow_rate'] = np.zeros(12)
+        self._values['lake_water~incoming__volume_flow_rate'] = np.zeros(25)
         self._values['lake_water~outgoing__volume_flow_rate'] = np.zeros(1)
 
 
@@ -158,19 +158,26 @@ def initialize(self, bmi_cfg_file=None):
         #RFC DA        
         self._values['rfc_timeseries_offset_hours'] = np.zeros(1)
         self._values['rfc_forecast_persist_days'] = np.zeros(1)
- 
+        self._values['lake_number'] = np.zeros(1, dtype='<U19')
+        self._values['reservoir_type'] = np.zeros(1, dtype=int)
+        self._values['use_RFC'] = np.zeros(1, dtype=bool) 
+        self._values['rfc_timeseries_discharges'] = np.zeros(289) 
+        self._values['rfc_timeseries_idx'] = np.zeros(1) 
+        self._values['rfc_timeseries_update_time'] = np.zeros(1) 
+        self._values['rfc_da_time_step'] = np.zeros(1) 
+        self._values['rfc_total_counts'] = np.zeros(1)
+        self._values['rfc_timeseries_file'] = np.zeros(1,  dtype='<U19')
+
         '''
         for var_name in self._input_var_names + self._output_var_names:
             # ---------- Temporarily set to 3 values ------------------#
             # ---------- so just set to zero for now ------------------#
             self._values[var_name] = np.zeros(3)
         '''
-
     def update(self):
         """Advance model by one time step."""
         if self._model._time==0.0:
             self._model.preprocess_static_vars(self._values) 
-
         self._model.run(self._values)
 
     def update_until(self, until):
@@ -181,7 +188,6 @@ def update_until(self, until):
             Time to run model until in seconds.
         """
         n_steps = int(until/self._model._time_step)
-
         for _ in range(int(n_steps)):
             self.update()
 
diff --git a/src/bmi_troute.py b/src/bmi_troute.py
index e079249fe..86b2a440e 100644
--- a/src/bmi_troute.py
+++ b/src/bmi_troute.py
@@ -134,10 +134,16 @@ def initialize(self, bmi_cfg_file=None):
         # -------------- Read in the BMI configuration -------------------------#
         bmi_cfg_file = Path(bmi_cfg_file)
         bmi_parameters = _read_config_file(bmi_cfg_file)
+        flowpath_columns = bmi_parameters.get('flowpath_columns')
+        attributes_columns = bmi_parameters.get('attributes_columns')
+        lakes_columns = bmi_parameters.get('waterbody_columns', [])
+        network_columns = bmi_parameters.get('network_columns', [])
+
         n_segment = int(bmi_parameters.get('segment_number'))
         n_waterbody = int(bmi_parameters.get('waterbody_number'))
         n_io = int(bmi_parameters.get('io_number'))
         n_upstream = int(bmi_parameters.get('upstream_number'))
+        n_gages = int(bmi_parameters.get('gage_number'))
 
         # ------------- Initialize t-route model ------------------------------#
         self._model = troute_model(bmi_cfg_file)
@@ -149,25 +155,26 @@ def initialize(self, bmi_cfg_file=None):
                                           long_name in self._var_name_units_map.keys()}
         self._var_units_map = {long_name:self._var_name_units_map[long_name][1] for \
                                           long_name in self._var_name_units_map.keys()}
-    
 
         # -------------- Initalize all the variables --------------------------# 
         # -------------- so that they'll be picked up with the get functions --#
-        #FIXME Do this better..., load size of variables from config file??
-        self._values['segment_id'] = np.zeros(n_segment, dtype=int)
-        self._values['segment_toid'] = np.zeros(n_segment, dtype=int)
-        self._values['dx'] = np.zeros(n_segment)
+        for col in flowpath_columns + attributes_columns + lakes_columns + network_columns:
+            self._values[col] = np.zeros(0)
+        
+        self._values['id'] = np.zeros(n_segment, dtype=int)
+        self._values['toid'] = np.zeros(n_segment, dtype=int)
+        self._values['lengthkm'] = np.zeros(n_segment)
         self._values['n'] = np.zeros(n_segment)
-        self._values['ncc'] = np.zeros(n_segment)
-        self._values['s0'] = np.zeros(n_segment)
-        self._values['bw'] = np.zeros(n_segment)
-        self._values['tw'] = np.zeros(n_segment)
-        self._values['twcc'] = np.zeros(n_segment)
+        self._values['nCC'] = np.zeros(n_segment)
+        self._values['So'] = np.zeros(n_segment)
+        self._values['BtmWdth'] = np.zeros(n_segment)
+        self._values['TopWdth'] = np.zeros(n_segment)
+        self._values['TopWdthCC'] = np.zeros(n_segment)
         self._values['alt'] = np.zeros(n_segment)
-        self._values['musk'] = np.zeros(n_segment)
-        self._values['musx'] = np.zeros(n_segment)
-        self._values['cs'] = np.zeros(n_segment)
-        self._values['waterbody_id'] = np.zeros(n_waterbody, dtype=int)
+        self._values['MusK'] = np.zeros(n_segment)
+        self._values['MusX'] = np.zeros(n_segment)
+        self._values['ChSlp'] = np.zeros(n_segment)        
+        self._values['hl_link'] = np.zeros(n_waterbody, dtype=int)
         self._values['waterbody_toid'] = np.zeros(n_waterbody, dtype=int)
         self._values['LkArea'] = np.zeros(n_waterbody)
         self._values['LkMxE'] = np.zeros(n_waterbody)
@@ -178,16 +185,19 @@ def initialize(self, bmi_cfg_file=None):
         self._values['WeirE'] = np.zeros(n_waterbody)
         self._values['WeirL'] = np.zeros(n_waterbody)
         self._values['ifd'] = np.zeros(n_waterbody)
+        self._values['network_id'] = np.zeros(n_segment)
+        self._values['hydroseq'] = np.zeros(n_segment)
+        self._values['hl_uri'] = np.zeros(n_segment)
         #self._values['qd0'] = np.zeros(1) #TODO will this come from a file or model engine?
         #self._values['h0'] = np.zeros(1) #TODO will this come from a file or model engine?
         self._values['reservoir_type'] = np.zeros(n_waterbody)
+        self._values['waterbody_connections__link'] = np.zeros(0)
+        self._values['waterbody_connections__lake'] = np.zeros(0)        
+        
         self._values['land_surface_water_source__volume_flow_rate'] = np.zeros(n_io)
+        self._values['land_surface_water_source__id'] = np.zeros(n_io)
         self._values['coastal_boundary__depth'] = np.zeros(0)
-        self._values['usgs_gage_observation__volume_flow_rate'] = np.zeros(0)
-        self._values['reservoir_usgs_gage_observation__volume_flow_rate'] = np.zeros(0)
-        self._values['reservoir_usace_gage_observation__volume_flow_rate'] = np.zeros(0)
-        self._values['rfc_gage_observation__volume_flow_rate'] = np.zeros(0)
-        self._values['lastobs__volume_flow_rate'] = np.zeros(0)
+
         self._values['channel_exit_water_x-section__volume_flow_rate'] = np.zeros(n_io)
         self._values['channel_water_flow__speed'] = np.zeros(n_io)
         self._values['channel_water__mean_depth'] = np.zeros(n_io)
@@ -206,10 +216,36 @@ def initialize(self, bmi_cfg_file=None):
         self._values['fvd_results'] = np.zeros(n_segment*3*12)
         self._values['fvd_index'] = np.zeros(1)
 
-        """
-        #TODO Update loading RFC data not through Fortran reservoir module.
-        self._values['rfc_gage_observation__volume_flow_rate'] = np.zeros(0)
-        """
+        # Data assimilation values
+        self._values['gage_crosswalk__segID'] = np.zeros(0, dtype=int)
+        self._values['gage_crosswalk__gageID'] = np.zeros(0, dtype='<U19')
+        self._values['gages'] = np.zeros(6, dtype='<U19')
+        self._values['usgs_timeslice_discharge'] = np.zeros(10010)
+        self._values['usgs_timeslice_stationId'] = np.zeros(10010, dtype='<U19')
+        self._values['usgs_timeslice_time'] = np.zeros(10010, dtype='<U19')
+        self._values['usgs_timeslice_discharge_quality'] = np.zeros(10010)
+
+        self._values['gages'] = np.zeros(6, dtype='<U19')
+        self._values['usace_timeslice_discharge'] = np.zeros(5192)
+        self._values['usace_timeslice_stationId'] = np.zeros(5192, dtype='<U19')
+        self._values['usace_timeslice_time'] = np.zeros(5192, dtype='<U19')
+        self._values['usace_timeslice_discharge_quality'] = np.zeros(5192)
+
+        self._values['lastobs_discharge'] = np.zeros(76)
+        self._values['lastobs_stationIdInd'] = np.zeros(9, dtype=int)
+        self._values['lastobs_timeInd'] = np.zeros(9, dtype=int)
+        #self._values['lastobs_stationId'] = np.zeros(76, dtype='<S19') #S19 keep 'b'prefix
+        self._values['lastobs_stationId'] = np.zeros(76, dtype='<U19')
+        self._values['lastobs_time'] = np.zeros(9, dtype='<U19')
+        self._values['lastobs_modelTimeAtOutput'] = np.zeros(1, dtype='<U19')
+        self._values['time_since_lastobs'] = np.zeros(76)
+
+        self._values['rfc_discharges'] = np.zeros(289)
+        self._values['rfc_stationId'] = np.zeros(3, dtype='<U19')
+        self._values['rfc_synthetic_values'] = np.zeros(0)
+        self._values['rfc_totalCounts'] = np.zeros(0)
+        self._values['rfc_datetime'] = np.zeros(3, dtype='<U19')
+        self._values['rfc_timestep'] = np.zeros(0)
 
     # Currently utilized BMI functions:
     def update(self):
@@ -240,10 +276,10 @@ def set_value(self, var_name, src):
         src : array_like
             Array of new values.
         """
-        val = self.get_value_ptr(var_name)
-        val[:] = src.reshape(val.shape)
+        #val = self.get_value_ptr(var_name)
+        #val[:] = src.reshape(val.shape)
         
-        #self._values[var_name] = src
+        self._values[var_name] = src
 
     def get_value(self, var_name):
         """Copy of values.
diff --git a/src/model_DAforcing.py b/src/model_DAforcing.py
new file mode 100644
index 000000000..485d31ca7
--- /dev/null
+++ b/src/model_DAforcing.py
@@ -0,0 +1,826 @@
+import numpy as np
+import netCDF4 as nc
+import pandas as pd
+import yaml
+from array import array
+import datetime
+import pathlib
+import logging
+from joblib import delayed, Parallel
+import netCDF4
+import xarray as xr
+
+
+from troute.routing.fast_reach.reservoir_hybrid_da import reservoir_hybrid_da
+from troute.routing.fast_reach.reservoir_RFC_da import reservoir_RFC_da, preprocess_RFC_data
+from troute.DataAssimilation import build_lastobs_df, _create_usgs_df, _reindex_link_to_lake_id
+#import troute.nhd_network_utilities_v02 as nnu
+
+
+class DAforcing_model():
+
+    def __init__(self, bmi_cfg_file=None):
+        """
+        
+        """
+        __slots__ = ['_data_assimilation_parameters', '_streamflow_da_parameters',
+                     '_lake_number', '_res_type', '_gage_lakeID_crosswalk_file', 
+                     '_time', '_time_step', 
+                     '_rfc_timeseries_idx', '_rfc_gage_id', '_rfc_timeseries_folder',
+                     '_rfc_timeseries_file', '_rfc_timeseries_offset_hours', '_rfc_forecast_persist_days',
+                     '_time_step_seconds', '_total_counts', '_rfc_timeseries_discharges', '_rfc_update_time', 
+                     '_use_RFC',
+                     '_timeslice_obs', '_timeslice_datetime', '_timeslice_stationId',
+                     '_timeslice_discharge_quality', 
+                     '_nudging', '_lastobs_stationId', '_time_since_lastobs', '_lastobs_discharge' ]
+
+        if bmi_cfg_file:
+            (#bmi_parameters, #TODO We might not need any bmi specific parameters
+             log_parameters, #TODO Update all logging/warnings throughout standalone reservoirs...
+             compute_parameters,
+             restart_parameters,
+             forcing_parameters,
+             data_assimilation_parameters,
+            ) = _read_config_file(bmi_cfg_file)
+
+            self._compute_parameters = compute_parameters
+            self._forcing_parameters = forcing_parameters
+            self._data_assimilation_parameters = data_assimilation_parameters
+
+            #if compute_parameters:
+            self._time_step = forcing_parameters.get("dt", 300) #time step in sec
+            self._nts = forcing_parameters.get("nts", 288) #the number of time steps
+            #NOTE: For any each operation either of AnA or Forecast, t0 (model start date) is
+            #provided from config file.            
+            self._t0 = restart_parameters.get("start_datetime", None)   
+            rfc_parameters = data_assimilation_parameters.get("rfc_reservoir_da", None) 
+            
+            if not self._t0:
+                raise(RuntimeError("No start_datetime provided in config file."))
+
+            if rfc_parameters:
+                #self._rfc_gage_id = rfc_parameters.get("reservoir_rfc_gage_id", None)
+                
+                #self._reservoir_rfc_forecast_lookback_hours= rfc_parameters.get("reservoir_rfc_forecast_lookback_hours",None)
+                self._rfc_timeseries_folder = rfc_parameters.get("rfc_forecast_time_series_folder", None)
+                self._gage_lakeID_crosswalk_file = rfc_parameters.get("gage_lakeID_crosswalk_file", None)
+                self._rfc_forecast_peyrsist_days = rfc_parameters.get("reservoir_rfc_forecast_persist_days", 11)
+                self._rfc_timeseries_offset_hours = rfc_parameters.get("reservoir_rfc_timeseries_offset_hours", 28)
+        else:
+            raise(RuntimeError("No config file provided."))
+            
+        self._time = 0.0  # initiall set zero but will be in sync with troute_model's self._time (sec)
+    
+    def preprocess_static_vars(self, values: dict):
+        '''
+        Create static data structures for reservoir DA objects and streamflow nudging 
+
+        Parameters
+        ----------
+
+            
+        Returns
+        -------
+
+        '''
+        data_assimilation_parameters = self._data_assimilation_parameters
+        streamflow_da_parameters     = data_assimilation_parameters.get('streamflow_da', None)
+
+        if streamflow_da_parameters:
+            self._nudging = streamflow_da_parameters.get('streamflow_nudging', False)
+        
+        self._lastobs_file = streamflow_da_parameters.get("wrf_hydro_lastobs_file", None)
+        self._lastobs_crosswalk_file = streamflow_da_parameters.get("gage_segID_crosswalk_file", None)
+        self._lastobs_start = streamflow_da_parameters.get("wrf_hydro_lastobs_lead_time_relative_to_simulation_start_time", 0)
+        self._streamflow_da_parameters = streamflow_da_parameters 
+
+        self._lake_number = values['waterbody__lake_number'] # NHDWaterbodyComID in RouteLink.nc
+        self._res_type = values['waterbody__type_number']
+
+        if self._res_type==4 or self._res_type==5:
+        # prepare static data for RFC DA
+            self.gage_lake_crosswalk_beta()
+
+    def gage_lake_crosswalk_beta(self):
+        '''
+        Compute gage to lake crosswalk DataFrame using lake_gage_df.csv
+
+        Parameters
+        ----------
+        values: dict
+            The model state data structure.
+            
+        Returns
+        -------
+        rfc_gage_id
+        '''
+        if self._res_type==4 or self._res_type==5:
+            #RFC reservoir DA
+            file= self._gage_lakeID_crosswalk_file
+            lake_gage_df = pd.read_csv(file)
+            self._rfc_gage_id = lake_gage_df.loc[(lake_gage_df['lake_id']==int(self._lake_number[0]))&
+                                            (lake_gage_df['reservoir_type']==self._res_type[0]), 
+                                            'gage_id'].values[0]
+
+    def run(self, values: dict,):
+        """
+        Run this model into the future, updating the state stored in the provided model dict appropriately.
+    
+        Parameters
+        ----------
+        values: dict
+            The model state data structure.
+            
+        Returns
+        -------
+        """
+
+         # compute data assimilation time series and related dynamic parameters
+        if self._res_type==2 or self._res_type==3 or self._nudging:                
+
+            #Create 1d numpy array of last_obs_df with with each element starting with stationID, 
+            #followed by time_since_lastobs and lastobs_discharge 
+            last_obs_df       = pd.DataFrame()            
+            lastobs_file = self._streamflow_da_parameters.get("wrf_hydro_lastobs_file", None)
+
+            if lastobs_file:                
+                #lastobs_crosswalk_file = streamflow_da_parameters.get("gage_segID_crosswalk_file", None)
+                lastobs_start = self._streamflow_da_parameters.get("wrf_hydro_lastobs_lead_time_relative_to_simulation_start_time", 0)
+       
+                lastobs_df = build_lastobs_df(
+                                                lastobs_file,
+                                                #self._lastobs_crosswalk_file,
+                                                lastobs_start,
+                                                )
+                #1D array with each element starting with stationID, followed by time_since_lastobs and lastobs_discharge 
+                lastobs_arr =  np.array(lastobs_df.to_records(index=True))
+                self._lastobs_stationId  = lastobs_arr['gages'].tolist()
+                self._time_since_lastobs = lastobs_arr['time_since_lastobs'].tolist()                
+                self._lastobs_discharge  = lastobs_arr['lastobs_discharge'].tolist()
+
+            # replace link ids with lake ids, for gages at waterbody outlets, 
+            # otherwise, gage data will not be assimilated at waterbody outlet
+            # segments.
+            #if network.link_lake_crosswalk:
+            #    self._last_obs_df = _reindex_link_to_lake_id(self._last_obs_df, network.link_lake_crosswalk)
+       
+            #Create 1d numpy arrays with each element having station id and discharge timeseries or 
+            #stationID and discharge qual. timeseries
+            timeslice_obs_df  = pd.DataFrame()
+            timeslice_qual_df = pd.DataFrame()
+            # Create da_sets: sets of TimeSlice files for each loop          
+            dt = datetime.datetime.strptime(self._t0,"%Y-%m-%d_%H:%M:%S") 
+            formatted_date = datetime.datetime(dt.year, dt.month, dt.day, dt.hour, dt.minute)
+            hours = self._time_step*self._nts/(60*60)
+            td = datetime.timedelta(hours=hours)
+            final_timestamp = formatted_date + td         
+ 
+            if self._data_assimilation_parameters:
+                #da_sets = nnu.build_da_sets(data_assimilation_parameters, run_sets, network.t0)
+                da_sets = build_da_sets(self._data_assimilation_parameters, final_timestamp, self._t0)
+            da_run=da_sets[0]
+                       
+            run_parameters = {
+                            'dt': self._forcing_parameters.get('dt'),
+                            'nts': self._forcing_parameters.get('nts'),
+                            'cpu_pool': self._compute_parameters.get('cpu_pool')
+                            }
+            #from_files=True,c
+            #value_dict=None, 
+            persistence_reservoir_da = self._data_assimilation_parameters.get("persistence_reservoir_da", None)
+            streamflow_da_parameters = self._data_assimilation_parameters.get('streamflow_da', None)
+
+            # Compared to _create_usgs_df used in DataAssimilation.py, this _create_timeslice_df doesn't
+            # do crosswalk b/t gageID and linkID and QC, all of which will be performed within t-route.
+            timeslice_obs_df = _create_timeslice_df(
+                                            persistence_reservoir_da,
+                                            #self._data_assimilation_parameters, 
+                                            streamflow_da_parameters, 
+                                            run_parameters, 
+                                            self._t0,
+                                            #network, 
+                                            da_run,
+                                            )
+            # convert a dataframe to a 1D numpy array while including the index value (station id) as part of the array
+            timeslice_obs_arr      = np.array(timeslice_obs_df.to_records(index=True)) # 1d array with each element having station id and discharge timeseries
+            n_elements_each_record = len(timeslice_obs_arr.dtype) - 1
+            stationId              = timeslice_obs_arr['link']
+            stationId_repeat_list  = (np.repeat(stationId, n_elements_each_record)).tolist()
+            # repeated timestamps by n_element_each_record for 
+            timestamps             = timeslice_obs_df.columns.strftime('%Y-%m-%d %H:%M:%S').tolist()
+            datetime_repeat_list   = timestamps*len(stationId)
+            # observed time series for one stationId after another 
+            obs_list=[]
+            for idx in range(len(stationId)):
+                obs_at_station = timeslice_obs_arr[idx]
+                temp_list = obs_at_station.tolist()
+                obs_list.extend(temp_list[1:])
+
+            self._timeslice_obs               = obs_list   
+            self._timeslice_datetime          = datetime_repeat_list
+            self._timeslice_stationId         = stationId_repeat_list
+            self._timeslice_discharge_quality = np.full(len(obs_list),100)
+
+        if self._res_type==4 or self._res_type==5:
+            (self._use_RFC, 
+             self._rfc_timeseries_discharges, 
+             self._rfc_timeseries_idx, 
+             self._rfc_update_time, 
+             self._da_time_step, 
+             self._total_counts,
+             self._rfc_timeseries_file) = preprocess_RFC_data( 
+                                                        self._t0,
+                                                        self._rfc_timeseries_offset_hours,
+                                                        self._rfc_gage_id,
+                                                        self._rfc_timeseries_folder,
+                                                        int(self._lake_number[0]),
+                                                        self._time_step
+                                                        )
+
+# Utility functions -------
+def _read_config_file(custom_input_file):
+    '''
+    Read-in data from user-created configuration file.
+    
+    Arguments
+    ---------
+    custom_input_file (str): configuration filepath, .yaml
+    
+    Returns
+    -------
+    bmi_parameters               (dict): Input parameters re bmi configuration
+    log_parameters               (dict): Input parameters re logging
+    compute_parameters           (dict): Input parameters re computation settings
+    data_assimilation_parameters (dict): Input parameters re data assimilation
+
+    '''
+    with open(custom_input_file) as custom_file:
+        data = yaml.load(custom_file, Loader=yaml.SafeLoader)
+
+    #bmi_parameters = data.get("bmi_parameters", None)
+    log_parameters = data.get("log_parameters", None)
+    compute_parameters = data.get("compute_parameters", None)
+    restart_parameters = compute_parameters.get("restart_parameters", None)
+    forcing_parameters = compute_parameters.get("forcing_parameters", None)
+    data_assimilation_parameters = compute_parameters.get("data_assimilation_parameters", None)
+    rfc_parameters = data_assimilation_parameters.get("rfc_reservoir_da", None)
+
+    return (
+        #bmi_parameters,
+        log_parameters,
+        compute_parameters,
+        restart_parameters,
+        forcing_parameters,
+        data_assimilation_parameters,
+        )
+
+def build_da_sets(da_params, final_timestamp, t0):
+    """
+    Create set lists of USGS and/or USACE TimeSlice files used for 
+    streamflow and reservoir data assimilation
+        
+    Arguments
+    --------
+    - da_params (dict): user-input data assimilation parameters
+    - run_sets (list) : forcing files for each run set in the simlation
+    - t0 (datetime)   : model initialization time
+        
+    Returns
+    -------
+    - da_sets (list)  : lists of USGS and USACE TimeSlice files for each run set 
+                         in the simulation
+        
+    Notes
+    -----
+        
+    """
+
+    persistence_reservoir_da = da_params.get('persistence_reservoir_da', False)
+    # check for user-input usgs and usace timeslice directories
+    usgs_timeslices_folder = persistence_reservoir_da.get(
+        "usgs_timeslices_folder",
+        None
+    )
+    usace_timeslices_folder = persistence_reservoir_da.get(
+        "usace_timeslices_folder",
+        None
+    )
+
+    # User-specified DA ON/OFF preferences
+    usace_da = False
+    usgs_da = False
+    #reservoir_da = da_params.get('reservoir_da', False)
+    if persistence_reservoir_da:
+        usgs_da = persistence_reservoir_da.get('reservoir_persistence_usgs', False)
+        usace_da = persistence_reservoir_da.get('reservoir_persistence_usace', False)
+        
+    nudging = False
+    streamflow_da = da_params.get('streamflow_da', False)
+    if streamflow_da:
+        nudging = streamflow_da.get('streamflow_nudging', False)
+            
+    if not usgs_da and not usace_da and not nudging:
+        # if all DA capabilities are OFF, return empty dictionary
+        #da_sets = [{} for _ in run_sets]
+        da_sets= {}
+
+    # if no user-input timeslice folders, a list of empty dictionaries
+    elif not usgs_timeslices_folder and not usace_timeslices_folder:
+        # if no timeslice folders, return empty dictionary
+        #da_sets = [{} for _ in run_sets]
+        da_sets = {}
+
+    # if user-input timeslice folders are present, build TimeSlice sets
+    else:            
+        # create Path objects for each TimeSlice directory
+        if usgs_timeslices_folder:
+            usgs_timeslices_folder = pathlib.Path(usgs_timeslices_folder)
+        if usace_timeslices_folder:
+            usace_timeslices_folder = pathlib.Path(usace_timeslices_folder)
+            
+        # the number of timeslice files appended to the front- and back-ends
+        # of the TimeSlice file interpolation stack
+        pad_hours = persistence_reservoir_da.get("timeslice_lookback_hours",1)
+        timeslice_pad = pad_hours * 4 # number of 15 minute TimeSlices in the pad
+
+        # timedelta of TimeSlice data - typically 15 minutes
+        dt_timeslice = datetime.timedelta(minutes = 15)
+
+        da_sets = [] # initialize list to store TimeSlice set lists
+
+        # Loop through each run set and build lists of available TimeSlice files
+        if 1==1:
+        #for (i, set_dict) in enumerate(run_sets):
+            i=0    
+            # Append an empty dictionary to the loop, which be used to hold
+            # lists of USGS and USACE TimeSlice files.
+            da_sets.append({})
+
+            # timestamps of TimeSlice files desired for run set i
+            t0 = datetime.datetime.strptime(t0,"%Y-%m-%d_%H:%M:%S") 
+            timestamps = pd.date_range(
+                t0 - dt_timeslice * timeslice_pad,
+                #run_sets[i]['final_timestamp'] + dt_timeslice * 4,
+                final_timestamp + dt_timeslice * 4,
+                freq=dt_timeslice
+            )
+
+            # identify available USGS TimeSlices in run set i
+            if (usgs_timeslices_folder and nudging) or (usgs_timeslices_folder and usgs_da):
+                filenames_usgs = (timestamps.strftime('%Y-%m-%d_%H:%M:%S') 
+                            + '.15min.usgsTimeSlice.ncdf').to_list()
+                    
+                # identify available USGS TimeSlices
+                filenames_usgs = _check_timeslice_exists(
+                        filenames_usgs, 
+                        usgs_timeslices_folder
+                )
+                    
+                # Add available TimeSlices to da_sets list
+                da_sets[i]['usgs_timeslice_files'] = filenames_usgs
+                    
+            # identify available USACE TimeSlices in run set i
+            if usace_timeslices_folder and usace_da:
+                filenames_usace = (timestamps.strftime('%Y-%m-%d_%H:%M:%S') 
+                                + '.15min.usaceTimeSlice.ncdf').to_list()
+                    
+                # identify available USACE TimeSlices
+                filenames_usace = _check_timeslice_exists(
+                        filenames_usace, 
+                        usace_timeslices_folder
+                )
+                    
+                # Add available TimeSlices to da_sets list
+                da_sets[i]['usace_timeslice_files'] = filenames_usace
+
+            # reset initialization time for loop set i+1
+            #t0 = run_sets[i]['final_timestamp']
+            t0 = final_timestamp
+                
+    return da_sets
+
+def _check_timeslice_exists(filenames, timeslices_folder):
+    """
+    Check that each TimeSlice file in a list of files exists. Return a list of 
+    available files.
+    
+    Arguments
+    ---------
+    - filenames               (list of str): TimeSlice filenames
+    - timeslices_folder (pathlib.PosixPath): TimeSlice directory
+    
+    Returns
+    -------
+    - filenames_existing (list of chr): Existing TimeSlice filenames in 
+                                        TimeSlice directory
+    
+    Notes
+    -----
+    - This is a utility function used by build_da_sets
+    
+    """
+    LOG = logging.getLogger('')
+    
+    # check that all USGS TimeSlice files in the set actually exist
+    drop_list = []
+    for f in filenames:
+        try:
+            J = pathlib.Path(timeslices_folder.joinpath(f))     
+            assert J.is_file() == True
+        except AssertionError:
+            LOG.warning("Missing TimeSlice file %s", J)
+            drop_list.append(f)
+
+    # Assemble a list of existing TimeSlice files, only
+    filenames_existing = [x for x in filenames if x not in drop_list]   
+    
+    return filenames_existing
+
+
+def _create_timeslice_df(
+                    persistence_reservoir_da,
+                    #data_assimilation_parameters, 
+                    streamflow_da_parameters,                    
+                    run_parameters, 
+                    t0,
+                    #network, 
+                    da_run):
+    '''
+    Function for reading USGS or USACE timeslice files and creating a dataframe
+    of USGS or USACE gage observations. This dataframe is used for streamflow
+    nudging and can be used for constructing USGS/USACE persistence reservoir DA.
+    
+    Arguments:
+    ----------
+    - persistence_reservoir_da     (dict): user input data re persistence reservoir da
+    - run_parameters               (dict): user input data re subset of compute configuration
+    - da_run                       (list): list of data assimilation files separated by for loop chunks
+    
+    Returns:
+    --------
+    - usgs_df (DataFrame): dataframe of USGS gage observations
+    '''
+
+    usgs_timeslices_folder  = persistence_reservoir_da.get("usgs_timeslices_folder", None)
+    usace_timeslices_folder = persistence_reservoir_da.get("usace_timeslices_folder", None)
+    #crosswalk_file         = streamflow_da_parameters.get("gage_segID_crosswalk_file", None)
+    crosswalk_gage_field    = streamflow_da_parameters.get('crosswalk_gage_field','gages')
+    crosswalk_segID_field   = streamflow_da_parameters.get('crosswalk_segID_field','link')
+    #da_decay_coefficient   = data_assimilation_parameters.get("da_decay_coefficient",120)
+    qc_threshold            = persistence_reservoir_da.get("qc_threshold",1)
+    interpolation_limit     = persistence_reservoir_da.get("interpolation_limit_min",59)
+
+
+    # User-specified DA ON/OFF preferences
+    usace_da = False
+    usgs_da = False
+    usgs_da = persistence_reservoir_da.get('reservoir_persistence_usgs', False)
+    usace_da = persistence_reservoir_da.get('reservoir_persistence_usace', False)
+    usgs_timeslices_folder = persistence_reservoir_da.get('usgs_timeslices_folder', None)
+    usace_timeslices_folder = persistence_reservoir_da.get('usace_timeslices_folder', None)    
+
+    timeslice_files= False
+    if usgs_timeslices_folder and usgs_da:
+        usgs_timeslices_folder = pathlib.Path(usgs_timeslices_folder)
+        timeslice_files = [usgs_timeslices_folder.joinpath(f) for f in 
+                        da_run['usgs_timeslice_files']]
+
+    if usace_timeslices_folder and usace_da:    
+        usace_timeslices_folder = pathlib.Path(usace_timeslices_folder)
+        timeslice_files = [usace_timeslices_folder.joinpath(f) for f in 
+                  da_run['usace_timeslice_files']]
+	
+    #t0 = datetime.datetime.strptime(t0,"%Y-%m-%d_%H:%M:%S") 
+
+    if timeslice_files:
+        timeslice_obs_df = get_obs_from_timeslices(
+                #network.link_gage_df,
+                crosswalk_gage_field,
+                crosswalk_segID_field,
+                timeslice_files,
+                qc_threshold,
+                interpolation_limit,
+                run_parameters.get("dt"),
+                t0,
+                #network.t0,
+                run_parameters.get("cpu_pool", None)
+                ) #.loc[network.link_gage_df.index]
+        
+		
+		# replace link ids with lake ids, for gages at waterbody outlets, 
+		# otherwise, gage data will not be assimilated at waterbody outlet
+		# segments.
+        #if network.link_lake_crosswalk:
+        #    usgs_df = _reindex_link_to_lake_id(usgs_df, network.link_lake_crosswalk)
+    
+    else:
+        timeslice_obs_df  = pd.DataFrame()
+    
+    return timeslice_obs_df
+
+def get_obs_from_timeslices(
+    #crosswalk_df,
+    crosswalk_gage_field,
+    crosswalk_dest_field,
+    timeslice_files,
+    qc_threshold,
+    interpolation_limit,
+    frequency_secs,
+    t0,
+    cpu_pool, 
+):
+    """
+    Read observations from TimeSlice files, interpolate available observations
+    and organize into a Pandas DataFrame
+    
+    Aguments
+    --------                                          
+    - crosswalk_gage_field         (str): fieldname of gage ID data in crosswalk dataframe
+    
+    - crosswalk_dest_field         (str): fieldname of destination data in link_gage_df. 
+                                          For streamflow DA, this is the field
+                                          containing segment IDs. For reservoir DA, 
+                                          this is the field containing waterbody IDs.
+                                          
+    - timeslice_files (list of PosixPath): Full paths to existing TimeSlice files
+    
+    - qc_threshold                  (int): Numerical observation quality 
+                                           threshold. Observations with quality
+                                           flags less than this value will be 
+                                           removed and replaced witn nan.
+                                           
+    - interpolation_limit           (int): Maximum gap duration (minuts) over 
+                                           which observations may be interpolated 
+                                           
+    - t0                       (datetime): Initialization time of simulation set
+    
+    - cpu_pool                      (int): Number of CPUs used for parallel 
+                                           TimeSlice reading and interolation
+    
+    Returns
+    -------
+    - observation_df_new (Pandas DataFrame): 
+    
+    Notes
+    -----
+    The max_fill is applied when the series is being considered at a 1 minute interval
+    so 14 minutes ensures no over-interpolation with 15-minute gage records, but creates
+    square-wave signals at gages reporting hourly...
+    therefore, we advise a 59 minute gap filling tolerance.
+    
+    """
+    # TODO: 
+    # - Parallelize this reading for speedup using netCDF4
+    # - Generecize the function to read USACE or USGS data
+    # - only return gages that are in the model domain (consider mask application)
+
+    # open TimeSlce files, organize data into dataframes
+    with Parallel(n_jobs=cpu_pool) as parallel:
+        jobs = []
+        for f in timeslice_files:
+            jobs.append(delayed(_read_timeslice_file)(f))
+        timeslice_dataframes = parallel(jobs)
+
+    # create lists of observations and obs quality dataframes returned 
+    # from _read_timeslice_file
+    timeslice_obs_frames = []
+    timeslice_qual_frames = []
+    for d in timeslice_dataframes:
+        timeslice_obs_frames.append(d[0])  # TimeSlice gage observation
+        timeslice_qual_frames.append(d[1]) # TimeSlice observation qual
+
+    # concatenate dataframes
+    timeslice_obs_df  = pd.concat(timeslice_obs_frames, axis = 1)
+    timeslice_qual_df = pd.concat(timeslice_qual_frames, axis = 1) 
+
+    # While it should be Link <> gage crosswalk data, we use here a fake crosswalk_df
+    # that has gage <> gage instead.
+    fake_crosswalk_df = (pd.DataFrame({
+                                crosswalk_dest_field: timeslice_obs_df.index,
+                                crosswalk_gage_field:  timeslice_obs_df.index    
+                        }))
+
+    df = fake_crosswalk_df
+    df[crosswalk_gage_field] = np.asarray(df[crosswalk_gage_field]).astype('<U15')
+    df = df.set_index(crosswalk_gage_field)
+    
+    # join crosswalk data with timeslice data, indexed on crosswalk destination field
+    observation_df = (df.join(timeslice_obs_df).
+               reset_index().
+               set_index(crosswalk_dest_field).
+               drop([crosswalk_gage_field], axis=1))
+
+    observation_qual_df = (df.join(timeslice_qual_df).
+               reset_index().
+               set_index(crosswalk_dest_field).
+               drop([crosswalk_gage_field], axis=1))
+
+    # ---- Laugh testing ------
+    # screen-out erroneous qc flags
+    observation_qual_df = (observation_qual_df.
+                           mask(observation_qual_df < 0, np.nan).
+                           mask(observation_qual_df > 1, np.nan)
+                          )
+
+    # screen-out poor quality flow observations
+    observation_df = (observation_df.
+                      mask(observation_qual_df < qc_threshold, np.nan).
+                      mask(observation_df <= 0, np.nan)
+                     )
+
+    # ---- Interpolate USGS observations to the input frequency (frequency_secs)
+    # This step is especially essential as actual published time of flow for stations
+    # can be different from timestamp included in the names of timeslice files.
+    observation_df_T = observation_df.transpose()             # transpose, making time the index
+    observation_df_T.index = pd.to_datetime(
+        observation_df_T.index, format = "%Y-%m-%d_%H:%M:%S"  # index variable as type datetime
+    )
+    
+    # specify resampling frequency 
+    frequency = str(int(frequency_secs/60))+"min"    
+    
+    # interpolate and resample frequency
+    buffer_df = observation_df_T.resample(frequency).asfreq()
+    with Parallel(n_jobs=cpu_pool) as parallel:
+        
+        jobs = []
+        interp_chunks = ()
+        step = 200
+        for a, i in enumerate(range(0, len(observation_df_T.columns), step)):
+            
+            start = i
+            if (i+step-1) < buffer_df.shape[1]:
+                stop = i+(step)
+            else:
+                stop = buffer_df.shape[1]
+                
+            jobs.append(
+                delayed(_interpolate_one)(observation_df_T.iloc[:,start:stop], interpolation_limit, frequency)
+            )
+            
+        interp_chunks = parallel(jobs)
+
+    observation_df_T = pd.DataFrame(
+        data = np.concatenate(interp_chunks, axis = 1), 
+        columns = buffer_df.columns, 
+        index = buffer_df.index
+    )
+    # re-transpose, making link the index
+    # TODO: Witine t-route or reservoir module, link value should be replaced by actual linkId 
+    # correponding to stationId (link here is actually still stationId)
+    observation_df_new = observation_df_T.transpose()    
+
+    return observation_df_new
+ 
+
+def _read_timeslice_file(f):
+
+    with netCDF4.Dataset(
+        filename = f,
+        mode = 'r',
+        format = "NETCDF4"
+    ) as ds:
+        
+        discharge = ds.variables['discharge'][:].filled(fill_value = np.nan)
+        stns      = ds.variables['stationId'][:].filled(fill_value = np.nan)
+        t         = ds.variables['time'][:].filled(fill_value = np.nan)
+        qual      = ds.variables['discharge_quality'][:].filled(fill_value = np.nan)
+        
+    stationId = np.apply_along_axis(''.join, 1, stns.astype(np.str))
+    time_str = np.apply_along_axis(''.join, 1, t.astype(np.str))
+    stationId = np.char.strip(stationId)
+
+    timeslice_observations = (pd.DataFrame({
+                                'stationId' : stationId,
+                                'datetime'  : time_str,
+                                'discharge' : discharge
+                            }).
+                             set_index(['stationId', 'datetime']).
+                             unstack(1, fill_value = np.nan)['discharge'])
+    
+    observation_quality = (pd.DataFrame({
+                                'stationId' : stationId,
+                                'datetime'  : time_str,
+                                'quality'   : qual/100
+                            }).
+                             set_index(['stationId', 'datetime']).
+                             unstack(1, fill_value = np.nan)['quality'])
+    
+    return timeslice_observations, observation_quality
+
+def build_lastobs_df(
+        lastobsfile,
+        #crosswalk_file,
+        time_shift           = 0,
+        crosswalk_gage_field = "gages",
+        crosswalk_link_field = "link",
+        obs_discharge_id     = "discharge",
+        time_idx_id          = "timeInd",
+        station_id           = "stationId",
+        station_idx_id       = "stationIdInd",
+        time_id              = "time",
+        discharge_nan        = -9999.0,
+        ref_t_attr_id        = "modelTimeAtOutput",
+        route_link_idx       = "feature_id",
+    ):
+    '''
+    Constructs a DataFame of "lastobs" data used in streamflow DA routine
+    "lastobs" information is just like it sounds. It is the magnitude and
+    timing of the last valid observation at each gage in the model domain. 
+    We use this information to jump start initialize the DA process, both 
+    for forecast and AnA simulations. 
+    
+    Arguments
+    ---------
+    
+    Returns
+    -------
+    
+    Notes
+    -----
+    
+    '''
+    # open crosswalking file and construct dataframe relating gageID to segmentID
+    #with xr.open_dataset(crosswalk_file) as ds:
+    #    gage_list = list(map(bytes.strip, ds[crosswalk_gage_field].values))
+    #    gage_mask = list(map(bytes.isalnum, gage_list))
+    #    gage_da   = list(map(bytes.strip, ds[crosswalk_gage_field][gage_mask].values))
+    #    data_var_dict = {
+    #        crosswalk_gage_field: gage_da,
+    #        crosswalk_link_field: ds[crosswalk_link_field].values[gage_mask],
+    #    }
+    #    gage_link_df = pd.DataFrame(data = data_var_dict).set_index([crosswalk_gage_field])
+      
+    with xr.open_dataset(lastobsfile) as ds:        
+        gages    = np.char.strip(ds[station_id].values)
+        
+        ref_time = datetime.datetime.strptime(ds.attrs[ref_t_attr_id], "%Y-%m-%d_%H:%M:%S")
+        
+        last_ts = ds[time_idx_id].values[-1]
+        
+        df_discharge = (
+            ds[obs_discharge_id].to_dataframe().                 # discharge to MultiIndex DF
+            replace(to_replace = discharge_nan, value = np.nan). # replace null values with nan
+            unstack(level = 0)                                   # unstack to single Index (timeInd)    
+        )
+        
+        last_obs_index = (
+            df_discharge.
+            apply(pd.Series.last_valid_index).                   # index of last non-nan value, each gage
+            to_numpy()                                           # to numpy array
+        )
+        last_obs_index = np.nan_to_num(last_obs_index, nan = last_ts).astype(int)
+                        
+        last_observations = []
+        lastobs_times     = []
+        for i, idx in enumerate(last_obs_index):
+            last_observations.append(df_discharge.iloc[idx,i])
+            lastobs_times.append(ds.time.values[i, idx].decode('utf-8'))
+            
+        last_observations = np.array(last_observations)
+        lastobs_times     = pd.to_datetime(
+            np.array(lastobs_times), 
+            format="%Y-%m-%d_%H:%M:%S", 
+            errors = 'coerce'
+        )
+
+        lastobs_times = (lastobs_times - ref_time).total_seconds()
+        lastobs_times = lastobs_times - time_shift
+
+    data_var_dict = {
+        'gages'               : gages,
+        'time_since_lastobs'  : lastobs_times,
+        'lastobs_discharge'   : last_observations
+    }
+
+    lastobs_df = (
+        pd.DataFrame(data = data_var_dict).
+        set_index('gages')
+        #join(gage_link_df, how = 'inner').
+        #reset_index().
+        #set_index(crosswalk_link_field)
+    )
+    
+
+    #lastobs_df = lastobs_df[
+    #    [
+    #        'gages',
+    #        'time_since_lastobs',
+    #        'lastobs_discharge',
+    #    ]
+    #]
+    
+    return lastobs_df
+
+def _interpolate_one(df, interpolation_limit, frequency):
+    
+    interp_out = (df.resample('min').
+                        interpolate(
+                            limit = interpolation_limit, 
+                            limit_direction = 'both'
+                        ).
+                        resample(frequency).
+                        asfreq().
+                        to_numpy()
+                       )
+    return interp_out
diff --git a/src/model_reservoir.py b/src/model_reservoir.py
index 503cb3562..638dee16e 100644
--- a/src/model_reservoir.py
+++ b/src/model_reservoir.py
@@ -49,7 +49,7 @@ def __init__(self, bmi_cfg_file=None):
 
     def preprocess_static_vars(self, values: dict):
 
-        lake_number = values['waterbody_id']
+        lake_number = values['hl_link']
         lake_area = values['LkArea']
         max_depth = values['LkMxE']
         orifice_area = values['OrificeA']
@@ -85,18 +85,31 @@ def preprocess_static_vars(self, values: dict):
             self._persistence_update_time = 0
         
         if self._res_type==4 or self._res_type==5:
-            (self._use_RFC, 
-             self._timeseries_discharges, 
-             self._timeseries_idx, 
-             self._update_time, 
-             self._da_time_step, 
-             self._total_counts,
-             self._rfc_timeseries_file) = preprocess_RFC_data(self._t0,
-                                     self._rfc_timeseries_offset_hours,
-                                     self._rfc_gage_id,
-                                     self._rfc_timeseries_folder,
-                                     lake_number,
-                                     self._time_step)
+            if np.all(values['rfc_timeseries_discharges']==0):
+                (self._use_RFC, 
+                self._timeseries_discharges, 
+                self._timeseries_idx, 
+                self._update_time, 
+                self._da_time_step, 
+                self._total_counts,
+                self._rfc_timeseries_file) = preprocess_RFC_data(
+                                                                self._t0,
+                                                                self._rfc_timeseries_offset_hours,
+                                                                self._rfc_gage_id,
+                                                                self._rfc_timeseries_folder,
+                                                                lake_number,
+                                                                self._time_step
+                                                                )
+            else:
+                #RFC parameter values from BMI-supplied array values
+                self._use_RFC = values['use_RFC'][0]
+                self._timeseries_discharges = values['rfc_timeseries_discharges'] 
+                self._timeseries_idx = int(values['rfc_timeseries_idx'][0])
+                self._update_time = int(values['rfc_timeseries_update_time'][0])
+                self._da_time_step = int(values['rfc_da_time_step'][0]) 
+                self._total_counts = int(values['rfc_total_counts'][0])
+                self._rfc_timeseries_file= values['rfc_timeseries_file'][0]
+
 
     def run(self, values: dict,):
         """
diff --git a/src/troute-network/troute/AbstractNetwork.py b/src/troute-network/troute/AbstractNetwork.py
index 3c9bcc7fd..b8f552abf 100644
--- a/src/troute-network/troute/AbstractNetwork.py
+++ b/src/troute-network/troute/AbstractNetwork.py
@@ -27,6 +27,7 @@ class AbstractNetwork(ABC):
                 "_waterbody_types_df", "_waterbody_type_specified", "_link_gage_df",
                 "_independent_networks", "_reaches_by_tw", "_flowpath_dict",
                 "_reverse_network", "_q0", "_t0", "_link_lake_crosswalk",
+                "_usgs_lake_gage_crosswalk", "_usace_lake_gage_crosswalk",
                 "_qlateral", "_break_segments", "_segment_index", "_coastal_boundary_depth_df",
                 "supernetwork_parameters", "waterbody_parameters","data_assimilation_parameters",
                 "restart_parameters", "compute_parameters", "forcing_parameters",
@@ -65,7 +66,7 @@ def __init__(self,):
         if self.break_points["break_network_at_waterbodies"]:
             self._break_segments = self._break_segments | set(self.waterbody_connections.values())
         if self.break_points["break_network_at_gages"]:
-            self._break_segments = self._break_segments | set(self.gages.get('gages').keys())
+            self._break_segments = self._break_segments | set(self.gages.get('gages',{}).keys())
         
         self.initialize_routing_scheme()
 
@@ -326,6 +327,14 @@ def link_gage_df(self):
             self._link_gage_df.index.name = 'link'
         return self._link_gage_df
 
+    @property
+    def usgs_lake_gage_crosswalk(self):
+        return self._usgs_lake_gage_crosswalk
+
+    @property
+    def usace_lake_gage_crosswalk(self):
+        return self._usace_lake_gage_crosswalk
+
     @property
     @abstractmethod
     def waterbody_connections(self):
@@ -577,9 +586,12 @@ def initial_warmstate_preprocess(self,):
                     len(waterbodies_initial_states_df)
                 )
 
-            self._waterbody_df = pd.merge(
-                self.waterbody_dataframe, waterbodies_initial_states_df, on=index_id
-            )
+            if index_id in self.waterbody_dataframe and index_id in waterbodies_initial_states_df:
+                self._waterbody_df = pd.merge(
+                    self.waterbody_dataframe, waterbodies_initial_states_df, on=index_id
+                )
+            else:
+                self._waterbody_df=pd.DataFrame()
 
             LOG.debug(
                 "waterbody initial states complete in %s seconds."\
diff --git a/src/troute-network/troute/DataAssimilation.py b/src/troute-network/troute/DataAssimilation.py
index 8d28da4e7..99a1c0c08 100644
--- a/src/troute-network/troute/DataAssimilation.py
+++ b/src/troute-network/troute/DataAssimilation.py
@@ -5,6 +5,9 @@
 import xarray as xr
 from datetime import datetime
 from abc import ABC
+from joblib import delayed, Parallel
+
+from troute.routing.fast_reach.reservoir_RFC_da import _validate_RFC_data
 
 
 # -----------------------------------------------------------------------------
@@ -58,12 +61,36 @@ def __init__(self, network, from_files, value_dict, da_run=[]):
         self._last_obs_df = pd.DataFrame()
         self._usgs_df = pd.DataFrame()
 
+        from_files = False
         # If streamflow nudging is turned on, create lastobs_df and usgs_df:
         if nudging:
-            if not from_files:
-                self._usgs_df = pd.DataFrame(index=value_dict['usgs_gage_ids'])
-                self._last_obs_df = pd.DataFrame(index=value_dict['lastobs_ids'])
-            
+            if not from_files and not network.link_gage_df.empty:
+                #self._usgs_df = pd.DataFrame(index=value_dict['usgs_gage_ids'])
+                #self._last_obs_df = pd.DataFrame(index=value_dict['lastobs_ids'])
+                
+                # Handle QC/QA and interpolation:
+                qc_threshold = data_assimilation_parameters.get("qc_threshold",1)
+
+                self._usgs_df = _timeslice_qcqa(
+                                                value_dict['usgs_timeslice_discharge'],
+                                                value_dict['usgs_timeslice_stationId'],
+                                                value_dict['usgs_timeslice_time'],
+                                                value_dict['usgs_timeslice_discharge_quality'],
+                                                qc_threshold,
+                                                run_parameters.get('dt', 300),
+                                                network.link_gage_df
+                                                )
+
+                self._last_obs_df = _assemble_lastobs_df(
+                                                        value_dict['lastobs_discharge'], 
+                                                        value_dict['lastobs_stationIdInd'], 
+                                                        value_dict['lastobs_timeInd'], 
+                                                        value_dict['lastobs_stationId'], 
+                                                        value_dict['lastobs_time'], 
+                                                        value_dict['lastobs_modelTimeAtOutput'][0], 
+                                                        value_dict['time_since_lastobs'],
+                                                        network.link_gage_df
+                                                        )            
             else:
                 lastobs_file = streamflow_da_parameters.get("wrf_hydro_lastobs_file", None)
                 lastobs_crosswalk_file = streamflow_da_parameters.get("gage_segID_crosswalk_file", None)
@@ -71,20 +98,21 @@ def __init__(self, network, from_files, value_dict, da_run=[]):
                 
                 if lastobs_file:
                     self._last_obs_df = build_lastobs_df(
-                        lastobs_file,
-                        lastobs_crosswalk_file,
-                        lastobs_start,
-                    )
+                                                        lastobs_file,
+                                                        lastobs_crosswalk_file,
+                                                        lastobs_start,
+                                                        )
                 
                 # replace link ids with lake ids, for gages at waterbody outlets, 
                 # otherwise, gage data will not be assimilated at waterbody outlet
                 # segments.
                 if network.link_lake_crosswalk:
                     self._last_obs_df = _reindex_link_to_lake_id(self._last_obs_df, network.link_lake_crosswalk)
-                
-                self._usgs_df = _create_usgs_df(data_assimilation_parameters, streamflow_da_parameters, run_parameters, network, da_run)
+                if not network.link_gage_df.empty:
+                    self._usgs_df = _create_usgs_df(data_assimilation_parameters, streamflow_da_parameters, run_parameters, network, da_run)
     
-    def update_after_compute(self, run_results,):
+    def update_after_compute(self, run_results, time_increment):
+    #def update_after_compute(self, run_results, ):
         '''
         Function to update data assimilation object after running routing module.
         
@@ -112,7 +140,8 @@ def update_after_compute(self, run_results,):
 
         if streamflow_da_parameters:
             if streamflow_da_parameters.get('streamflow_nudging', False):
-                self._last_obs_df = new_lastobs(run_results, self._run_parameters.get("dt") * self._run_parameters.get("nts"))
+                #self._last_obs_df = new_lastobs(run_results, self._run_parameters.get("dt") * self._run_parameters.get("nts"))
+                self._last_obs_df = new_lastobs(run_results, time_increment)               
 
     def update_for_next_loop(self, network, da_run,):
         '''
@@ -137,8 +166,10 @@ def update_for_next_loop(self, network, da_run,):
         streamflow_da_parameters = data_assimilation_parameters.get('streamflow_da', None)
         
         if streamflow_da_parameters.get('streamflow_nudging', False):
-            self._usgs_df = _create_usgs_df(data_assimilation_parameters, streamflow_da_parameters, run_parameters, network, da_run)
-            
+            if not network.link_gage_df.empty:
+                self._usgs_df = _create_usgs_df(data_assimilation_parameters, streamflow_da_parameters, run_parameters, network, da_run)
+            else:
+                self._usgs_df = pd.DataFrame()
 
 class PersistenceDA(AbstractDA):
     """
@@ -170,12 +201,42 @@ def __init__(self, network, from_files, value_dict, da_run=[]):
 
         if not from_files:
             if usgs_persistence:
-                reservoir_usgs_df = pd.DataFrame(index=value_dict['reservoir_usgs_ids'])
-                # create reservoir hybrid DA initial parameters dataframe    
+                # if usgs_df is already created, make reservoir_usgs_df from that rather than reading in data again
+                if self._usgs_df.empty:
+
+                    qc_threshold = data_assimilation_parameters.get("qc_threshold",1)
+
+                    self._usgs_df = _timeslice_qcqa(
+                        value_dict['timeslice_discharge'],
+                        value_dict['timeslice_stationId'],
+                        value_dict['timeslice_time'],
+                        value_dict['timeslice_discharge_quality'],
+                        qc_threshold,
+                        run_parameters.get('dt', 300),
+                        network.link_gage_df) 
+                    
+                # resample `usgs_df` to 15 minute intervals
+                usgs_df_15min = (
+                    self._usgs_df.
+                    transpose().
+                    resample('15min').asfreq().
+                    transpose()
+                )
+
+                # subset and usgs_df to reservoir only locations
+                #FIXME: This is assuming all waterbodies are USGS (no USACE). Is this the 
+                #case for HYFeatures?
+                reservoir_usgs_df = (
+                    usgs_df_15min.
+                    join(network.waterbody_dataframe['index'], how='inner').
+                    drop(['index'],axis=1)
+                )
+                
+                # create reservoir persistence DA initial parameters dataframe    
                 if not reservoir_usgs_df.empty:
                     reservoir_usgs_param_df = pd.DataFrame(
                         data = 0, 
-                        index = reservoir_usgs_df.index,
+                        index = reservoir_usgs_df.index ,
                         columns = ['update_time']
                     )
                     reservoir_usgs_param_df['prev_persisted_outflow'] = np.nan
@@ -183,7 +244,7 @@ def __init__(self, network, from_files, value_dict, da_run=[]):
                     reservoir_usgs_param_df['persistence_index'] = 0
                 else:
                     reservoir_usgs_param_df = pd.DataFrame()
-            
+
             if usace_persistence:
                 reservoir_usace_df = pd.DataFrame(index=value_dict['reservoir_usace_ids'])
                 # create reservoir hybrid DA initial parameters dataframe    
@@ -298,7 +359,7 @@ def __init__(self, network, from_files, value_dict, da_run=[]):
         # if the first column is some timestamp greater than t0, then this will throw
         # an error. Need to think through this more. 
         if not self._usgs_df.empty:
-            self._usgs_df = self._usgs_df.loc[:,network.t0:]
+            self._usgs_df = self._usgs_df.loc[:,network.t0.strftime('%Y-%m-%d %H:%M:%S'):]
     
     def update_after_compute(self, run_results,):
         '''
@@ -455,9 +516,33 @@ class RFCDA(AbstractDA):
     """
     
     """
-    def __init__(self, from_files, value_dict):
-        if from_files:
-            pass
+    def __init__(self, network, from_files, value_dict):
+        waterbody_parameters = self._waterbody_parameters
+        rfc_parameters = waterbody_parameters.get('rfc', None)
+
+        # check if user explictly requests RFC reservoir DA
+        rfc  = False
+        if rfc_parameters:
+            rfc = rfc_parameters.get('reservoir_rfc_forecasts', False)
+
+        if not from_files:
+            if rfc:
+                (
+                self._reservoir_rfc_df,
+                self._reservoir_rfc_param_df
+                ) = _rfc_timeseries_qcqa(
+                                        value_dict['rfc_discharges'],
+                                        value_dict['rfc_stationId'],
+                                        value_dict['rfc_synthetic_values'],
+                                        value_dict['rfc_totalCounts'],
+                                        value_dict['rfc_datetime'],
+                                        value_dict['rfc_timestep'],
+                                        1, #lake_number
+                                        network.t0
+                                        ) 
+            else: 
+                self._reservoir_rfc_df = pd.DataFrame()
+                self._reservoir_rfc_param_df = pd.DataFrame()
         else:
             pass
 
@@ -487,13 +572,13 @@ def __init__(self, network, data_assimilation_parameters, run_parameters, waterb
 
         NudgingDA.__init__(self, network, from_files, value_dict, da_run)
         PersistenceDA.__init__(self, network, from_files, value_dict, da_run)
-        RFCDA.__init__(self, from_files, value_dict)
-    
-    def update_after_compute(self, run_results,):
+        RFCDA.__init__(self, network, from_files, value_dict)
+
+    def update_after_compute(self, run_results,time_increment):
         '''
         
         '''
-        NudgingDA.update_after_compute(self, run_results)
+        NudgingDA.update_after_compute(self, run_results, time_increment)
         PersistenceDA.update_after_compute(self, run_results)
         RFCDA.update_after_compute(self)
 
@@ -604,12 +689,12 @@ def _create_usgs_df(data_assimilation_parameters, streamflow_da_parameters, run_
     da_decay_coefficient   = data_assimilation_parameters.get("da_decay_coefficient",120)
     qc_threshold           = data_assimilation_parameters.get("qc_threshold",1)
     interpolation_limit    = data_assimilation_parameters.get("interpolation_limit_min",59)
-    
+
     # TODO: join timeslice folder and files into complete path upstream
     usgs_timeslices_folder = pathlib.Path(usgs_timeslices_folder)
     usgs_files = [usgs_timeslices_folder.joinpath(f) for f in 
                   da_run['usgs_timeslice_files']]
-	
+
     if usgs_files:
         usgs_df = (
             nhd_io.get_obs_from_timeslices(
@@ -1000,3 +1085,287 @@ def read_reservoir_parameter_file(
     
     return df1, usgs_crosswalk, usace_crosswalk
 
+def _timeslice_qcqa(discharge, 
+                    stns, 
+                    t, 
+                    qual, 
+                    qc_threshold, 
+                    frequency_secs, 
+                    crosswalk_df, 
+                    crosswalk_gage_field='gages',
+                    crosswalk_dest_field='link',
+                    interpolation_limit=59,
+                    cpu_pool=1):
+    #FIXME Do we need the following commands? Or something similar? Depends on 
+    # what format model engine provides these variables...
+    '''
+    stationId = np.apply_along_axis(''.join, 1, stns.astype(np.str))
+    time_str = np.apply_along_axis(''.join, 1, t.astype(np.str))
+    stationId = np.char.strip(stationId)
+    '''
+    stationId = stns
+    time_str = t
+    observation_df = (pd.DataFrame({
+                                'stationId' : stationId,
+                                'datetime'  : time_str,
+                                'discharge' : discharge
+                            }).
+                             set_index(['stationId', 'datetime']).
+                             unstack(1, fill_value = np.nan)['discharge'])
+    
+    observation_qual_df = (pd.DataFrame({
+                                'stationId' : stationId,
+                                'datetime'  : time_str,
+                                'quality'   : qual/100
+                            }).
+                             set_index(['stationId', 'datetime']).
+                             unstack(1, fill_value = np.nan)['quality'])
+
+    # Link <> gage crosswalk data
+    df = crosswalk_df.reset_index()
+    df[crosswalk_gage_field] = np.asarray(df[crosswalk_gage_field]).astype('<U15')
+    df = df.set_index(crosswalk_gage_field)
+    
+    # join crosswalk data with timeslice data, indexed on crosswalk destination field
+    observation_df = (df.join(observation_df).
+               reset_index().
+               set_index(crosswalk_dest_field).
+               drop([crosswalk_gage_field], axis=1))
+
+    observation_qual_df = (df.join(observation_qual_df).
+               reset_index().
+               set_index(crosswalk_dest_field).
+               drop([crosswalk_gage_field], axis=1))
+    
+    #Check if QC is already performed from model_DAforcing.py
+    t1 = observation_df.iloc[:,0].name
+    t1 = datetime.strptime(t1, "%Y-%m-%d %H:%M:%S")
+    t2 = observation_df.iloc[:,1].name
+    t2 = datetime.strptime(t2, "%Y-%m-%d %H:%M:%S")
+    dt= (t2 - t1).seconds
+
+    #when DAforcing module is used, it already completed QC and resampling. 
+    #So, no need to do them again.
+    if not dt==frequency_secs or not np.all(qual==100):
+        # ---- Laugh testing ------
+        # screen-out erroneous qc flags
+        observation_qual_df = (observation_qual_df.
+                            mask(observation_qual_df < 0, np.nan).
+                            mask(observation_qual_df > 1, np.nan)
+                            )
+
+        # screen-out poor quality flow observations
+        observation_df = (observation_df.
+                        mask(observation_qual_df < qc_threshold, np.nan).
+                        mask(observation_df <= 0, np.nan)
+                        )
+
+        # ---- Interpolate USGS observations to the input frequency (frequency_secs)
+        observation_df_T = observation_df.transpose()             # transpose, making time the index
+        observation_df_T.index = pd.to_datetime(
+            observation_df_T.index, format = "%Y-%m-%d_%H:%M:%S"  # index variable as type datetime
+        )
+        
+        # specify resampling frequency 
+        frequency = str(int(frequency_secs/60))+"min"    
+        
+        # interpolate and resample frequency
+        buffer_df = observation_df_T.resample(frequency).asfreq()
+        with Parallel(n_jobs=cpu_pool) as parallel:
+            
+            jobs = []
+            interp_chunks = ()
+            step = 200
+            for a, i in enumerate(range(0, len(observation_df_T.columns), step)):
+                
+                start = i
+                if (i+step-1) < buffer_df.shape[1]:
+                    stop = i+(step)
+                else:
+                    stop = buffer_df.shape[1]
+                    
+                jobs.append(
+                    delayed(_interpolate_one)(observation_df_T.iloc[:,start:stop], interpolation_limit, frequency)
+                )
+                
+            interp_chunks = parallel(jobs)
+
+        observation_df_T = pd.DataFrame(
+            data = np.concatenate(interp_chunks, axis = 1), 
+            columns = buffer_df.columns, 
+            index = buffer_df.index
+        )
+        
+        # re-transpose, making link the index
+        observation_df_new = observation_df_T.transpose().loc[crosswalk_df.index]
+        observation_df_new.index = observation_df_new.index.astype('int64')
+    else:
+        observation_df_new = observation_df
+
+    return observation_df_new
+
+def _interpolate_one(df, interpolation_limit, frequency):
+    
+    interp_out = (df.resample('min').
+                    interpolate(
+                                limit = interpolation_limit, 
+                                limit_direction = 'both'
+                                ).
+                                resample(frequency).
+                                asfreq().
+                                to_numpy()
+                )
+    return interp_out
+
+def _assemble_lastobs_df(
+                        discharge, 
+                        stationIdInd, 
+                        timeInd, 
+                        stationId, 
+                        time, 
+                        modelTimeAtOutput, 
+                        time_since_lastobs,
+                        gage_link_df, 
+                        time_shift=0):
+
+    if not np.all(timeInd==0) or not np.all(time==''):    
+        #Use arrays not directly from DAfocing module
+        gages    = np.char.strip(stationId)
+            
+        ref_time = datetime.strptime(modelTimeAtOutput, "%Y-%m-%d_%H:%M:%S")
+        
+        last_ts = timeInd.max()
+        
+        df_discharge = (
+            pd.DataFrame(
+            data = {
+                'discharge': discharge,
+                'stationIdInd': stationIdInd,
+                'timeInd': timeInd
+                }).
+                set_index(['stationIdInd','timeInd']).
+                unstack(level=0)
+        )
+
+        df_time = (
+            pd.DataFrame(
+            data = {
+                'discharge': time,
+                'stationIdInd': stationIdInd,
+                'timeInd': timeInd
+                }).
+                set_index(['stationIdInd','timeInd']).
+                unstack(level=1)
+        ).to_numpy()
+        
+        last_obs_index = (
+            df_discharge.
+            apply(pd.Series.last_valid_index).                   # index of last non-nan value, each gage
+            to_numpy()                                           # to numpy array
+        )
+        last_obs_index = np.nan_to_num(last_obs_index, nan = last_ts).astype(int)
+                        
+        last_observations = []
+        lastobs_times     = []
+        for i, idx in enumerate(last_obs_index):
+            last_observations.append(df_discharge.iloc[idx,i])
+            lastobs_times.append(df_time[i, idx]) #.decode('utf-8')  <- TODO:decoding was needed in old version, may need again depending on dtype that is provided by model engine
+            
+        last_observations = np.array(last_observations)
+        lastobs_times     = pd.to_datetime(
+            np.array(lastobs_times), 
+            format="%Y-%m-%d_%H:%M:%S", 
+            errors = 'coerce'
+        )
+
+        lastobs_times = (lastobs_times - ref_time).total_seconds()
+        lastobs_times = lastobs_times - time_shift
+
+        data_var_dict = {
+            'gages'               : gages,
+            'time_since_lastobs'  : lastobs_times,
+            'lastobs_discharge'   : last_observations
+        }
+    else:
+        #Use arrays from DAforcing module
+        #converts bytes format to regular strings
+        stationId = [item.decode('utf-8') for item in stationId]
+        data_var_dict = {
+            'gages'               : stationId,
+            'time_since_lastobs'  : time_since_lastobs,
+            'lastobs_discharge'   : discharge
+
+        }
+
+    lastobs_df = (
+        pd.DataFrame(data = data_var_dict).
+        set_index('gages').
+        join(gage_link_df.reset_index().set_index('gages'), how = 'inner').
+        reset_index().
+        set_index('link')
+    )
+
+    lastobs_df = lastobs_df[
+        [
+            'gages',
+            'time_since_lastobs',
+            'lastobs_discharge',
+        ]
+    ]
+
+    lastobs_df.index = lastobs_df.index.astype('int64')
+    return lastobs_df
+
+def _rfc_timeseries_qcqa(discharge,stationId,synthetic,totalCounts,timestamp,timestep,lake_number,t0):
+    rfc_df = pd.DataFrame(
+        {'stationId': stationId,
+         'datetime': timestamp,
+         'discharge': discharge,
+         'synthetic': synthetic
+         }
+    )
+    rfc_df['stationId'] = rfc_df['stationId'].map(bytes.strip)
+
+    validation_df = rfc_df.groupby('stationId').agg(list)
+    validation_index = validation_df.index
+    use_rfc_df = pd.DataFrame()
+    for i in validation_index:
+        val_lake_number = lake_number #TODO: placeholder, figure out how to get lake number here...
+        val_discharge = validation_df.loc[i].discharge
+        val_synthetic = validation_df.loc[i].synthetic
+        
+        use_rfc = _validate_RFC_data(
+            val_lake_number, 
+            val_discharge, 
+            val_synthetic, 
+            '', 
+            '', 
+            300,
+            from_files=False
+            )
+        
+        use_rfc_df = pd.concat([
+            use_rfc_df,
+            pd.DataFrame({
+                'stationId': [i],
+                'use_rfc': use_rfc
+            })
+        ], ignore_index=True)
+        
+    rfc_df = (rfc_df.
+              set_index(['stationId', 'datetime']).
+              unstack(1, fill_value = np.nan)['discharge'])
+    
+    rfc_param_df = (pd.merge(
+        pd.DataFrame(
+        {'stationId': stationId,
+         'idx': rfc_df.columns.get_loc(t0),
+         'da_timestep': timestep,
+         'totalCounts': totalCounts,
+         'update_time': 0,
+         }
+    ).drop_duplicates(),
+    use_rfc_df, on='stationId').
+    set_index('stationId'))
+
+    return rfc_df, rfc_param_df
\ No newline at end of file
diff --git a/src/troute-network/troute/HYFeaturesNetwork.py b/src/troute-network/troute/HYFeaturesNetwork.py
index 47d4bdb19..ee40e18ac 100644
--- a/src/troute-network/troute/HYFeaturesNetwork.py
+++ b/src/troute-network/troute/HYFeaturesNetwork.py
@@ -6,20 +6,55 @@
 import json
 from pathlib import Path
 import pyarrow.parquet as pq
+from itertools import chain
+from joblib import delayed, Parallel
+from collections import defaultdict
 
 import troute.nhd_io as nhd_io #FIXME
-from troute.nhd_network import reverse_dict, extract_connections
+from troute.nhd_network import reverse_dict, extract_connections, reverse_network, reachable
 
 __verbose__ = False
 __showtiming__ = False
 
-def read_geopkg(file_path):
-    flowpaths = gpd.read_file(file_path, layer="flowpaths")
-    attributes = gpd.read_file(file_path, layer="flowpath_attributes").drop('geometry', axis=1)
-    #merge all relevant data into a single dataframe
-    flowpaths = pd.merge(flowpaths, attributes, on='id')
+def read_geopkg(file_path, data_assimilation_parameters, waterbody_parameters):
+    # Establish which layers we will read. We'll always need the flowpath tables
+    layers = ['flowpaths','flowpath_attributes']
+
+    # If waterbodies are being simulated, read lakes table
+    if waterbody_parameters.get('break_network_at_waterbodies',False):
+        layers.append('lakes')
+
+    # If any DA is activated, read network table as well for gage information
+    streamflow_nudging = data_assimilation_parameters.get('streamflow_da',{}).get('streamflow_nudging',False)
+    usgs_da = data_assimilation_parameters.get('reservoir_da',{}).get('reservoir_persistence_usgs',False)
+    usace_da = data_assimilation_parameters.get('reservoir_da',{}).get('reservoir_persistence_usace',False)
+    rfc_da = waterbody_parameters.get('rfc',{}).get('reservoir_rfc_forecasts',False)
+    if any([streamflow_nudging, usgs_da, usace_da, rfc_da]):
+        layers.append('network')
+    
+    # Retrieve geopackage information:
+    with Parallel(n_jobs=len(layers)) as parallel:
+        jobs = []
+        for layer in layers:
+            jobs.append(
+                delayed(gpd.read_file)
+                #(f, qlat_file_value_col, gw_bucket_col, terrain_ro_col)
+                #delayed(nhd_io.get_ql_from_csv)
+                (filename=file_path, layer=layer)                    
+            )
+        gpkg_list = parallel(jobs)
+    table_dict = {layers[i]: gpkg_list[i] for i in range(len(layers))}
+    flowpaths = pd.merge(table_dict.get('flowpaths'), table_dict.get('flowpath_attributes'), on='id')
+    lakes = table_dict.get('lakes', pd.DataFrame())
+    network = table_dict.get('network', pd.DataFrame())
 
-    return flowpaths
+    '''
+    flowpaths = gpd.read_file(file_path, layer='flowpaths')
+    flowpath_attributes = gpd.read_file(file_path, layer='flowpath_attributes')
+    flowpaths = pd.merge(flowpaths, flowpath_attributes, on='id')
+    '''
+
+    return flowpaths, lakes, network
 
 def read_json(file_path, edge_list):
     dfs = []
@@ -42,8 +77,8 @@ def read_json(file_path, edge_list):
 def numeric_id(flowpath):
     id = flowpath['id'].split('-')[-1]
     toid = flowpath['toid'].split('-')[-1]
-    flowpath['id'] = int(id)
-    flowpath['toid'] = int(toid)
+    flowpath['id'] = int(float(id))
+    flowpath['toid'] = int(float(toid))
     return flowpath
 
 def read_ngen_waterbody_df(parm_file, lake_index_field="wb-id", lake_id_mask=None):
@@ -54,13 +89,20 @@ def read_ngen_waterbody_df(parm_file, lake_index_field="wb-id", lake_id_mask=Non
     """
     def node_key_func(x):
         return int( x.split('-')[-1] )
+    
     if Path(parm_file).suffix=='.gpkg':
-        df = gpd.read_file(parm_file, layer="lake_attributes").set_index('id')
+        df = gpd.read_file(parm_file, layer='lakes')
+
+        df = (
+            df.drop(['id','toid','hl_id','hl_reference','hl_uri','geometry'], axis=1)
+            .rename(columns={'hl_link': 'lake_id'})
+            )
+        df['lake_id'] = df.lake_id.astype(float).astype(int)
+        df = df.set_index('lake_id').drop_duplicates().sort_index()
     elif Path(parm_file).suffix=='.json':
         df = pd.read_json(parm_file, orient="index")
-
-    df.index = df.index.map(node_key_func)
-    df.index.name = lake_index_field
+        df.index = df.index.map(node_key_func)
+        df.index.name = lake_index_field
 
     if lake_id_mask:
         df = df.loc[lake_id_mask]
@@ -88,6 +130,57 @@ def node_key_func(x):
         
     return df
 
+def read_geo_file(supernetwork_parameters, waterbody_parameters, data_assimilation_parameters):
+        
+    geo_file_path = supernetwork_parameters["geo_file_path"]
+    
+    file_type = Path(geo_file_path).suffix
+    if(  file_type == '.gpkg' ):        
+        flowpaths, lakes, network = read_geopkg(geo_file_path, 
+                                                data_assimilation_parameters,
+                                                waterbody_parameters)
+        #TODO Do we need to keep .json as an option?
+        '''
+        elif( file_type == '.json') :
+            edge_list = supernetwork_parameters['flowpath_edge_list']
+            self._dataframe = read_json(geo_file_path, edge_list) 
+        '''
+    else:
+        raise RuntimeError("Unsupported file type: {}".format(file_type))
+    
+    return flowpaths, lakes, network
+
+def load_bmi_data(value_dict, bmi_parameters,): 
+    # Get the column names that we need from each table of the geopackage
+    flowpath_columns = bmi_parameters.get('flowpath_columns')
+    attributes_columns = bmi_parameters.get('attributes_columns')
+    lakes_columns = bmi_parameters.get('waterbody_columns')
+    network_columns = bmi_parameters.get('network_columns')
+
+    # Create dataframes with the relevent columns
+    flowpaths = pd.DataFrame(data=None, columns=flowpath_columns)
+    for col in flowpath_columns:
+        flowpaths[col] = value_dict[col]
+
+    flowpath_attributes = pd.DataFrame(data=None, columns=attributes_columns)
+    for col in attributes_columns:
+        flowpath_attributes[col] = value_dict[col]
+    flowpath_attributes = flowpath_attributes.rename(columns={'attributes_id': 'id'})
+
+    lakes = pd.DataFrame(data=None, columns=lakes_columns)
+    for col in lakes_columns:
+        lakes[col] = value_dict[col]
+
+    network = pd.DataFrame(data=None, columns=network_columns)
+    for col in network_columns:
+        network[col] = value_dict[col]
+    network = network.rename(columns={'network_id': 'id'})
+
+    # Merge the two flowpath tables into one
+    flowpaths = pd.merge(flowpaths, flowpath_attributes, on='id')
+
+    return flowpaths, lakes, network
+
 
 class HYFeaturesNetwork(AbstractNetwork):
     """
@@ -107,8 +200,7 @@ def __init__(self,
                  showtiming=False,
                  from_files=True,
                  value_dict={},
-                 segment_attributes=[],
-                 waterbody_attributes=[]):
+                 bmi_parameters={},):
         """
         
         """
@@ -126,22 +218,31 @@ def __init__(self,
             print("creating supernetwork connections set")
         if self.showtiming:
             start_time = time.time()
-        
+
         #------------------------------------------------
-        # Load Geo File
+        # Load hydrofabric information
         #------------------------------------------------
         if from_files:
-            self.read_geo_file()
+            flowpaths, lakes, network = read_geo_file(
+                self.supernetwork_parameters,
+                self.waterbody_parameters,
+                self.data_assimilation_parameters
+            )
         else:
-            self.load_bmi_data(value_dict, segment_attributes, waterbody_attributes)
-        
-        #TODO Update for waterbodies and DA specific to HYFeatures...
-        self._waterbody_connections = {}
-        self._waterbody_type_specified = None
-        self._gages = None
-        self._link_lake_crosswalk = None
+            flowpaths, lakes, network = load_bmi_data(
+                value_dict, 
+                bmi_parameters,
+                )
+
+        # Preprocess network objects
+        self.preprocess_network(flowpaths)
 
+        # Preprocess waterbody objects
+        self.preprocess_waterbodies(lakes)
 
+        # Preprocess data assimilation objects #TODO: Move to DataAssimilation.py?
+        self.preprocess_data_assimilation(network)
+ 
         if self.verbose:
             print("supernetwork connections set complete")
         if self.showtiming:
@@ -149,7 +250,7 @@ def __init__(self,
             
 
         super().__init__()   
-            
+
         # Create empty dataframe for coastal_boundary_depth_df. This way we can check if
         # it exists, and only read in SCHISM data during 'assemble_forcings' if it doesn't
         self._coastal_boundary_depth_df = pd.DataFrame()
@@ -171,63 +272,36 @@ def waterbody_connections(self):
             A dictionary where the keys are the reach/segment id, and the
             value is the id to look up waterbody parameters
         """
-        if( not self._waterbody_connections ):
-            #Funny story, NaN != NaN is true!!!!
-            #Drop the nan, then check for waterbody_null just in case
-            #waterbody_null happens to be NaN
-            #FIXME this drops ALL nan, not just `waterbody`
-            #waterbody_segments = self._dataframe.dropna().loc[
-            #    self._dataframe["waterbody"] != self.waterbody_null, "waterbody"
-            #]
-            #waterbody_segments = waterbody_segments.loc[self.waterbody_dataframe.index]
-            #self._waterbody_connections = waterbody_segments.index\
-            #    .to_series(name = waterbody_segments.name)\
-            #    .astype("int")\
-            #    .to_dict()
-            #If we identify as a waterbody, drop from the main dataframe
-            #Ugh, but this drops everything that that MIGHT be a "lake"
-            #without knowing if it was defined as a lake in the lake params
-            #so this should just drop the waterbody_df index, not these segments...
-            #In fact, these waterbody connections should probably be entirely reworked
-            #with that in mind...
-            self._waterbody_connections = self._waterbody_df.index.to_series(name = self._waterbody_df.index.name).astype("int").to_dict()
-            #FIXME seems way more appropriate to do this in the constructor so the property doesn't side effect
-            #the param df..., but then it breaks down the connection property...so for now, leave it here and fix later
-            self._dataframe.drop(self._waterbody_df.index, axis=0, inplace=True)
         return self._waterbody_connections
-
+    
     @property
     def gages(self):
         """
         FIXME
         """
-        if self._gages is None and "gages" in self._dataframe.columns:
-            self._gages = nhd_io.build_filtered_gage_df(self._dataframe[["gages"]])
-        else:
-            self._gages = {}
         return self._gages
     
     @property
     def waterbody_null(self):
         return np.nan #pd.NA
     
-    def read_geo_file(self,):
-        
-        geo_file_path = self.supernetwork_parameters["geo_file_path"]
-        
-        file_type = Path(geo_file_path).suffix
-        if(  file_type == '.gpkg' ):        
-            self._dataframe = read_geopkg(geo_file_path)
-        elif( file_type == '.json') :
-            edge_list = self.supernetwork_parameters['flowpath_edge_list']
-            self._dataframe = read_json(geo_file_path, edge_list) 
-        else:
-            raise RuntimeError("Unsupported file type: {}".format(file_type))
-        
+    def preprocess_network(self, flowpaths):
+        self._dataframe = flowpaths
+
         # Don't need the string prefix anymore, drop it
         mask = ~ self.dataframe['toid'].str.startswith("tnex") 
         self._dataframe = self.dataframe.apply(numeric_id, axis=1)
         
+        # handle segment IDs that are also waterbody IDs. The fix here adds a large value
+        # to the segmetn IDs, creating new, unique IDs. Otherwise our connections dictionary
+        # will get confused because there will be repeat IDs...
+        duplicate_wb_segments = self.supernetwork_parameters.get("duplicate_wb_segments", None)
+        duplicate_wb_id_offset = self.supernetwork_parameters.get("duplicate_wb_id_offset", 9.99e11)
+        if duplicate_wb_segments:
+            # update the values of the duplicate segment IDs
+            fix_idx = self.dataframe.id.isin(set(duplicate_wb_segments))
+            self._dataframe.loc[fix_idx,"id"] = (self.dataframe[fix_idx].id + duplicate_wb_id_offset).astype("int64")
+
         # make the flowpath linkage, ignore the terminal nexus
         self._flowpath_dict = dict(zip(self.dataframe.loc[mask].toid, self.dataframe.loc[mask].id))
         
@@ -287,115 +361,137 @@ def read_geo_file(self,):
             self.dataframe, "downstream", terminal_codes=self.terminal_codes
         )
 
-        #Load waterbody/reservoir info
-        if self.waterbody_parameters:
-            levelpool_params = self.waterbody_parameters.get('level_pool', None)
-            if not levelpool_params:
-                # FIXME should not be a hard requirement
-                raise(RuntimeError("No supplied levelpool parameters in routing config"))
-                
-            lake_id = levelpool_params.get("level_pool_waterbody_id", "wb-id")
-            try:
-                self._waterbody_df = read_ngen_waterbody_df(
-                            levelpool_params["level_pool_waterbody_parameter_file_path"],
-                            lake_id,
-                            )
-                    
-                # Remove duplicate lake_ids and rows
-                self._waterbody_df = (
-                                self.waterbody_dataframe.reset_index()
-                                .drop_duplicates(subset=lake_id)
-                                .set_index(lake_id)
-                                .sort_index()
-                                )
-            except ValueError:
-                self._waterbody_df = pd.DataFrame()
-
-            try:
-                self._waterbody_types_df = read_ngen_waterbody_type_df(
-                                        levelpool_params["reservoir_parameter_file"],
-                                        lake_id,
-                                        #self.waterbody_connections.values(),
-                                        )
-                # Remove duplicate lake_ids and rows
-                self._waterbody_types_df =(
-                                    self.waterbody_types_dataframe.reset_index()
-                                    .drop_duplicates(subset=lake_id)
-                                    .set_index(lake_id)
-                                    .sort_index()
-                                    )
-
-            except ValueError:
-                #FIXME any reservoir operations requires some type
-                #So make this default to 1 (levelpool)
-                self._waterbody_types_df = pd.DataFrame(index=self.waterbody_dataframe.index)
-                self._waterbody_types_df['reservoir_type'] = 1
+    def preprocess_waterbodies(self, lakes):
+        # If waterbodies are being simulated, create waterbody dataframes and dictionaries
+        if not lakes.empty:
+            self._waterbody_df = (
+                lakes[['hl_link','ifd','LkArea','LkMxE','OrificeA',
+                       'OrificeC','OrificeE','WeirC','WeirE','WeirL']]
+                .rename(columns={'hl_link': 'lake_id'})
+                )
+            self._waterbody_df['lake_id'] = self.waterbody_dataframe.lake_id.astype(float).astype(int)
+            self._waterbody_df = self.waterbody_dataframe.set_index('lake_id').drop_duplicates().sort_index()
+            
+            # Create wbody_conn dictionary:
+            #FIXME temp solution for missing waterbody info in hydrofabric
+            self.bandaid()
+            
+            wbody_conn = self.dataframe[['waterbody']].dropna()
+            wbody_conn = (
+                wbody_conn['waterbody']
+                .str.split(',',expand=True)
+                .reset_index()
+                .melt(id_vars='key')
+                .drop('variable', axis=1)
+                .dropna()
+                .astype(int)
+                )
+            
+            self._waterbody_connections = (
+                wbody_conn[wbody_conn['value'].isin(self.waterbody_dataframe.index)]
+                .set_index('key')['value']
+                .to_dict()
+                )
+            
+            self._dataframe = self.dataframe.drop('waterbody', axis=1)
+
+            # if waterbodies are being simulated, adjust the connections graph so that 
+            # waterbodies are collapsed to single nodes. Also, build a mapping between 
+            # waterbody outlet segments and lake ids
+            break_network_at_waterbodies = self.waterbody_parameters.get("break_network_at_waterbodies", False)
+            if break_network_at_waterbodies:
+                self._connections, self._link_lake_crosswalk = replace_waterbodies_connections(
+                    self.connections, self.waterbody_connections
+                )
+            else:
+                self._link_lake_crosswalk = None
+            
+            self._waterbody_types_df = pd.DataFrame(
+                data = 1, 
+                index = self.waterbody_dataframe.index, 
+                columns = ['reservoir_type']).sort_index()
+            
+            self._waterbody_type_specified = True
+            
         else:
             self._waterbody_df = pd.DataFrame()
             self._waterbody_types_df = pd.DataFrame()
-    
-    def load_bmi_data(self, value_dict, segment_attributes, waterbody_attributes):
-        
-        self._dataframe = pd.DataFrame(data=None, columns=segment_attributes)
-        self._waterbody_df = pd.DataFrame(data=None, columns=waterbody_attributes)
-
-        for var in segment_attributes:
-            self._dataframe[var] = value_dict[var]
-        
-        # make the flowpath linkage, ignore the terminal nexus
-        self._flowpath_dict = dict(zip(self.dataframe.segment_toid, self.dataframe.segment_id))
-        
-        # **********  need to be included in flowpath_attributes  *************
-        self._dataframe['alt'] = 1.0 #FIXME get the right value for this... 
-
-        self._dataframe = self.dataframe.rename(columns={'segment_id': 'key',
-                                                         'segment_toid': 'downstream'})
-        self._dataframe.set_index("key", inplace=True)
-        self._dataframe = self.dataframe.sort_index()
-
-        # numeric code used to indicate network terminal segments
-        terminal_code = self.supernetwork_parameters.get("terminal_code", 0)
+            self._waterbody_connections = {}
+            self._waterbody_type_specified = False
+            self._link_lake_crosswalk = None
+
+    def preprocess_data_assimilation(self, network):
+        if not network.empty and not network.hl_uri.isna().all():
+            gages_df = network[['id','hl_uri','hydroseq']].drop_duplicates()
+            # clear out missing values
+            gages_df = gages_df[~gages_df['hl_uri'].isnull()]
+            gages_df = gages_df[~gages_df['hydroseq'].isnull()]
+            # make 'id' an integer
+            gages_df['id'] = gages_df['id'].str.split('-',expand=True).loc[:,1].astype(float).astype(int)
+            # split the hl_uri column into type and value
+            gages_df[['type','value']] = gages_df.hl_uri.str.split('-',expand=True,n=1)
+            # filter for 'Gages' only
+            gages_df = gages_df[gages_df['type'].isin(['Gages','NID'])]
+            # In the event that a segment contains multiple gages, assign only the furthest 
+            # downstream segment ID to any given gage
+            gages_df = gages_df.sort_values(['value','hydroseq']).groupby('value').last().reset_index()
+            # transform dataframe into a dictionary where key is segment ID and value is gage ID
+            self._gages = gages_df[['id','value']].rename(columns={'value': 'gages'}).set_index('id').to_dict()
+            # Create lake_gage crosswalk dataframes:
+            link_gage_df = (
+                pd.DataFrame.from_dict(self._gages)
+                .reset_index()
+                .rename(columns={'index': 'link'})
+                .set_index('link')
+                )
+            lake_gage_df = (
+                pd.DataFrame(self.waterbody_connections.items(),
+                             columns = ['link', 'lake_id'])
+                             .set_index('link')
+                             .join(link_gage_df)
+                             .reset_index()[['lake_id','gages']]
+                )
+            lake_gage_df = lake_gage_df[~lake_gage_df['gages'].isnull()]
+            #################################
+            #FIXME: temporary solution, this makes sure each lake only has one gage, and that
+            # it is the gage furthest downstream
+            lake_ids = lake_gage_df.lake_id.unique()
+            lake_outflow_gage_ids = []
+
+            for i in lake_ids:
+                temp_df = lake_gage_df[lake_gage_df['lake_id']==i]
+                lake_outflow_gage_ids.append(
+                    gages_df[gages_df['value']
+                             .isin(temp_df.gages)]
+                             .sort_values('hydroseq')
+                             .iloc[-1,:]
+                             .value
+                )
 
-        # There can be an externally determined terminal code -- that's this first value
-        self._terminal_codes = set()
-        self._terminal_codes.add(terminal_code)
-        # ... but there may also be off-domain nodes that are not explicitly identified
-        # but which are terminal (i.e., off-domain) as a result of a mask or some other
-        # an interior domain truncation that results in a
-        # otherwise valid node value being pointed to, but which is masked out or
-        # being intentionally separated into another domain.
-        self._terminal_codes = self.terminal_codes | set(
-            self.dataframe[~self.dataframe["downstream"].isin(self.dataframe.index)]["downstream"].values
-        )
+            lake_gage_df = lake_gage_df[lake_gage_df['gages'].isin(lake_outflow_gage_ids)]
+            #####################################
+            #FIXME: temporary solution, handles USGS and USACE reservoirs. Need to update for
+            # RFC reservoirs...
+            usgs_ind = lake_gage_df.gages.str.isnumeric()
+            self._usgs_lake_gage_crosswalk = (
+                lake_gage_df.loc[usgs_ind].rename(columns={'lake_id': 'usgs_lake_id', 'gages': 'usgs_gage_id'})
+                .set_index('usgs_lake_id')
+                )
+            
+            self._usace_lake_gage_crosswalk =  (
+                lake_gage_df.loc[~usgs_ind].rename(columns={'lake_id': 'usace_lake_id', 'gages': 'usace_gage_id'})
+                .set_index('usace_lake_id')
+                )
 
-        #This is NEARLY redundant to the self.terminal_codes property, but in this case
-        #we actually need the mapping of what is upstream of that terminal node as well.
-        #we also only want terminals that actually exist based on definition, not user input
-        terminal_mask = ~self._dataframe["downstream"].isin(self._dataframe.index)
-        terminal = self._dataframe.loc[ terminal_mask ]["downstream"]
-        self._upstream_terminal = dict()
-        for key, value in terminal.items():
-            self._upstream_terminal.setdefault(value, set()).add(key)
+            if not self._waterbody_types_df.empty:
+                self._waterbody_types_df.loc[self._usgs_lake_gage_crosswalk.index,'reservoir_type'] = 2
+                self._waterbody_types_df.loc[self._usace_lake_gage_crosswalk.index,'reservoir_type'] = 3
 
-        # build connections dictionary
-        self._connections = extract_connections(
-            self.dataframe, "downstream", terminal_codes=self.terminal_codes
-        )
+        else:
+            self._gages = {}
+            self._usgs_lake_gage_crosswalk = pd.DataFrame()
+            self._usgs_lake_gage_crosswalk = pd.DataFrame()
         
-        #Load waterbody/reservoir info
-        if self.waterbody_parameters:
-            for var in waterbody_attributes:
-                self._waterbody_df[var] = value_dict[var]
-
-            self._waterbody_df = self._waterbody_df.rename(columns={'waterbody_id': 'wb-id',
-                                                                    'waterbody_toid': 'toid'})
-            self._waterbody_df.set_index("wb-id", inplace=True)
-            self._waterbody_df = self.waterbody_dataframe.sort_index()
-
-            self._waterbody_types_df = pd.DataFrame(self.waterbody_dataframe['reservoir_type'])
-            self._waterbody_df.drop('reservoir_type', axis=1, inplace=True)
-
-    
     def build_qlateral_array(self, run,):
         
         # TODO: set default/optional arguments
@@ -488,6 +584,19 @@ def build_qlateral_array(self, run,):
 
         self._qlateral = qlats_df
 
+    ######################################################################
+    #FIXME Temporary solution to hydrofabric issues. Fix specific instances here for now...
+    def bandaid(self,):
+        #This chunk assigns lake_ids to segments that reside within the waterbody:
+        self._dataframe.loc[[5548,5551,],'waterbody'] = '5194634'
+        self._dataframe.loc[[5539,5541,5542],'waterbody'] = '5194604'
+        self._dataframe.loc[[2710744,2710746],'waterbody'] = '120051895'
+        self._dataframe.loc[[1536065,1536067],'waterbody'] = '7100709'
+        self._dataframe.loc[[1536104,1536099,1536084,1536094],'waterbody'] = '120052233'
+        self._dataframe.loc[[2711040,2711044,2711047],'waterbody'] = '120052275'
+    #######################################################################
+
+
 def read_file(file_name):
     extension = file_name.suffix
     if extension=='.csv':
@@ -497,3 +606,117 @@ def read_file(file_name):
         df.index.name = None
     
     return df
+
+def tailwaters(N):
+    '''
+    Find network tailwaters
+    
+    Arguments
+    ---------
+    N (dict, int: [int]): Network connections graph
+    
+    Returns
+    -------
+    (iterable): tailwater segments
+    
+    Notes
+    -----
+    - If reverse connections graph is handed as input, then function
+      will return network headwaters.
+      
+    '''
+    tw = chain.from_iterable(N.values()) - N.keys()
+    for m, n in N.items():
+        if not n:
+            tw.add(m)
+    return tw
+
+def reservoir_shore(connections, waterbody_nodes):
+    wbody_set = set(waterbody_nodes)
+    not_in = lambda x: x not in wbody_set
+
+    shore = set()
+    for node in wbody_set:
+        shore.update(filter(not_in, connections[node]))
+    return list(shore)
+
+def reservoir_boundary(connections, waterbodies, n):
+    if n not in waterbodies and n in connections:
+        return any(x in waterbodies for x in connections[n])
+    return False
+
+def reverse_surjective_mapping(d):
+    rd = defaultdict(list)
+    for src, dst in d.items():
+        rd[dst].append(src)
+    rd.default_factory = None
+    return rd
+
+def separate_waterbodies(connections, waterbodies):
+    waterbody_nodes = {}
+    for wb, nodes in reverse_surjective_mapping(waterbodies).items():
+        waterbody_nodes[wb] = net = {}
+        for n in nodes:
+            if n in connections:
+                net[n] = list(filter(waterbodies.__contains__, connections[n]))
+    return waterbody_nodes
+
+def replace_waterbodies_connections(connections, waterbodies):
+    """
+    Use a single node to represent waterbodies. The node id is the
+    waterbody id. Create a cross walk dictionary that relates lake_ids
+    to the terminal segments within the waterbody footprint.
+    
+    Arguments
+    ---------
+    - connections (dict):
+    - waterbodies (dict): dictionary relating segment linkIDs to the
+                          waterbody lake_id that they lie in
+
+    Returns
+    -------
+    - new_conn  (dict): connections dictionary with waterbodies represented by single nodes. 
+                        Waterbody node ids are lake_ids
+    - link_lake (dict): cross walk dictionary where keys area lake_ids and values are lists
+                        of waterbody tailwater nodes (i.e. the nodes connected to the 
+                        waterbody outlet). 
+    """
+    new_conn = {}
+    link_lake = {}
+    waterbody_nets = separate_waterbodies(connections, waterbodies)
+    rconn = reverse_network(connections)
+
+    for n in connections:
+        if n in waterbodies:
+            wbody_code = waterbodies[n]
+            if wbody_code in new_conn:
+                continue
+
+            # get all nodes from waterbody
+            wbody_nodes = [k for k, v in waterbodies.items() if v == wbody_code]
+            outgoing = reservoir_shore(connections, wbody_nodes)
+            new_conn[wbody_code] = outgoing
+            
+            if len(outgoing)>=1:
+                if outgoing[0] in waterbodies:
+                    new_conn[wbody_code] = [waterbodies.get(outgoing[0])]
+                link_lake[wbody_code] = list(set(rconn[outgoing[0]]).intersection(set(wbody_nodes)))[0]
+            else:
+                subset_dict = {key: value for key, value in connections.items() if key in wbody_nodes}
+                link_lake[wbody_code] = list(tailwaters(subset_dict))[0]
+
+        elif reservoir_boundary(connections, waterbodies, n):
+            # one of the children of n is a member of a waterbody
+            # replace that child with waterbody code.
+            new_conn[n] = []
+
+            for child in connections[n]:
+                if child in waterbodies:
+                    new_conn[n].append(waterbodies[child])
+                else:
+                    new_conn[n].append(child)
+        else:
+            # copy to new network unchanged
+            new_conn[n] = connections[n]
+    
+    return new_conn, link_lake
\ No newline at end of file
diff --git a/src/troute-network/troute/nhd_io.py b/src/troute-network/troute/nhd_io.py
index 710d5b87a..51563a698 100644
--- a/src/troute-network/troute/nhd_io.py
+++ b/src/troute-network/troute/nhd_io.py
@@ -120,7 +120,8 @@ def read_config_file(custom_input_file):
                         "musx": "MusX",
                         "cs": "ChSlp"  # TODO: rename to `sideslope`
                         }
-        supernetwork_parameters["columns"]             = routelink_attr 
+        if not supernetwork_parameters.get('columns',None):
+            supernetwork_parameters["columns"]         = routelink_attr 
         supernetwork_parameters["waterbody_null_code"] = -9999
         supernetwork_parameters["terminal_code"]       =  0
         supernetwork_parameters["driver_string"]       = "NetCDF"
diff --git a/src/troute-nwm/src/nwm_routing/__main__.py b/src/troute-nwm/src/nwm_routing/__main__.py
index 30d707c28..aa1acabff 100644
--- a/src/troute-nwm/src/nwm_routing/__main__.py
+++ b/src/troute-nwm/src/nwm_routing/__main__.py
@@ -208,7 +208,7 @@ def main_v04(argv):
         network.update_waterbody_water_elevation()    
         
         # update reservoir parameters and lastobs_df
-        data_assimilation.update_after_compute(run_results)
+        data_assimilation.update_after_compute(run_results, dt*nts)
 
         # TODO move the conditional call to write_lite_restart to nwm_output_generator.
         if "lite_restart" in output_parameters:
diff --git a/src/troute-routing/troute/routing/compute.py b/src/troute-routing/troute/routing/compute.py
index a926abaef..4519ac2a0 100644
--- a/src/troute-routing/troute/routing/compute.py
+++ b/src/troute-routing/troute/routing/compute.py
@@ -176,7 +176,10 @@ def _prep_reservoir_da_dataframes(reservoir_usgs_df, reservoir_usgs_param_df, re
         if exclude_segments:
             usgs_wbodies_sub = set(usgs_wbodies_sub).difference(set(exclude_segments))
         reservoir_usgs_df_sub = reservoir_usgs_df.loc[usgs_wbodies_sub]
-        reservoir_usgs_df_time = (reservoir_usgs_df.columns - t0).total_seconds().to_numpy()
+        reservoir_usgs_df_time = []
+        for timestamp in reservoir_usgs_df.columns:
+            reservoir_usgs_df_time.append((timestamp - t0).total_seconds())
+        reservoir_usgs_df_time = np.array(reservoir_usgs_df_time)
         reservoir_usgs_update_time = reservoir_usgs_param_df['update_time'].loc[usgs_wbodies_sub].to_numpy()
         reservoir_usgs_prev_persisted_flow = reservoir_usgs_param_df['prev_persisted_outflow'].loc[usgs_wbodies_sub].to_numpy()
         reservoir_usgs_persistence_update_time = reservoir_usgs_param_df['persistence_update_time'].loc[usgs_wbodies_sub].to_numpy()
@@ -199,8 +202,10 @@ def _prep_reservoir_da_dataframes(reservoir_usgs_df, reservoir_usgs_param_df, re
         if exclude_segments:
             usace_wbodies_sub = set(usace_wbodies_sub).difference(set(exclude_segments))
         reservoir_usace_df_sub = reservoir_usace_df.loc[usace_wbodies_sub]
-        reservoir_usace_df_time = (reservoir_usace_df.columns - t0).total_seconds().to_numpy()
-        reservoir_usace_df_time = (reservoir_usace_df.columns - t0).total_seconds().to_numpy()
+        reservoir_usace_df_time = []
+        for timestamp in reservoir_usace_df.columns:
+            reservoir_usace_df_time.append((timestamp - t0).total_seconds())
+        reservoir_usace_df_time = np.array(reservoir_usace_df_time)
         reservoir_usace_update_time = reservoir_usace_param_df['update_time'].loc[usace_wbodies_sub].to_numpy()
         reservoir_usace_prev_persisted_flow = reservoir_usace_param_df['prev_persisted_outflow'].loc[usace_wbodies_sub].to_numpy()
         reservoir_usace_persistence_update_time = reservoir_usace_param_df['persistence_update_time'].loc[usace_wbodies_sub].to_numpy()
@@ -1413,4 +1418,4 @@ def compute_diffusive_routing(
             )
         )
 
-    return results_diffusive
+    return results_diffusive
\ No newline at end of file
diff --git a/src/troute-routing/troute/routing/fast_reach/reservoir_RFC_da.py b/src/troute-routing/troute/routing/fast_reach/reservoir_RFC_da.py
index f11122f3d..8689c57c6 100644
--- a/src/troute-routing/troute/routing/fast_reach/reservoir_RFC_da.py
+++ b/src/troute-routing/troute/routing/fast_reach/reservoir_RFC_da.py
@@ -100,12 +100,15 @@ def _timeseries_idx_updatetime_totalcounts(lookback_hours,
 
     return timeseries_idx, timeseries_update_time, time_step_seconds, total_counts
 
-def _validate_RFC_data(lake_number, 
-                       time_series, 
-                       synthetic, 
-                       rfc_timeseries_folder, 
-                       rfc_timeseries_file,
-                       routing_period):
+def _validate_RFC_data(
+                        lake_number, 
+                        time_series, 
+                        synthetic, 
+                        rfc_timeseries_folder, 
+                        rfc_timeseries_file,
+                        routing_period,
+                        from_files=True,
+                       ):
     
     use_RFC = True
     file_path= os.path.join(rfc_timeseries_folder, rfc_timeseries_file)
@@ -126,7 +129,7 @@ def _validate_RFC_data(lake_number,
               contain one or more values greater than or equal to 90,000 Cubic Meters per \
               Second (twice the Mississippi River historical peak flow). \
               This reservoir will use level pool calculations instead.")
-    elif os.path.isfile(file_path)==False:
+    elif from_files and (os.path.isfile(file_path)==False):
         use_RFC = False
         print(f"WARNING: RFC Forecast Time Series file for reservoir {lake_number} \
               does not exist. \
diff --git a/src/troute_model.py b/src/troute_model.py
index a079b9611..021bbd1ea 100644
--- a/src/troute_model.py
+++ b/src/troute_model.py
@@ -23,8 +23,8 @@ def __init__(self, bmi_cfg_file):
         __slots__ = ['_log_parameters', '_preprocessing_parameters', '_supernetwork_parameters', 
                      '_waterbody_parameters', '_compute_parameters', '_forcing_parameters', 
                      '_restart_parameters', '_hybrid_parameters', '_output_parameters', 
-                     '_parity_parameters', '_data_assimilation_parameters', '_time', 
-                     '_segment_attributes', '_waterbody_attributes', '_network',
+                     '_parity_parameters', '_data_assimilation_parameters', '_bmi_parameters',
+                     '_time', '_segment_attributes', '_waterbody_attributes', '_network',
                      '_data_assimilation', '_fvd', '_lakeout']
         
         (
@@ -38,6 +38,7 @@ def __init__(self, bmi_cfg_file):
             self._output_parameters, 
             self._parity_parameters, 
             self._data_assimilation_parameters,
+            self._bmi_parameters,
         ) = _read_config_file(bmi_cfg_file)
 
         self._run_parameters = {
@@ -76,19 +77,18 @@ def preprocess_static_vars(self, values: dict):
             compute_parameters=self._compute_parameters,
             hybrid_parameters=self._hybrid_parameters,
             from_files=False, value_dict=values,
-            segment_attributes=self._segment_attributes, 
-            waterbody_attributes=self._waterbody_attributes)
+            bmi_parameters=self._bmi_parameters,)
 
         # Create data assimilation object with IDs but no dynamic variables yet.
         # Dynamic variables will be assigned during 'run' function. 
         self._data_assimilation = tr.DataAssimilation(
-        self._network,
-        self._data_assimilation_parameters,
-        self._run_parameters,
-        self._waterbody_parameters,
-        from_files=False,
-        value_dict=values,
-        )
+                                                    self._network,
+                                                    self._data_assimilation_parameters,
+                                                    self._run_parameters,
+                                                    self._waterbody_parameters,
+                                                    from_files=False,
+                                                    value_dict=values,
+                                                    )
 
         if len(values['upstream_id'])>0:
             for key in values['upstream_id']:
@@ -99,8 +99,6 @@ def preprocess_static_vars(self, values: dict):
                     for rli, _ in enumerate(self._network._reaches_by_tw[tw]):
                         self._network._reaches_by_tw[tw][rli].remove(key)
 
-
-
     def run(self, values: dict, until=300):
         """
         Run this model into the future, updating the state stored in the provided model dict appropriately.
@@ -115,23 +113,26 @@ def run(self, values: dict, until=300):
         Returns
         -------
         """
+
         # Set input data into t-route objects
         # Forcing values:
+        #FIX: index=self._network.segment_index is temporary fix, which needs to be updated
         self._network._qlateral = pd.DataFrame(index=self._network.segment_index).join(
             pd.DataFrame(values['land_surface_water_source__volume_flow_rate'],
-                         index=values['segment_id'])
+                         index=self._network.segment_index)
         )
         self._network._coastal_boundary_depth_df = pd.DataFrame(values['coastal_boundary__depth'])
         if len(values['upstream_id'])>0:
             flowveldepth_interorder = {values['upstream_id'][0]:{"results": values['upstream_fvd']}}
         else:
             flowveldepth_interorder = {}
-
-        # Data Assimilation values:
-        self._data_assimilation._usgs_df = pd.DataFrame(values['usgs_gage_observation__volume_flow_rate'])
-        self._data_assimilation._last_obs_df = pd.DataFrame(values['lastobs__volume_flow_rate'])
-        self._data_assimilation._reservoir_usgs_df = pd.DataFrame(values['reservoir_usgs_gage_observation__volume_flow_rate'])
-        self._data_assimilation._reservoir_usace_df = pd.DataFrame(values['reservoir_usace_gage_observation__volume_flow_rate'])
+      
+        # Trim the time-extent of the streamflow_da usgs_df
+        # what happens if there are timeslice files missing on the front-end? 
+        # if the first column is some timestamp greater than t0, then this will throw
+        # an error. Need to think through this more. 
+        if not self._data_assimilation.usgs_df.empty:
+            self._data_assimilation._usgs_df = self._data_assimilation.usgs_df.loc[:,self._network.t0.strftime('%Y-%m-%d %H:%M:%S'):]
 
         # Adjust number of steps based on user input
         nts = int(until/self._time_step)
@@ -178,7 +179,7 @@ def run(self, values: dict, until=300):
                          self._network.unrefactored_topobathy_df,
                          flowveldepth_interorder,
                          )
-        
+
         # update initial conditions with results output
         self._network.new_q0(self._run_results)
         # update offnetwork_upstream initial conditions
@@ -204,14 +205,15 @@ def run(self, values: dict, until=300):
         self._network.new_t0(self._time_step, nts)
 
         # get reservoir DA initial parameters for next loop iteration
-        self._data_assimilation.update_after_compute(self._run_results)
+        if not self._network._link_gage_df.empty:
+            self._data_assimilation.update_after_compute(self._run_results, self._time_step*nts)
         
         # Create output flowveldepth and lakeout arrays
         self._fvd, self._lakeout = _create_output_dataframes(
-            self._run_results,
-            nts,
-            self._network._waterbody_df,
-        )
+                                                            self._run_results,
+                                                            nts,
+                                                            self._network._waterbody_df,
+                                                             )
         values['fvd_results'] = self._fvd.values.flatten()
         values['fvd_index'] = self._fvd.index
         
@@ -227,10 +229,10 @@ def run(self, values: dict, until=300):
             self._run_results, 
             nts, 
             self._network._waterbody_df,)
-        
+
         # update model time
         self._time += self._time_step * nts
-
+        
 
 # Utility functions -------
 def _read_config_file(custom_input_file): #TODO: Update this function, I dont' think
@@ -268,24 +270,6 @@ def _read_config_file(custom_input_file): #TODO: Update this function, I dont' t
         supernetwork_parameters["title_string"]       = "HY_Features Test"
         supernetwork_parameters["geo_file_path"]      = supernetwork_parameters['geo_file_path']
         supernetwork_parameters["flowpath_edge_list"] = None    
-        routelink_attr = {
-                        #link????
-                        "key": "id",
-                        "downstream": "toid",
-                        "dx": "length_m",
-                        "n": "n",  # TODO: rename to `manningn`
-                        "ncc": "nCC",  # TODO: rename to `mannningncc`
-                        "s0": "So",
-                        "bw": "BtmWdth",  # TODO: rename to `bottomwidth`
-                        #waterbody: "NHDWaterbodyComID",
-                        "tw": "TopWdth",  # TODO: rename to `topwidth`
-                        "twcc": "TopWdthCC",  # TODO: rename to `topwidthcc`
-                        "alt": "alt",
-                        "musk": "MusK",
-                        "musx": "MusX",
-                        "cs": "ChSlp"  # TODO: rename to `sideslope`
-                        }
-        supernetwork_parameters["columns"]             = routelink_attr 
         supernetwork_parameters["waterbody_null_code"] = -9999
         supernetwork_parameters["terminal_code"]       =  0
         supernetwork_parameters["driver_string"]       = "NetCDF"
@@ -306,6 +290,7 @@ def _read_config_file(custom_input_file): #TODO: Update this function, I dont' t
     )
     output_parameters = data.get("output_parameters", {})
     parity_parameters = output_parameters.get("wrf_hydro_parity_check", {})
+    bmi_parameters = data.get("bmi_parameters", {})
 
     return (
         preprocessing_parameters,
@@ -318,6 +303,7 @@ def _read_config_file(custom_input_file): #TODO: Update this function, I dont' t
         output_parameters,
         parity_parameters,
         data_assimilation_parameters,
+        bmi_parameters,
     )
 
 def _retrieve_last_output(results, nts, waterbodies_df,):
diff --git a/test/BMI/bmi_large_example.yaml b/test/BMI/bmi_large_example.yaml
new file mode 100644
index 000000000..8313a8c6b
--- /dev/null
+++ b/test/BMI/bmi_large_example.yaml
@@ -0,0 +1,199 @@
+#--------------------------------------------------------------------------------
+bmi_parameters:
+    #----------
+    segment_number: 6
+    waterbody_number: 1
+    io_number: 6
+    upstream_number: 0
+    gage_number: 3
+    flowpath_columns:
+        - 'id'
+        - 'toid'
+        - 'lengthkm'
+    attributes_columns:
+        - 'attributes_id'
+        - 'rl_gages'
+        - 'rl_NHDWaterbodyComID'
+        - 'MusK'
+        - 'MusX'
+        - 'n'
+        - 'So'
+        - 'ChSlp'
+        - 'BtmWdth'
+        - 'nCC'
+        - 'TopWdthCC'
+        - 'TopWdth'
+    waterbody_columns:
+        - 'hl_link'
+        - 'ifd'
+        - 'LkArea'
+        - 'LkMxE'
+        - 'OrificeA'
+        - 'OrificeC'
+        - 'OrificeE'
+        - 'WeirC'
+        - 'WeirE'
+        - 'WeirL'
+    network_columns:
+        - 'network_id'
+        - 'hydroseq'
+        - 'hl_uri'
+
+#--------------------------------------------------------------------------------
+log_parameters:
+    #----------
+    showtiming: False
+    log_level : CRITICAL
+#--------------------------------------------------------------------------------
+network_topology_parameters:
+    #----------
+    supernetwork_parameters:
+        #----------
+        geo_file_type: HYFeaturesNetwork  #NHDNetwork        
+        geo_file_path: domain/gauge_01013500.gpkg 
+        columns: 
+            key: 'id'
+            downstream: 'toid'
+            dx : 'lengthkm'
+            n : 'n'
+            ncc : 'nCC'
+            s0 : 'So'
+            bw : 'BtmWdth'
+            waterbody : 'rl_NHDWaterbodyComID'
+            #gages : 'rl_gages'
+            tw : 'TopWdth'
+            twcc : 'TopWdthCC'
+            musk : 'MusK'
+            musx : 'MusX'
+            cs : 'ChSlp'
+            alt: 'alt'
+        duplicate_wb_segments:
+            - 717696
+            - 1311881
+            - 3133581
+            - 1010832
+            - 1023120
+            - 1813525
+            - 1531545
+            - 1304859
+            - 1320604
+            - 1233435
+            - 11816
+            - 1312051
+            - 2723765
+            - 2613174
+            - 846266
+            - 1304891
+            - 1233595
+            - 1996602
+            - 2822462
+            - 2384576
+            - 1021504
+            - 2360642
+            - 1326659
+            - 1826754
+            - 572364
+            - 1336910
+            - 1332558
+            - 1023054
+            - 3133527
+            - 3053788
+            - 3101661
+            - 2043487
+            - 3056866
+            - 1296744
+            - 1233515
+            - 2045165
+            - 1230577
+            - 1010164
+            - 1031669
+            - 1291638
+            - 1637751
+    waterbody_parameters:
+        #----------
+        break_network_at_waterbodies: True 
+        level_pool:
+            #----------
+            level_pool_waterbody_parameter_file_path: domain/gauge_01013500.gpkg 
+
+#--------------------------------------------------------------------------------
+compute_parameters:
+    #----------
+    parallel_compute_method: bmi 
+    subnetwork_target_size : 10000
+    cpu_pool               : 16
+    compute_kernel         : V02-structured
+    assume_short_ts        : True  
+    restart_parameters:
+        #----------
+        start_datetime: "2021-08-23_13:00:00"
+    hybrid_parameters:
+        run_hybrid_routing: False
+        diffusive_domain  : domain/coastal_domain.yaml 
+        use_natl_xsections: False
+        topobathy_domain  :  domain/final_diffusive_natural_xs.nc 
+        run_refactored_network: False
+        refactored_domain:  domain/unit_test_noRS/refactored_coastal_domain.yaml 
+        refactored_topobathy_domain:  domain/refac_final_diffusive_natural_xs.nc 
+        coastal_boundary_domain: domain/coastal_boundary_domain.yaml
+    forcing_parameters:
+        #----------
+        qts_subdivisions            : 12
+        dt                          : 300 # [sec]
+        qlat_input_folder           : channel_forcing/
+        qlat_file_pattern_filter    : "*NEXOUT.csv"
+        #nexus_input_folder          : channel_forcing/ 
+        #nexus_file_pattern_filter   : "*NEXOUT.csv" # or "*NEXOUT.parquet" or "nex-*"
+        #binary_nexus_file_folder    : binary_files # this is required if nexus_file_pattern_filter="nex-*"
+        #coastal_boundary_input_file : #channel_forcing/schout_1.nc  
+        nts                         : 288 #288 for 1day
+        max_loop_size               : 24 # [hr]  
+    data_assimilation_parameters:
+        #----------
+        #usgs_timeslices_folder   : #usgs_TimeSlice/
+        #usace_timeslices_folder  : #usace_TimeSlice/
+        #timeslice_lookback_hours : #48 
+        streamflow_da:
+            #----------
+            streamflow_nudging            : True
+            diffusive_streamflow_nudging  : False
+            gage_segID_crosswalk_file     : domain/RouteLink.nc  
+            crosswalk_gage_field          : 'gages'
+            crosswalk_segID_field         : 'link'
+            wrf_hydro_lastobs_file        : lastobs/nudgingLastObs.2021-08-23_12:00:00.nc                
+            lastobs_output_folder         : 
+            da_decay_coefficient          : 120
+            wrf_hydro_lastobs_lead_time_relative_to_simulation_start_time : 0
+        persistence_reservoir_da:
+            #----------
+            reservoir_persistence_usgs  : True
+            reservoir_persistence_usace : False
+            usgs_timeslices_folder      : usgs_TimeSlice/
+            usace_timeslices_folder     : usace_TimeSlice/
+            gage_lakeID_crosswalk_file  : # domain/reservoir_index_AnA.nc
+            timeslice_lookback_hours    : 2 
+            qc_threshold                : #1
+            interpolation_limit_min     : 
+        rfc_reservoir_da:
+            reservoir_rfc_forecast                  : False
+            rfc_forecast_time_series_folder         : rfc_TimeSeries/
+            gage_lakeID_crosswalk_file              : domain/lake_gage_df.csv
+            reservoir_rfc_forecast_lookback_hours   : 48
+            reservoir_rfc_forecast_persist_days     : 11
+            reservoir_rfc_timeseries_offset_hours   : 28
+
+#--------------------------------------------------------------------------------
+output_parameters:
+    #----------
+    test_output: output/output.pkl
+#    lite_restart:
+        #----------
+#        lite_restart_output_directory: restart/
+#    chrtout_output:
+        #----------
+#        wrf_hydro_channel_output_source_folder: channel_forcing/
+#    chanobs_output:
+        #----------
+#        chanobs_output_directory: output/
+#        chanobs_filepath        : lcr_chanobs.nc
+#    lakeout_output: lakeout/
\ No newline at end of file
diff --git a/test/BMI/bmi_lower_example.yaml b/test/BMI/bmi_lower_example.yaml
index 95177cc37..4c1507c44 100644
--- a/test/BMI/bmi_lower_example.yaml
+++ b/test/BMI/bmi_lower_example.yaml
@@ -5,6 +5,39 @@ bmi_parameters:
     waterbody_number: 0
     io_number: 3
     upstream_number: 1
+    gage_number: 0
+    flowpath_columns:
+        - 'id'
+        - 'toid'
+        - 'lengthkm'
+    attributes_columns:
+        - 'attributes_id'
+        - 'rl_gages'
+        - 'rl_NHDWaterbodyComID'
+        - 'MusK'
+        - 'MusX'
+        - 'n'
+        - 'So'
+        - 'ChSlp'
+        - 'BtmWdth'
+        - 'nCC'
+        - 'TopWdthCC'
+        - 'TopWdth'
+    waterbody_columns:
+        - 'hl_link'
+        - 'ifd'
+        - 'LkArea'
+        - 'LkMxE'
+        - 'OrificeA'
+        - 'OrificeC'
+        - 'OrificeE'
+        - 'WeirC'
+        - 'WeirE'
+        - 'WeirL'
+    network_columns:
+        - 'network_id'
+        - 'hydroseq'
+        - 'hl_uri'
 
 #--------------------------------------------------------------------------------
 log_parameters:
@@ -17,95 +50,150 @@ network_topology_parameters:
     supernetwork_parameters:
         #----------
         geo_file_type: HYFeaturesNetwork  #NHDNetwork        
-        geo_file_path: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg 
-        mask_file_path: # domain/unit_test_noRS/coastal_subset.txt
-        synthetic_wb_segments:
-            #- 4800002
-            #- 4800004
-            #- 4800006
-            #- 4800007
+        geo_file_path: domain/gauge_01013500.gpkg 
+        columns: 
+            key: 'id'
+            downstream: 'toid'
+            dx : 'lengthkm'
+            n : 'n'
+            ncc : 'nCC'
+            s0 : 'So'
+            bw : 'BtmWdth'
+            waterbody : 'rl_NHDWaterbodyComID'
+            #gages : 'rl_gages'
+            tw : 'TopWdth'
+            twcc : 'TopWdthCC'
+            musk : 'MusK'
+            musx : 'MusX'
+            cs : 'ChSlp'
+            alt: 'alt'
+        duplicate_wb_segments:
+            - 717696
+            - 1311881
+            - 3133581
+            - 1010832
+            - 1023120
+            - 1813525
+            - 1531545
+            - 1304859
+            - 1320604
+            - 1233435
+            - 11816
+            - 1312051
+            - 2723765
+            - 2613174
+            - 846266
+            - 1304891
+            - 1233595
+            - 1996602
+            - 2822462
+            - 2384576
+            - 1021504
+            - 2360642
+            - 1326659
+            - 1826754
+            - 572364
+            - 1336910
+            - 1332558
+            - 1023054
+            - 3133527
+            - 3053788
+            - 3101661
+            - 2043487
+            - 3056866
+            - 1296744
+            - 1233515
+            - 2045165
+            - 1230577
+            - 1010164
+            - 1031669
+            - 1291638
+            - 1637751
     waterbody_parameters:
         #----------
         break_network_at_waterbodies: True 
         level_pool:
             #----------
-            level_pool_waterbody_parameter_file_path: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg 
-            reservoir_parameter_file                : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg
-        #rfc:
-            #----------
-            #reservoir_parameter_file                : domain/reservoir_index_AnA.nc
-            #reservoir_rfc_forecasts                 : False
-            #reservoir_rfc_forecasts_time_series_path: rfc_TimeSeries/
-            #reservoir_rfc_forecasts_lookback_hours  : 48
+            level_pool_waterbody_parameter_file_path: domain/gauge_01013500.gpkg 
+
 #--------------------------------------------------------------------------------
 compute_parameters:
     #----------
     parallel_compute_method: bmi 
-    compute_kernel         : V02-structured
-    assume_short_ts        : True
     subnetwork_target_size : 10000
-    cpu_pool               : 36
+    cpu_pool               : 16
+    compute_kernel         : V02-structured
+    assume_short_ts        : True  
     restart_parameters:
         #----------
-        #wrf_hydro_channel_restart_file: restart/HYDRO_RST.2020-08-26_00:00_DOMAIN1
-        #wrf_hydro_channel_ID_crosswalk_file: domain/RouteLink_NWMv2.1.nc
-        #wrf_hydro_waterbody_restart_file: restart/HYDRO_RST.2020-08-26_00:00_DOMAIN1
-        #wrf_hydro_waterbody_ID_crosswalk_file    : domain/LAKEPARM_NWMv2.1.nc 
-        #wrf_hydro_waterbody_crosswalk_filter_file: domain/LAKEPARM_NWMv2.1.nc
-        start_datetime: "2015-12-01_00:00:00"
+        start_datetime: "2021-08-23_13:00:00"
     hybrid_parameters:
         run_hybrid_routing: False
-        diffusive_domain  : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/coastal_domain.yaml 
+        diffusive_domain  : domain/coastal_domain.yaml 
         use_natl_xsections: False
-        topobathy_domain  : # domain/final_diffusive_natural_xs.nc 
+        topobathy_domain  :  domain/final_diffusive_natural_xs.nc 
         run_refactored_network: False
-        refactored_domain: # domain/unit_test_noRS/refactored_coastal_domain.yaml 
-        refactored_topobathy_domain: # domain/refac_final_diffusive_natural_xs.nc 
-        coastal_boundary_domain: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/coastal_boundary_domain.yaml
+        refactored_domain:  domain/unit_test_noRS/refactored_coastal_domain.yaml 
+        refactored_topobathy_domain:  domain/refac_final_diffusive_natural_xs.nc 
+        coastal_boundary_domain: domain/coastal_boundary_domain.yaml
     forcing_parameters:
         #----------
         qts_subdivisions            : 12
         dt                          : 300 # [sec]
-        qlat_input_folder           : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/channel_forcing
+        qlat_input_folder           : channel_forcing/
         qlat_file_pattern_filter    : "*NEXOUT.csv"
-        nexus_input_folder          : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/channel_forcing 
-        nexus_file_pattern_filter   : "*NEXOUT.csv" #OR "*NEXOUT.parquet" OR "nex-*"
-        binary_nexus_file_folder    : binary_files # this is required if nexus_file_pattern_filter="nex-*"
-        coastal_boundary_input_file : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/channel_forcing/schout_1.nc  
-        nts                         : 48 #288 for 1day
-        max_loop_size               : 1 # [hr]  
+        #nexus_input_folder          : channel_forcing/ 
+        #nexus_file_pattern_filter   : "*NEXOUT.csv" # or "*NEXOUT.parquet" or "nex-*"
+        #binary_nexus_file_folder    : binary_files # this is required if nexus_file_pattern_filter="nex-*"
+        #coastal_boundary_input_file : #channel_forcing/schout_1.nc  
+        nts                         : 288 #288 for 1day
+        max_loop_size               : 24 # [hr]  
     data_assimilation_parameters:
         #----------
-        usgs_timeslices_folder   : #usgs_TimeSlice/
-        usace_timeslices_folder  : #usace_TimeSlice/
-        timeslice_lookback_hours : #48 
-        qc_threshold             : #1
+        #usgs_timeslices_folder   : #usgs_TimeSlice/
+        #usace_timeslices_folder  : #usace_TimeSlice/
+        #timeslice_lookback_hours : #48 
         streamflow_da:
             #----------
-            streamflow_nudging            : False
+            streamflow_nudging            : True
             diffusive_streamflow_nudging  : False
-            gage_segID_crosswalk_file     : # domain/RouteLink_NWMv2.1.nc  
-            crosswalk_gage_field          : # 'gages'
-            crosswalk_segID_field         : # 'link'
-            wrf_hydro_lastobs_file        :                
-            lastobs_output_folder         : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/lastobs
-        reservoir_da:
+            gage_segID_crosswalk_file     : domain/RouteLink.nc  
+            crosswalk_gage_field          : 'gages'
+            crosswalk_segID_field         : 'link'
+            wrf_hydro_lastobs_file        : lastobs/nudgingLastObs.2021-08-23_12:00:00.nc                
+            lastobs_output_folder         : 
+            da_decay_coefficient          : 120
+            wrf_hydro_lastobs_lead_time_relative_to_simulation_start_time : 0
+        persistence_reservoir_da:
             #----------
-            reservoir_persistence_usgs  : False
+            reservoir_persistence_usgs  : True
             reservoir_persistence_usace : False
+            usgs_timeslices_folder      : usgs_TimeSlice/
+            usace_timeslices_folder     : usace_TimeSlice/
             gage_lakeID_crosswalk_file  : # domain/reservoir_index_AnA.nc
+            timeslice_lookback_hours    : 2 
+            qc_threshold                : #1
+            interpolation_limit_min     : 
+        rfc_reservoir_da:
+            reservoir_rfc_forecast                  : False
+            rfc_forecast_time_series_folder         : rfc_TimeSeries/
+            gage_lakeID_crosswalk_file              : domain/lake_gage_df.csv
+            reservoir_rfc_forecast_lookback_hours   : 48
+            reservoir_rfc_forecast_persist_days     : 11
+            reservoir_rfc_timeseries_offset_hours   : 28
+
 #--------------------------------------------------------------------------------
 output_parameters:
     #----------
-    test_output: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/output/unit_test_hyfeature.pkl
+    test_output: output/output.pkl
 #    lite_restart:
         #----------
-#        lite_restart_output_directory: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/restart/
+#        lite_restart_output_directory: restart/
 #    chrtout_output:
         #----------
-#        wrf_hydro_channel_output_source_folder: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/channel_forcing/
+#        wrf_hydro_channel_output_source_folder: channel_forcing/
 #    chanobs_output:
         #----------
-#        chanobs_output_directory: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/output/
+#        chanobs_output_directory: output/
 #        chanobs_filepath        : lcr_chanobs.nc
-#    lakeout_output: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/lakeout/
\ No newline at end of file
+#    lakeout_output: lakeout/
\ No newline at end of file
diff --git a/test/BMI/bmi_reservoir_example.yaml b/test/BMI/bmi_reservoir_example.yaml
index 2a0dc3059..35c9758ef 100644
--- a/test/BMI/bmi_reservoir_example.yaml
+++ b/test/BMI/bmi_reservoir_example.yaml
@@ -13,27 +13,31 @@ log_parameters:
 #--------------------------------------------------------------------------------
 compute_parameters:
     #--------------
-    model_start_time: "2021-10-20_13:00:00"
+    model_start_time: "2021-08-23_13:00:00"
     model_time_step: 300 # model timestep in seconds (300 = 5min)
 #--------------------------------------------------------------------------------
 reservoir_data_assimilation_parameters:
     level_pool:
         #----------
-        level_pool_waterbody_parameter_file_path: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg 
-        reservoir_parameter_file                : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg
-    rfc:
+        level_pool_waterbody_parameter_file_path: domain/gauge_01013500.gpkg  
+        reservoir_parameter_file                : domain/gauge_01013500.gpkg 
+    rfc_reservoir_da:
         #----------
-        reservoir_rfc_timeseries_folder          : "./../test/BMI/rfc_timeseries/"
-        reservoir_rfc_gage_id                    : "KNFC1"
-        reservoir_rfc_timeseries_offset_hours    : 28
-        reservoir_rfc_forecast_persist_days      : 11
-    persistence:
+        reservoir_rfc_forecast                  : True
+        rfc_forecast_time_series_folder         : rfc_TimeSeries/
+        reservoir_rfc_gage_id                   : "KNFC1"
+        gage_lakeID_crosswalk_file              : domain/lake_gage_df.csv
+        reservoir_rfc_forecast_lookback_hours   : 48
+        reservoir_rfc_forecast_persist_days     : 11
+        reservoir_rfc_timeseries_offset_hours   : 28
+    persistence_reservoir_da:
         #----------
-        reservoir_persistence_usgs  : False
+        reservoir_persistence_usgs  : True
         reservoir_persistence_usace : False
+        usgs_timeslices_folder      : usgs_TimeSlice/
+        usace_timeslices_folder     : usace_TimeSlice/
         gage_lakeID_crosswalk_file  : # domain/reservoir_index_AnA.nc
-        usgs_timeslices_folder   : #usgs_TimeSlice/
-        usace_timeslices_folder  : #usace_TimeSlice/
-        timeslice_lookback_hours : #48 
-        qc_threshold             : #1
+        timeslice_lookback_hours    : 2 
+        qc_threshold                : #1
+        interpolation_limit_min     : 
 
diff --git a/test/BMI/bmi_upper_example.yaml b/test/BMI/bmi_upper_example.yaml
index 4d7832217..a2bd68dac 100644
--- a/test/BMI/bmi_upper_example.yaml
+++ b/test/BMI/bmi_upper_example.yaml
@@ -5,6 +5,39 @@ bmi_parameters:
     waterbody_number: 0
     io_number: 3
     upstream_number: 0
+    gage_number: 3
+    flowpath_columns:
+        - 'id'
+        - 'toid'
+        - 'lengthkm'
+    attributes_columns:
+        - 'attributes_id'
+        - 'rl_gages'
+        - 'rl_NHDWaterbodyComID'
+        - 'MusK'
+        - 'MusX'
+        - 'n'
+        - 'So'
+        - 'ChSlp'
+        - 'BtmWdth'
+        - 'nCC'
+        - 'TopWdthCC'
+        - 'TopWdth'
+    waterbody_columns:
+        - 'hl_link'
+        - 'ifd'
+        - 'LkArea'
+        - 'LkMxE'
+        - 'OrificeA'
+        - 'OrificeC'
+        - 'OrificeE'
+        - 'WeirC'
+        - 'WeirE'
+        - 'WeirL'
+    network_columns:
+        - 'network_id'
+        - 'hydroseq'
+        - 'hl_uri'
 
 #--------------------------------------------------------------------------------
 log_parameters:
@@ -17,95 +50,150 @@ network_topology_parameters:
     supernetwork_parameters:
         #----------
         geo_file_type: HYFeaturesNetwork  #NHDNetwork        
-        geo_file_path: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg 
-        mask_file_path: # domain/unit_test_noRS/coastal_subset.txt
-        synthetic_wb_segments:
-            #- 4800002
-            #- 4800004
-            #- 4800006
-            #- 4800007
+        geo_file_path: domain/gauge_01013500.gpkg 
+        columns: 
+            key: 'id'
+            downstream: 'toid'
+            dx : 'lengthkm'
+            n : 'n'
+            ncc : 'nCC'
+            s0 : 'So'
+            bw : 'BtmWdth'
+            waterbody : 'rl_NHDWaterbodyComID'
+            #gages : 'rl_gages'
+            tw : 'TopWdth'
+            twcc : 'TopWdthCC'
+            musk : 'MusK'
+            musx : 'MusX'
+            cs : 'ChSlp'
+            alt: 'alt'
+        duplicate_wb_segments:
+            - 717696
+            - 1311881
+            - 3133581
+            - 1010832
+            - 1023120
+            - 1813525
+            - 1531545
+            - 1304859
+            - 1320604
+            - 1233435
+            - 11816
+            - 1312051
+            - 2723765
+            - 2613174
+            - 846266
+            - 1304891
+            - 1233595
+            - 1996602
+            - 2822462
+            - 2384576
+            - 1021504
+            - 2360642
+            - 1326659
+            - 1826754
+            - 572364
+            - 1336910
+            - 1332558
+            - 1023054
+            - 3133527
+            - 3053788
+            - 3101661
+            - 2043487
+            - 3056866
+            - 1296744
+            - 1233515
+            - 2045165
+            - 1230577
+            - 1010164
+            - 1031669
+            - 1291638
+            - 1637751
     waterbody_parameters:
         #----------
         break_network_at_waterbodies: True 
         level_pool:
             #----------
-            level_pool_waterbody_parameter_file_path: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg 
-            reservoir_parameter_file                : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/gauge_01069700.gpkg
-        #rfc:
-            #----------
-            #reservoir_parameter_file                : domain/reservoir_index_AnA.nc
-            #reservoir_rfc_forecasts                 : False
-            #reservoir_rfc_forecasts_time_series_path: rfc_TimeSeries/
-            #reservoir_rfc_forecasts_lookback_hours  : 48
+            level_pool_waterbody_parameter_file_path: domain/gauge_01013500.gpkg 
+
 #--------------------------------------------------------------------------------
 compute_parameters:
     #----------
     parallel_compute_method: bmi 
-    compute_kernel         : V02-structured
-    assume_short_ts        : True
     subnetwork_target_size : 10000
-    cpu_pool               : 36
+    cpu_pool               : 16
+    compute_kernel         : V02-structured
+    assume_short_ts        : True  
     restart_parameters:
         #----------
-        #wrf_hydro_channel_restart_file: restart/HYDRO_RST.2020-08-26_00:00_DOMAIN1
-        #wrf_hydro_channel_ID_crosswalk_file: domain/RouteLink_NWMv2.1.nc
-        #wrf_hydro_waterbody_restart_file: restart/HYDRO_RST.2020-08-26_00:00_DOMAIN1
-        #wrf_hydro_waterbody_ID_crosswalk_file    : domain/LAKEPARM_NWMv2.1.nc 
-        #wrf_hydro_waterbody_crosswalk_filter_file: domain/LAKEPARM_NWMv2.1.nc
-        start_datetime: "2015-12-01_00:00:00"
+        start_datetime: "2021-08-23_13:00:00"
     hybrid_parameters:
         run_hybrid_routing: False
-        diffusive_domain  : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/coastal_domain.yaml 
+        diffusive_domain  : domain/coastal_domain.yaml 
         use_natl_xsections: False
-        topobathy_domain  : # domain/final_diffusive_natural_xs.nc 
+        topobathy_domain  :  domain/final_diffusive_natural_xs.nc 
         run_refactored_network: False
-        refactored_domain: # domain/unit_test_noRS/refactored_coastal_domain.yaml 
-        refactored_topobathy_domain: # domain/refac_final_diffusive_natural_xs.nc 
-        coastal_boundary_domain: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/domain/coastal_boundary_domain.yaml
+        refactored_domain:  domain/unit_test_noRS/refactored_coastal_domain.yaml 
+        refactored_topobathy_domain:  domain/refac_final_diffusive_natural_xs.nc 
+        coastal_boundary_domain: domain/coastal_boundary_domain.yaml
     forcing_parameters:
         #----------
         qts_subdivisions            : 12
         dt                          : 300 # [sec]
-        qlat_input_folder           : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/channel_forcing
+        qlat_input_folder           : channel_forcing/
         qlat_file_pattern_filter    : "*NEXOUT.csv"
-        nexus_input_folder          : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/channel_forcing 
-        nexus_file_pattern_filter   : "*NEXOUT.csv" #OR "*NEXOUT.parquet" OR "nex-*"
-        binary_nexus_file_folder    : binary_files # this is required if nexus_file_pattern_filter="nex-*"
-        coastal_boundary_input_file : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/channel_forcing/schout_1.nc  
-        nts                         : 48 #288 for 1day
-        max_loop_size               : 1 # [hr]  
+        #nexus_input_folder          : channel_forcing/ 
+        #nexus_file_pattern_filter   : "*NEXOUT.csv" # or "*NEXOUT.parquet" or "nex-*"
+        #binary_nexus_file_folder    : binary_files # this is required if nexus_file_pattern_filter="nex-*"
+        #coastal_boundary_input_file : #channel_forcing/schout_1.nc  
+        nts                         : 288 #288 for 1day
+        max_loop_size               : 24 # [hr]  
     data_assimilation_parameters:
         #----------
-        usgs_timeslices_folder   : #usgs_TimeSlice/
-        usace_timeslices_folder  : #usace_TimeSlice/
-        timeslice_lookback_hours : #48 
-        qc_threshold             : #1
+        #usgs_timeslices_folder   : #usgs_TimeSlice/
+        #usace_timeslices_folder  : #usace_TimeSlice/
+        #timeslice_lookback_hours : #48 
         streamflow_da:
             #----------
-            streamflow_nudging            : False
+            streamflow_nudging            : True
             diffusive_streamflow_nudging  : False
-            gage_segID_crosswalk_file     : # domain/RouteLink_NWMv2.1.nc  
-            crosswalk_gage_field          : # 'gages'
-            crosswalk_segID_field         : # 'link'
-            wrf_hydro_lastobs_file        :                
-            lastobs_output_folder         : /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/lastobs
-        reservoir_da:
+            gage_segID_crosswalk_file     : domain/RouteLink.nc  
+            crosswalk_gage_field          : 'gages'
+            crosswalk_segID_field         : 'link'
+            wrf_hydro_lastobs_file        : lastobs/nudgingLastObs.2021-08-23_12:00:00.nc                
+            lastobs_output_folder         : 
+            da_decay_coefficient          : 120
+            wrf_hydro_lastobs_lead_time_relative_to_simulation_start_time : 0
+        persistence_reservoir_da:
             #----------
-            reservoir_persistence_usgs  : False
+            reservoir_persistence_usgs  : True
             reservoir_persistence_usace : False
+            usgs_timeslices_folder      : usgs_TimeSlice/
+            usace_timeslices_folder     : usace_TimeSlice/
             gage_lakeID_crosswalk_file  : # domain/reservoir_index_AnA.nc
+            timeslice_lookback_hours    : 2 
+            qc_threshold                : #1
+            interpolation_limit_min     : 
+        rfc_reservoir_da:
+            reservoir_rfc_forecast                  : False
+            rfc_forecast_time_series_folder         : rfc_TimeSeries/
+            gage_lakeID_crosswalk_file              : domain/lake_gage_df.csv
+            reservoir_rfc_forecast_lookback_hours   : 48
+            reservoir_rfc_forecast_persist_days     : 11
+            reservoir_rfc_timeseries_offset_hours   : 28
+
 #--------------------------------------------------------------------------------
 output_parameters:
     #----------
-    test_output: /home/sean.horvath/projects/t-route/test/unit_test_hyfeature/output/unit_test_hyfeature.pkl
+    test_output: output/output.pkl
 #    lite_restart:
         #----------
-#        lite_restart_output_directory: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/restart/
+#        lite_restart_output_directory: restart/
 #    chrtout_output:
         #----------
-#        wrf_hydro_channel_output_source_folder: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/channel_forcing/
+#        wrf_hydro_channel_output_source_folder: channel_forcing/
 #    chanobs_output:
         #----------
-#        chanobs_output_directory: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/output/
+#        chanobs_output_directory: output/
 #        chanobs_filepath        : lcr_chanobs.nc
-#    lakeout_output: /glade/u/home/shorvath/projects/t-route/test/LowerColorado_TX/lakeout/
\ No newline at end of file
+#    lakeout_output: lakeout/
\ No newline at end of file
diff --git a/test/BMI/domain/RouteLink.nc b/test/BMI/domain/RouteLink.nc
new file mode 100644
index 000000000..fc1c0ab07
Binary files /dev/null and b/test/BMI/domain/RouteLink.nc differ
diff --git a/test/BMI/domain/gauge_01013500.gpkg b/test/BMI/domain/gauge_01013500.gpkg
new file mode 100644
index 000000000..e57e5500c
Binary files /dev/null and b/test/BMI/domain/gauge_01013500.gpkg differ
diff --git a/test/BMI/domain/gauge_01069700.gpkg b/test/BMI/domain/gauge_01069700.gpkg
new file mode 100644
index 000000000..48b20ae7b
Binary files /dev/null and b/test/BMI/domain/gauge_01069700.gpkg differ
diff --git a/test/BMI/domain/lake_gage_df.csv b/test/BMI/domain/lake_gage_df.csv
new file mode 100644
index 000000000..6ba561905
--- /dev/null
+++ b/test/BMI/domain/lake_gage_df.csv
@@ -0,0 +1,513 @@
+lake_id,gage_id,reservoir_type
+229217,06713000,2
+936750,07124410,2
+1031669,01043500,2
+1086591,03209000,2
+1127701,07344210,2
+1233435,09015000,2
+1259469,08057300,2
+120054054,11507500,2
+2739068,01429000,2
+2803451,11162753,2
+2806071,11174000,2
+2896951,06751150,2
+167122203,05292000,2
+4167460,06012500,2
+4185065,01447800,2
+4186689,01449800,2
+4690013,01563200,2
+4782813,01470960,2
+166174045,01019000,2
+5212313,03228805,2
+5212351,03228500,2
+5864569,01104430,2
+6228110,0137462010,2
+6225308,01374941,2
+6245050,01382385,2
+6244958,01382210,2
+6244708,01383500,2
+6248826,01381000,2
+6248656,01378500,2
+6262252,01407500,2
+6479325,02382500,2
+6743056,01100505,2
+167201419,05074500,2
+7108515,05126210,2
+8008517,11451000,2
+167484046,02077670,2
+8761867,0208250410,2
+8776313,02086500,2
+9304958,05017500,2
+9512534,01396800,2
+9554371,06401500,2
+10737413,10301720,2
+11002485,02232000,2
+120053478,10335000,2
+11572508,02090380,2
+11686926,01581920,2
+120053573,01591610,2
+12033889,021556525,2
+167120968,05425912,2
+13343906,05357245,2
+14363834,01597500,2
+120052979,05058000,2
+15372030,03141500,2
+166757576,02243960,2
+120052700,03322485,2
+19387454,03121500,2
+20057974,07206000,2
+22886855,12301933,2
+23127757,13011000,2
+23171013,13081500,2
+120052939,13077000,2
+23756364,14145500,2
+23769069,14169000,2
+23777375,14162200,2
+23812618,14208700,2
+23848103,12039500,2
+23859017,12035400,2
+24245783,14220500,2
+24252328,14238000,2
+24260837,12193400,2
+24331842,12342500,2
+120052938,13183000,2
+6639922,05050000,2
+5194634,01018500,2
+10091800,UT10131,3
+16603633,CA10167,3
+21606665,CA00240,3
+120051899,CA10246,3
+20194524,CA10148,3
+2781987,CA10186,3
+1010832,TX00020,3
+15237526,AR00535,3
+120053569,MO30202,3
+167299813,AR00174,3
+166899385,KY03001,3
+120052349,KY05017,3
+9422503,NY01055,3
+167246015,CO00351,3
+188031,CO01281,3
+167266511,KS00024,3
+18950909,KS00019,3
+5943595,KS00025,3
+7344817,KS00022,3
+120052972,KS00021,3
+17404975,NE01057,3
+19016317,KS00023,3
+167794979,NE01048,3
+17404931,NE01063,3
+17216840,NE01518,3
+15975492,WY01295,3
+167245825,WY01297,3
+22103649,WY01290,3
+12898716,WY01378,3
+12869679,WY01299,3
+11546100,SD01092,3
+120053557,SD01093,3
+12793741,WY01300,3
+3056866,MT00134,3
+4167440,MT00569,3
+167204997,MT00576,3
+21849419,ND00147,3
+21861936,SD01141,3
+120053643,ND00151,3
+167204871,MT00568,3
+120051950,MT00559,3
+3022162,MT00560,3
+12394600,MT00571,3
+167204901,MT00025,3
+167156996,IL00117,3
+167122265,IL00113,3
+937110111,MO82201,3
+167122256,IL00118,3
+120051919,MN00594,3
+4083248,MN00579,3
+4083202,MN00581,3
+167120397,MN00583,3
+4620258,MN00582,3
+6657709,MN00574,3
+167122141,MN00586,3
+4817675,MN00585,3
+120052509,ND00332,3
+4800004,PortHuron,3
+6106841,CT00506,3
+166174267,NH00003,3
+23938563,OR00624,3
+23761342,OR00005,3
+23761332,OR00008,3
+23756162,OR00007,3
+23707652,OR00381,3
+120053990,ID00288,3
+120054056,ID00283,3
+24215523,OR00577,3
+23717064,OR00098,3
+23777431,OR00015,3
+23788981,OR00012,3
+23634782,ID00287,3
+24428693,WA00273,3
+24428511,WA00263,3
+24136753,WA00260,3
+22983738,ID00222,3
+22983840,MT00223,3
+24260289,WA00169,3
+167122309,TN04102,3
+18415569,TN03722,3
+120052688,TN03701,3
+11620502,KY03012,3
+4003290,KY03011,3
+120052316,KY03009,3
+3999688,KY03007,3
+486928,KY03027,3
+1086597,VA195001,3
+885333,KY03029,3
+1086587,KY03028,3
+6933708,WV10924,3
+6906421,WV08902,3
+19322053,WV00701,3
+4547794,WV06702,3
+3964366,WV09901,3
+120052749,KY03030,3
+166830448,KY03055,3
+10263686,KY00051,3
+10208007,IN03003,3
+18465136,IN03002,3
+166899251,IN03001,3
+166899200,IN03017,3
+166899204,OH00927,3
+166899203,OH00929,3
+5231436,OH00017,3
+3483493,OH00008,3
+15417757,OH00018,3
+76669453,WV00707,3
+19390686,OH00010,3
+19390726,OH00012,3
+15370770,OH00002,3
+167484603,OH00016,3
+166899180,OH00007,3
+167484552,OH00019,3
+15408897,OH00020,3
+15408959,OH00001,3
+3984810,OH00028,3
+18505514,IN03005,3
+10925571,PA00273,3
+166759236,AL01426,3
+166759211,AL01420,3
+1304859,TX00699,3
+17875083,CO01671,3
+167300345,AHDA4,4
+3745478,DIEA4,4
+3745526,DQDA4,4
+3745418,GLLA4,4
+630011,BKDO2,4
+617546,PCLO2,4
+591880,HGLO2,4
+8347705,MYST2,4
+167484743,MGCO2,4
+167300255,DSNT2,4
+167300271,ARBO2,4
+8357843,WRLO2,4
+13732800,SYOT2,4
+13756271,ALTO2,4
+3140356,FOSO2,4
+167300241,MTNO2,4
+681831,FTCO2,4
+481656,NRMO2,4
+167801019,EUFO2,4
+402142,TENO2,4
+6043008,WSLO2,4
+7801259,BMTA4,4
+7827790,NMBA4,4
+167299912,PENO2,4
+21772239,MFDO2,4
+167299918,GIBO2,4
+167299904,OOLO2,4
+20971700,KEYO2,4
+846266,BIRO2,4
+941070128,SKLO2,4
+371555,HEYO2,4
+389804,CNLO2,4
+13811164,FSLO2,4
+19980072,MRIT2,4
+21000069,GSPO2,4
+21160241,CHNK1,4
+21038107,KAWO2,4
+21514748,FLLK1,4
+21784832,HULO2,4
+21783714,CPLO2,4
+20943110,ECLK1,4
+21795481,BIGK1,4
+167297255,JRLK1,4
+20953830,TRLK1,4
+20927390,CNGK1,4
+20079044,EDRK1,4
+20917521,MLBK1,4
+21318615,GCDA3,4
+20584396,LYMA3,4
+120052904,RSVA3,4
+20476542,SMDA3,4
+20438850,VDBA3,4
+120053952,HORA3,4
+21383092,BWAA3,4
+120052757,CBDN2,4
+22071698,LKSA3,4
+20603252,PCON2,4
+20603248,MVDN2,4
+10022260,GUUU1,4
+17014523,FRVC2,4
+17034145,LPVC2,4
+3252975,BMDC2,4
+3251185,CRFC2,4
+3252989,MPSC2,4
+10814778,MYSU1,4
+120051930,OCEU1,4
+4876219,JOVU1,4
+4875263,ELLU1,4
+3906255,SFSU1,4
+4876263,MLSU1,4
+3180118,VEGC2,4
+3174852,RRGC2,4
+1336910,MDCC2,4
+1332558,TRBC2,4
+1312051,BLRC2,4
+1233515,CBGC2,4
+1233595,WCKC2,4
+1230577,WFRC2,4
+1311881,BGMC2,4
+11965847,STAU1,4
+11975087,LAAU1,4
+11964599,STIU1,4
+10375440,DCRU1,4
+10327875,UTLU1,4
+664014,HLZU1,4
+10273702,OPDU1,4
+10091588,ECWU1,4
+10276260,ECCU1,4
+10089124,CRDU1,4
+166248016,BRWU1,4
+120051967,MCWW4,4
+10038598,GRZU1,4
+18300278,BIGW4,4
+18352167,GBFW4,4
+3192800,VIVW4,4
+7897413,BLZI1,4
+4558474,BBOI1,4
+4467951,BEAI1,4
+20342929,HAWC1,4
+20332350,ELPC1,4
+20334374,SVIC1,4
+17573833,LKPC1,4
+17609317,CCHC1,4
+17568947,PYMC1,4
+22670080,ISAC1,4
+14930103,SCSC1,4
+120052624,TMDC1,4
+8210941,NACC1,4
+120053442,SNRC1,4
+17693799,LEXC1,4
+17693805,CADC1,4
+17693823,COYC1,4
+17693795,ANDC1,4
+21606713,MSWC1,4
+17080041,LNGC1,4
+120053836,FRAC1,4
+22050039,PFTC1,4
+8914219,BPRC1,4
+10742110,TOPN2,4
+17080669,HETC1,4
+17080601,CHVC1,4
+347987,KNFC1,4
+17065952,NHGC1,4
+3950979,CMCC1,4
+15021939,NIMC1,4
+130951632,LBEC1,4
+8271433,WSDC1,4
+8306696,LAMC1,4
+7993809,EPRC1,4
+7990259,SGEC1,4
+8005383,INVC1,4
+7989989,BLBC1,4
+12076080,ORDC1,4
+8060131,HLEC1,4
+15012277,CFWC1,4
+8060079,NBBC1,4
+8932994,DNRC1,4
+120053784,TAHC1,4
+8932970,BCVC1,4
+120053476,STPC1,4
+8932974,PSRC1,4
+2781993,WHSC1,4
+8245384,LLKC1,4
+361273,IRGC1,4
+15078462,BKDL1,4
+120053896,LBUL1,4
+8341399,WAGL1,4
+167300374,CRLL1,4
+19925795,BCEA4,4
+167182354,LCAL1,4
+19568056,UBRA1,4
+19626258,LBRA1,4
+19566308,CCRA1,4
+167182317,SRDM6,4
+18014672,GRNM6,4
+167166404,ENDM6,4
+22000120,DGDA4,4
+22697680,NADA4,4
+15231972,BMDA4,4
+167299819,GRRA4,4
+15252778,ARKM6,4
+166997625,NRMT1,4
+19667261,OCCT1,4
+19674973,HADT1,4
+19668381,BRDG1,4
+166997585,NOTG1,4
+166912876,FONN7,4
+166997584,CHAN7,4
+166997474,SHDT1,4
+166997499,WTGT1,4
+166997475,FPHT1,4
+166997501,CRKT1,4
+166997463,DUGT1,4
+166997561,NRST1,4
+120052259,NFDA4,4
+167299818,BSGA4,4
+7666880,CLRM7,4
+167166315,WPPM7,4
+120053459,JCKV2,4
+120053440,BCHP1,4
+1748473,DWNN6,4
+2613174,CNNN6,4
+167267899,STXM7,4
+7387259,PTXM7,4
+2992128,HILK1,4
+10114004,PLKK1,4
+167267891,MLVK1,4
+167266519,KANK1,4
+7330556,WLSK1,4
+167800866,MLFK1,4
+18880944,MTTK1,4
+746373,PRRK1,4
+3730511,CLIK1,4
+2529647,SLKM7,4
+4460822,LBRM7,4
+120053324,RADI4,4
+19040443,REPN1,4
+11758154,GPDN1,4
+6597410,SAYI4,4
+167121028,PELI4,4
+17539821,CRVI4,4
+120052268,STVC3,4
+6127281,SCIR1,4
+3247342,GBRN6,4
+22741995,HIKN6,4
+6719717,STDM1,4
+3318110,BNGM1,4
+166195943,RKWM1,4
+21980955,CPNN6,4
+166890766,SWRN6,4
+23927716,LOSO3,4
+24161747,DRBI1,4
+24518496,PRVO3,4
+23807386,SCOO3,4
+23979340,HAHW1,4
+24136807,CLEW1,4
+22971534,HHWM8,4
+167484418,SWJW2,4
+166899099,TYGW2,4
+3806779,YGOP1,4
+167484295,CMDP1,4
+4739601,CCDP1,4
+167484347,LHDP1,4
+13155459,KITO1,4
+13152651,MLPO1,4
+166899115,BRWO1,4
+13152353,MSQO1,4
+12996298,SHDP1,4
+10922417,TIOP1,4
+166899002,KNZP1,4
+6873355,GHDP1,4
+10361596,WDRF1,4
+166758723,FOGG1,4
+120052975,TYLA1,4
+21454020,MRFA1,4
+21638156,CLBA1,4
+166758703,WETG1,4
+167484077,CHDS1,4
+166759840,HRTG1,4
+6495106,CMMG1,4
+6495140,CVLG1,4
+6479321,CTRG1,4
+167496465,KERV2,4
+166737717,NUDN7,4
+166755060,NHPN7,4
+9250140,WLKN7,4
+8674019,PTTV2,4
+5569731,SOMT2,4
+3588682,SMCT2,4
+5670445,GGLT2,4
+2571688,BLNT2,4
+120053388,STIT2,4
+5670421,GNGT2,4
+1111211,TBLT2,4
+1158647,JSPT2,4
+1445978,BDWT2,4
+4132531,DAWT2,4
+166414857,ALAT2,4
+5531274,ACTT2,4
+120053204,WTYT2,4
+120053201,PCTT2,4
+120053389,SAGT2,4
+1267968,BNBT2,4
+120053021,LEWT2,4
+120051934,GPVT2,4
+1291638,LVNT2,4
+9051313,WCDP1,4
+22294608,HDLN6,4
+120053340,PNTT2,4
+5292739,LFKT2,4
+5278062,LCRT2,4
+5278562,LMVT2,4
+5278224,LMTT2,4
+8327942,BKLT2,4
+4451216,LPTT2,4
+1148575,SKCT2,4
+1304891,BPRT2,4
+120051933,EAMT2,4
+1267710,FLWT2,4
+1267898,LART2,4
+1269548,GPET2,4
+120053026,FRHT2,4
+120051936,TRNT2,4
+1492358,LVDT2,4
+5490089,LSWT2,4
+5489185,HAWT2,4
+5506926,LSFT2,4
+5525777,HCRT2,4
+5541638,SMKT2,4
+5494328,LMGT2,4
+120053359,PSMT2,4
+5495308,LPPT2,4
+120053199,GBYT2,4
+5511586,LCLT2,4
+2567012,LLET2,4
+5575089,LLST2,4
+120053033,LCTT2,4
+120053035,HSJT2,4
+5632093,JBTT2,4
+5635591,CCRT2,4
+5635571,CLRT2,4
+5722027,EVST2,4
+5721267,BLKT2,4
+5702167,TBRT2,4
+5740630,LKCT2,4
+5734861,LBWT2,4
+5753298,BCRT2,4
+5756886,BUDT2,4
+120053393,MSDT2,4
+1637751,CKDT2,4
+10834778,MDLT2,4
+120052363,CTDT2,4
+3169144,MTHT2,4
+3210503,RLAT2,4
+120052275,AMIT2,4
+120051895,FALT2,4
diff --git a/test/BMI/lastobs/nudgingLastObs.2021-08-23_12:00:00.nc b/test/BMI/lastobs/nudgingLastObs.2021-08-23_12:00:00.nc
new file mode 100644
index 000000000..71c90af89
Binary files /dev/null and b/test/BMI/lastobs/nudgingLastObs.2021-08-23_12:00:00.nc differ
diff --git a/test/BMI/lastobs/nudgingLastObs.2021-08-23_14:00:00.nc b/test/BMI/lastobs/nudgingLastObs.2021-08-23_14:00:00.nc
new file mode 100644
index 000000000..1831fc1e7
Binary files /dev/null and b/test/BMI/lastobs/nudgingLastObs.2021-08-23_14:00:00.nc differ
diff --git a/test/BMI/run_bmi_persistence_RFC_usingDAforcingModule.py b/test/BMI/run_bmi_persistence_RFC_usingDAforcingModule.py
new file mode 100644
index 000000000..85f992b51
--- /dev/null
+++ b/test/BMI/run_bmi_persistence_RFC_usingDAforcingModule.py
@@ -0,0 +1,355 @@
+#import sys
+import numpy as np
+import pandas as pd
+
+#sys.path.append("src/")
+import bmi_troute
+import bmi_reservoirs
+import bmi_DAforcing
+
+def create_output_dataframes(results, nts, waterbodies_df):
+    """
+    Run this model into the future, updating the state stored in the provided model dict appropriately.
+    Note that the model assumes the current values set for input variables are appropriately for the time
+    duration of this update (i.e., ``dt``) and do not need to be interpolated any here.
+    Parameters
+    ----------
+    results: list
+        The results from nwm_routing.
+    nts: int
+        The number of time steps the model was run.
+    waterbodies_df: pd.DataFrame
+        Dataframe containing waterbody parameters (specifically, IDs stored in index)
+    link_lake_crosswalk: dict #TODO: Can we remove this?
+        Relates lake ids to outlet link ids.
+    Returns
+    -------
+    q_channel_df: pandas.core.series.Series
+        Streamflow rate for each segment
+    v_channel_df: pandas.core.series.Series
+        Streamflow velocity for each segment
+    d_channel_df: pandas.core.series.Series
+        Streamflow depth for each segment
+    i_lakeout_df: pandas.core.series.Series
+        Inflow for each waterbody
+    q_lakeout_df: pandas.core.series.Series
+        Outflow for each waterbody
+    d_lakeout_df: pandas.core.series.Series
+        Water elevation for each waterbody
+    """
+    qvd_columns = pd.MultiIndex.from_product(
+        [range(int(nts)), ["q", "v", "d"]]
+    ).to_flat_index()
+    
+    flowveldepth = pd.concat(
+        [pd.DataFrame(r[1], index=r[0], columns=qvd_columns) for r in results], copy=False,
+    )
+    
+    # create waterbody dataframe for output to netcdf file
+    i_columns = pd.MultiIndex.from_product(
+        [range(int(nts)), ["i"]]
+    ).to_flat_index()
+    
+    wbdy = pd.concat(
+        [pd.DataFrame(r[6], index=r[0], columns=i_columns) for r in results],
+        copy=False,
+    )
+    
+    wbdy_id_list = waterbodies_df.index.values.tolist()
+
+    i_lakeout_df = wbdy.loc[wbdy_id_list].iloc[:,-1]
+    q_lakeout_df = flowveldepth.loc[wbdy_id_list].iloc[:,-3]
+    d_lakeout_df = flowveldepth.loc[wbdy_id_list].iloc[:,-1]
+    #lakeout = pd.concat([i_df, q_df, d_df], axis=1)
+    
+    # replace waterbody lake_ids with outlet link ids
+    #TODO Update the following line to fit with HyFeatures. Do we need to replace IDs? Or replace
+    # waterbody_ids with the downstream segment?
+    #flowveldepth = _reindex_lake_to_link_id(flowveldepth, link_lake_crosswalk)
+    
+    q_channel_df = flowveldepth.iloc[:,-3]
+    v_channel_df = flowveldepth.iloc[:,-2]
+    d_channel_df = flowveldepth.iloc[:,-1]
+    
+    segment_ids = flowveldepth.index.values.tolist()
+
+    return flowveldepth, wbdy #q_channel_df, v_channel_df, d_channel_df, i_lakeout_df, q_lakeout_df, d_lakeout_df#, wbdy_id_list, 
+
+#----------------------------------------------------------------
+# Full model
+#----------------------------------------------------------------
+# Initialize model with configuration file
+full_model = bmi_troute.bmi_troute()
+full_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_large_example.yaml')
+
+# Set static values
+#flowpaths layer parameters
+full_model.set_value('id', np.array([1056,385,156,158,159,157]))
+full_model.set_value('toid', np.array([157,157,157,159,160,158]))
+full_model.set_value('lengthkm', np.array([3.383,7.247,2.090,2.059,3.909,1.568]))
+#flowpath_attributes layer parameters
+full_model.set_value('attributes_id', np.array([1056,385,156,158,159,157]))
+full_model.set_value('rl_gages', np.array(['08117995', '08124000', '08130700', 'NULL', 'NULL', 'NULL']))
+full_model.set_value('rl_NHDWaterbodyComID', np.array(['NULL', 'NULL', 'NULL','NULL', 'NULL', 157 ]))
+full_model.set_value('n', np.array([0.060000,0.059635,0.050000,0.057287,0.050000,0.055400]))
+full_model.set_value('nCC', np.array([0.120000,0.119270,0.100000,0.114575,0.100000,0.110800]))
+full_model.set_value('So', np.array([0.011690,0.018579,0.000211,0.030771,0.002016,0.017703]))
+full_model.set_value('BtmWdth', np.array([2.860991,2.809054,19.379018,6.677849,20.134363,9.857479]))
+full_model.set_value('TopWdth', np.array([4.768318,4.681756,32.298364,11.129749,33.557271,16.429131]))
+full_model.set_value('TopWdthCC', np.array([14.304953,14.045269,96.895086,33.389247,100.671812,49.287396]))
+full_model.set_value('alt', np.array([1.0,1.0,1.0,1.0,1.0,1.0]))
+full_model.set_value('MusK', np.array([3600.0,3600.0,3600.0,3600.0,3600.0,3600.0]))
+full_model.set_value('MusX', np.array([0.2,0.2,0.2,0.2,0.2,0.2]))
+full_model.set_value('ChSlp', np.array([0.585855,0.610357,0.251915,0.581235,0.247701,0.519852]))
+#Waterbody parameters
+full_model.set_value('waterbody_id', np.array([157]))
+full_model.set_value('waterbody_toid', np.array([158]))
+full_model.set_value('LkArea', np.array([61.150299]))
+full_model.set_value('LkMxE', np.array([201.179993]))
+full_model.set_value('OrificeA', np.array([1.0]))
+full_model.set_value('OrificeC', np.array([0.1]))
+full_model.set_value('OrificeE', np.array([190.559998]))
+full_model.set_value('WeirC', np.array([0.4]))
+full_model.set_value('WeirE', np.array([199.586993]))
+full_model.set_value('WeirL', np.array([10.0]))
+full_model.set_value('ifd', np.array([0.9]))
+full_model.set_value('reservoir_type', np.array([2]))
+
+
+#-----------------------
+# Split model
+#-----------------------
+# Initialize routing models with configuration file
+upper_routing_model = bmi_troute.bmi_troute()
+upper_routing_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_upper_example.yaml')
+
+lower_routing_model = bmi_troute.bmi_troute()
+lower_routing_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_lower_example.yaml')
+
+# Initialize reservoir model
+reservoir_model = bmi_reservoirs.bmi_reservoir()
+reservoir_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_reservoir_example.yaml')
+
+# Set static values
+#flowpaths layer parameters
+upper_routing_model.set_value('id', np.array(['wb-1056','wb-385','wb-156']))
+upper_routing_model.set_value('toid', np.array(['nex-157','nex-157','nex-157']))
+upper_routing_model.set_value('lengthkm', np.array([3.383,7.247,2.090]))
+#flowpath_attributes layer parameters
+upper_routing_model.set_value('attributes_id', np.array(['wb-1056','wb-385','wb-156']))
+upper_routing_model.set_value('rl_gages', np.array(['08117995', '08124000', '08130700']))
+upper_routing_model.set_value('rl_NHDWaterbodyComID', np.array([None, None, None]))
+upper_routing_model.set_value('n', np.array([0.060000,0.059635,0.050000]))
+upper_routing_model.set_value('nCC', np.array([0.120000,0.119270,0.100000]))
+upper_routing_model.set_value('So', np.array([0.011690,0.018579,0.000211]))
+upper_routing_model.set_value('BtmWdth', np.array([2.860991,2.809054,19.379018]))
+upper_routing_model.set_value('TopWdth', np.array([4.768318,4.681756,32.298364]))
+upper_routing_model.set_value('TopWdthCC', np.array([14.304953,14.045269,96.895086]))
+upper_routing_model.set_value('alt', np.array([1.0,1.0,1.0]))
+upper_routing_model.set_value('MusK', np.array([3600.0,3600.0,3600.0]))
+upper_routing_model.set_value('MusX', np.array([0.2,0.2,0.2]))
+upper_routing_model.set_value('ChSlp', np.array([0.585855,0.610357,0.251915]))
+upper_routing_model.set_value('network_id', np.array(['wb-1056','wb-385','wb-156']))
+upper_routing_model.set_value('hydroseq', np.array([1,2,3]) )
+upper_routing_model.set_value('hl_uri', np.array(['Gages-08117995', 'Gages-08124000', 'Gages-08130700']))
+
+#flowpaths layer parameters, lower
+lower_routing_model.set_value('id', np.array(['wb-158','wb-159','wb-157']))
+lower_routing_model.set_value('toid', np.array(['nex-159','nex-160','nex-158']))
+lower_routing_model.set_value('lengthkm', np.array([2.059,3.909,1.568]))
+#flowpath_attributes parameters
+lower_routing_model.set_value('attributes_id', np.array(['wb-158','wb-159','wb-157']))
+lower_routing_model.set_value('rl_gages', np.array([None, None, None]))
+lower_routing_model.set_value('rl_NHDWaterbodyComID', np.array([None, None, None]))
+lower_routing_model.set_value('n', np.array([0.057287,0.050000,0.055400]))
+lower_routing_model.set_value('nCC', np.array([0.114575,0.100000,0.110800]))
+lower_routing_model.set_value('So', np.array([0.030771,0.002016,0.017703]))
+lower_routing_model.set_value('BtmWdth', np.array([6.677849,20.134363,9.857479]))
+lower_routing_model.set_value('TopWdth', np.array([11.129749,33.557271,16.429131]))
+lower_routing_model.set_value('TopWdthCC', np.array([33.389247,100.671812,49.287396]))
+lower_routing_model.set_value('alt', np.array([1.0,1.0,1.0]))
+lower_routing_model.set_value('MusK', np.array([3600.0,3600.0,3600.0]))
+lower_routing_model.set_value('MusX', np.array([0.2,0.2,0.2]))
+lower_routing_model.set_value('ChSlp', np.array([0.581235,0.247701,0.519852]))
+lower_routing_model.set_value('network_id', np.array(['wb-158','wb-159','wb-157']))
+lower_routing_model.set_value('hydroseq', np.array([5, 6, 4]) )
+lower_routing_model.set_value('hl_uri', np.array([None, None, None]))
+
+
+# build RFC DA forcing and related inputs
+DAforcing_model = bmi_DAforcing.bmi_DAforcing()
+DAforcing_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_large_example.yaml')
+# input argument to DA forcing preprocess module
+#DAforcing_model.set_value('rfc_gage_id', np.array(['KNFC1']))
+DAforcing_model.set_value('waterbody__lake_number', np.array(['347987'])) # assume 157 <- 347987
+DAforcing_model.set_value('waterbody__type_number', np.array([2]))
+DAforcing_model.update()
+
+
+# Initialize reservoir model
+reservoir_model = bmi_reservoirs.bmi_reservoir()
+reservoir_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_reservoir_example.yaml')
+
+# move DA forcing data obtained from DAforcing_model to reservoir_model
+#Waterbody parameters
+reservoir_model.set_value('hl_link', np.array([347987]))
+#reservoir_model.set_value('waterbody_toid', np.array([158]))
+reservoir_model.set_value('LkArea', np.array([61.150299]))
+reservoir_model.set_value('LkMxE', np.array([201.179993]))
+reservoir_model.set_value('OrificeA', np.array([1.0]))
+reservoir_model.set_value('OrificeC', np.array([0.1]))
+reservoir_model.set_value('OrificeE', np.array([190.559998]))
+reservoir_model.set_value('WeirC', np.array([0.4]))
+reservoir_model.set_value('WeirE', np.array([199.586993]))
+reservoir_model.set_value('WeirL', np.array([10.0]))
+reservoir_model.set_value('ifd', np.array([0.9]))
+reservoir_model.set_value('reservoir_type', np.array(DAforcing_model._model._res_type))
+
+if DAforcing_model._model._res_type==4 or DAforcing_model._model._res_type==5:
+    reservoir_model.set_value('lake_number', DAforcing_model._values['lake_number'] )
+    reservoir_model.set_value('reservoir_type', np.array(DAforcing_model._model._res_type))
+    reservoir_model.set_value('use_RFC', np.array(DAforcing_model._model._use_RFC)) 
+    reservoir_model.set_value('rfc_timeseries_discharges',  np.array(DAforcing_model._model._rfc_timeseries_discharges))
+    reservoir_model.set_value('rfc_timeseries_idx',  np.array(DAforcing_model._model._rfc_timeseries_idx)) 
+    reservoir_model.set_value('rfc_timeseries_update_time',  np.array(DAforcing_model._model._rfc_update_time))
+    reservoir_model.set_value('rfc_da_time_step',  np.array(DAforcing_model._model._da_time_step))
+    reservoir_model.set_value('rfc_total_counts',  np.array(DAforcing_model._model._total_counts))  
+    reservoir_model.set_value('rfc_timeseries_file',  np.array(DAforcing_model._model._rfc_timeseries_file))
+    reservoir_model.set_value('lake_surface__elevation', np.array([-1.000000e+09]))
+
+if DAforcing_model._model._res_type==2 or DAforcing_model._model._res_type==3:
+    #DA forcing for usgs_df
+    upper_routing_model.set_value('gages', np.array(['1056','08117995','385','08124000','156','08130700']))
+    #upper_routing_model.set_value('usgs_timeslice_discharge', np.array([1,2,3,4,5,6]))
+    #upper_routing_model.set_value('usgs_timeslice_stationId', np.array(['01012570', '01013500', '01012515', '01012570', '01013500', '01012515']))
+    #upper_routing_model.set_value('usgs_timeslice_time', np.array(['2015-08-16_00:00:00','2015-08-16_00:03:00','2015-08-16_00:03:00',
+    #                                                '2015-08-16_00:15:00', '2015-08-16_00:18:00','2015-08-16_00:18:00']))
+    #upper_routing_model.set_value('usgs_timeslice_discharge_quality', np.array([100,100,100,100,100,100]))
+    upper_routing_model.set_value('usgs_timeslice_discharge', np.array(DAforcing_model._model._timeslice_obs))
+    upper_routing_model.set_value('usgs_timeslice_stationId', np.array(DAforcing_model._model._timeslice_stationId))
+    upper_routing_model.set_value('usgs_timeslice_time', np.array(DAforcing_model._model._timeslice_datetime))
+    upper_routing_model.set_value('usgs_timeslice_discharge_quality', np.array(DAforcing_model._model._timeslice_discharge_quality))
+
+    #DA forcing for last_obs_df
+    upper_routing_model.set_value('lastobs_discharge', np.array(DAforcing_model._model._lastobs_discharge))
+    upper_routing_model.set_value('time_since_lastobs', np.array(DAforcing_model._model._time_since_lastobs))
+    upper_routing_model.set_value('lastobs_stationId', np.array(DAforcing_model._model._lastobs_stationId))    
+
+# Create random forcing values
+forcing_vals = np.random.gamma(1,1,6*120).reshape(120,6)
+gage_vals = np.random.gamma(1,1,1*120)
+gage_times = np.arange(0.0,120*3600,3600)
+# input some NaNs to see how persistence module handles missing values
+gage_vals[25:73] = np.nan
+
+reservoir_model.set_value('gage_observations', gage_vals)
+reservoir_model.set_value('gage_time', gage_times)
+# input for RFC reservoir DA
+
+#reservoir_model.set_value('rfc_timeseries_offset_hours', np.array([28]))
+#reservoir_model.set_value('rfc_forecast_persist_days',np.array([11]))
+        
+full_fvd = pd.DataFrame()
+full_wbdy = pd.DataFrame()
+upper_fvd = pd.DataFrame()
+lower_fvd = pd.DataFrame()
+res_fvd = pd.DataFrame()
+for hr in range(120):
+    '''
+    # Full network
+    # Set dynamic values
+    full_model.set_value('land_surface_water_source__volume_flow_rate', forcing_vals[hr,:])
+    full_model.set_value('gage_observations', gage_vals)
+    full_model.set_value('gage_time', gage_times)
+    full_model.update_until(3600)
+    
+    flowveldepth, wbdy = create_output_dataframes(full_model._model._run_results, 
+                                                  3600/full_model._model._time_step, 
+                                                  full_model._model._network.waterbody_dataframe)
+    pdb.set_trace()
+    full_fvd = pd.concat([full_fvd, flowveldepth], axis=1)
+    full_wbdy = pd.concat([full_wbdy, wbdy], axis=1)
+    '''
+     # Split network
+    # Set dynamic values
+    /home/dongha.kim/github/t-route/test/inputupper_routing_model.set_value('land_surface_water_source__volume_flow_rate', forcing_vals[hr,0:3])
+    upper_routing_model.update_until(3600)
+    flowveldepth, wbdy = create_output_dataframes(upper_routing_model._model._run_results, 
+                                                  3600/upper_routing_model._model._time_step, 
+                                                  upper_routing_model._model._network.waterbody_dataframe)
+    upper_fvd = pd.concat([upper_fvd, flowveldepth], axis=1)
+
+    reservoir_inflow = flowveldepth.loc[[1056,385,156]].sum()[0::3].to_numpy()
+    # test
+    '''
+    reservoir_inflow = np.array([0.038284,
+                                 0.105146,
+                                 0.219112,
+                                 0.381832,
+                                 0.544385,
+                                 0.701310,
+                                 0.849002,
+                                 0.985553,
+                                 1.111356,
+                                 1.224970,
+                                 1.326913,
+                                 1.419024])
+    '''
+    reservoir_inflow = np.array([187,
+                                185,
+                                183,
+                                181,
+                                179,
+                                177,
+                                175,
+                                173,
+                                171,
+                                169,
+                                167,
+                                165,
+                                163,
+                                161,
+                                159,
+                                157,
+                                155,
+                                153,
+                                151,
+                                149,
+                                147,
+                                145,
+                                143,
+                                141,
+                                139])
+
+    reservoir_model.set_value('lake_water~incoming__volume_flow_rate', reservoir_inflow)
+    reservoir_model.update_until(3600)
+    ## here here lover
+    upstream_fvd = np.asarray(
+        [
+        item for sublist in zip(reservoir_model._model._outflow_list,
+                                np.zeros(len(reservoir_model._model._outflow_list)).tolist(),
+                                reservoir_model._model._water_elevation_list) for item in sublist
+        ]
+    )
+    reservoir_model._model._outflow_list = []
+    reservoir_model._model._water_elevation_list = []
+    
+
+    lower_routing_model.set_value('land_surface_water_source__volume_flow_rate', forcing_vals[hr,3:6])
+    lower_routing_model.set_value('upstream_id', np.array([int(157)]))
+    lower_routing_model.set_value('upstream_fvd', upstream_fvd)
+    lower_routing_model.update_until(3600)
+
+    flowveldepth, wbdy = create_output_dataframes(lower_routing_model._model._run_results, 
+                                                  3600/lower_routing_model._model._time_step, 
+                                                  lower_routing_model._model._network.waterbody_dataframe)
+    
+    lower_fvd = pd.concat([lower_fvd, flowveldepth], axis=1)
+    res_fvd = pd.concat([res_fvd, pd.DataFrame(upstream_fvd.reshape(12,3))], axis=0)
+
+full_fvd.to_csv('/home/dongha.kim/github/t-route/temp_output/persistence/full_fvd.csv')
+upper_fvd.to_csv('/home/dongha.kim/github/t-route/temp_output/persistence/upper_fvd.csv')
+lower_fvd.to_csv('/home/dongha.kim/github/t-route/temp_output/persistence/lower_fvd.csv')
+res_fvd.to_csv('/home/dongha.kim/github/t-route/temp_output/persistence/res_fvd.csv')
+pd.DataFrame({'Gage_Time': gage_times,
+              'Gage_Values': gage_vals}).to_csv('/home/dongha.kim/github/t-route/temp_output/persistence/gage.csv')
diff --git a/test/BMI/run_bmi_troute_example.py b/test/BMI/run_bmi_troute_example.py
new file mode 100644
index 000000000..53f5985ec
--- /dev/null
+++ b/test/BMI/run_bmi_troute_example.py
@@ -0,0 +1,171 @@
+#import sys
+import numpy as np
+import pandas as pd
+import pickle
+
+#sys.path.append("src/")
+import bmi_troute
+import bmi_DAforcing
+
+
+def numeric_id(df):
+    toid = df['toid'].split('-')[-1]
+    df['toid'] = int(toid)
+    return df
+
+def read_bmi_input_data(filename):
+    with open(filename, 'rb') as h:
+        df, wbdy_df = pickle.load(h)
+
+    #Remove string prefix from wbdy['toid']
+    wbdy_df =pd.DataFrame(wbdy_df)
+    wbdy_df = wbdy_df.apply(numeric_id, axis=1)
+
+    df_dict = df.reset_index().to_dict('list')
+    wbdy_dict = wbdy_df.reset_index().to_dict('list')
+
+    return df_dict, wbdy_dict
+
+
+###############################################
+#TEMP
+from datetime import timedelta
+def lastobs_df_output(
+    lastobs_df,
+    dt,
+    nts,
+    t0,
+    gages,
+):
+
+    # join gageIDs to lastobs_df
+    lastobs_df = lastobs_df.join(gages)
+
+    # timestamp of last simulation timestep
+    modelTimeAtOutput = t0 + timedelta(seconds = nts * dt)
+    modelTimeAtOutput_str = modelTimeAtOutput.strftime('%Y-%m-%d_%H:%M:%S')
+
+    # timestamp of last observation
+    var = [timedelta(seconds=d) for d in lastobs_df.time_since_lastobs.fillna(0)]
+    lastobs_timestamp = [modelTimeAtOutput - d for d in var]
+    lastobs_timestamp_str = [d.strftime('%Y-%m-%d_%H:%M:%S') for d in lastobs_timestamp]
+    lastobs_timestamp_str_array = np.asarray(lastobs_timestamp_str,dtype = '|S19').reshape(len(lastobs_timestamp_str),1)
+
+    return lastobs_timestamp_str_array
+###################################################
+
+
+
+#----------------------------------------------------------------
+# Full model
+#----------------------------------------------------------------
+# Initialize model with configuration file
+full_model = bmi_troute.bmi_troute()
+full_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_large_example.yaml')
+
+# Set static values
+# Read from pickle file to imitate BMI set_value function
+df_dict, wbdy_dict = read_bmi_input_data('/home/dongha.kim/github/t-route/temp_input/bmi_input/bmi_input_data.pickle')
+
+#Segment parameters
+full_model.set_value('segment_id', np.array(df_dict['key']))
+full_model.set_value('segment_toid', np.array(df_dict['downstream']))
+full_model.set_value('dx', np.array(df_dict['dx']))
+full_model.set_value('n', np.array(df_dict['n']))
+full_model.set_value('ncc', np.array(df_dict['ncc']))
+full_model.set_value('s0', np.array(df_dict['s0']))
+full_model.set_value('bw', np.array(df_dict['bw']))
+full_model.set_value('tw', np.array(df_dict['tw']))
+full_model.set_value('twcc', np.array(df_dict['twcc']))
+full_model.set_value('alt', np.array(df_dict['alt']))
+full_model.set_value('musk', np.array(df_dict['musk']))
+full_model.set_value('musx', np.array(df_dict['musx']))
+full_model.set_value('cs', np.array(df_dict['cs']))
+
+#Waterbody parameters
+full_model.set_value('waterbody_id', np.array(wbdy_dict['wb-id']))
+full_model.set_value('waterbody_toid', np.array(wbdy_dict['toid']))
+full_model.set_value('LkArea', np.array(wbdy_dict['LkArea']))
+full_model.set_value('LkMxE', np.array(wbdy_dict['LkMxE']))
+full_model.set_value('OrificeA', np.array(wbdy_dict['OrificeA']))
+full_model.set_value('OrificeC', np.array(wbdy_dict['OrificeC']))
+full_model.set_value('OrificeE', np.array(wbdy_dict['OrificeE']))
+full_model.set_value('WeirC', np.array(wbdy_dict['WeirC']))
+full_model.set_value('WeirE', np.array(wbdy_dict['WeirE']))
+full_model.set_value('WeirL', np.array(wbdy_dict['WeirL']))
+full_model.set_value('ifd', np.array(wbdy_dict['ifd']))
+full_model.set_value('reservoir_type', np.array([1,1,1,1,1]))
+
+# Create random forcing values
+n_segment = 313
+n_simhr = 120
+forcing_vals = np.random.gamma(1,1,n_segment*n_simhr).reshape(n_simhr,n_segment)
+gage_vals = np.random.gamma(1,1,1*n_simhr)
+gage_times = np.arange(0.0,n_simhr*3600,3600)  # 3600 for converting hr to sec
+# input some NaNs to see how persistence module handles missing values
+gage_vals[25:73] = np.nan
+
+# pairs of (flowpath ID, usgs station ID)
+full_model.set_value('gages', np.array(['135','01012570','160','01013500','324','01012515']))
+
+# Set DA values
+# usgs_df
+full_model.set_value('usgs_timeslice_discharge', np.array([1,2,3,4,5,6]))
+full_model.set_value('usgs_timeslice_stationId', np.array(['01012570', '01013500', '01012515', '01012570', '01013500', '01012515']))
+full_model.set_value('usgs_timeslice_time', np.array(['2015-08-16_00:00:00','2015-08-16_00:03:00','2015-08-16_00:03:00',
+                                                '2015-08-16_00:15:00', '2015-08-16_00:18:00','2015-08-16_00:18:00']))
+full_model.set_value('usgs_timeslice_discharge_quality', np.array([100,100,100,100,100,100]))
+
+# lastobs_df
+full_model.set_value('lastobs_discharge', np.array([1,2,3,4,5,6,7,8,9]))
+full_model.set_value('lastobs_stationIdInd', np.array([0,0,0,1,1,1,2,2,2])) 
+full_model.set_value('lastobs_timeInd', np.array([0,1,2,0,1,2,0,1,2]))
+full_model.set_value('lastobs_stationId', np.array(['01012570','01013500','01012515']))
+full_model.set_value('lastobs_time', np.array(['2015-08-15_23:15:00','2015-08-15_23:30:00','2015-08-15_23:45:00',
+                                               '2015-08-15_23:15:00','2015-08-15_23:30:00','2015-08-15_23:45:00',
+                                               '2015-08-15_23:15:00','2015-08-15_23:30:00','2015-08-15_23:45:00']))
+full_model.set_value('lastobs_modelTimeAtOutput', np.array(['2015-08-16_00:00:00']))
+
+#use a standalone DA forcing BMI module for creating DA timeseries and related parameters
+DAforcing_model = bmi_DAforcing.bmi_DAforcing()
+DAforcing_model.initialize(bmi_cfg_file='/home/dongha.kim/github/t-route/test/BMI/bmi_large_example.yaml')
+DAforcing_model.set_value('lake_number', np.array([347987]))
+DAforcing_model.set_value('reservoir_type', np.array([4]))
+DAforcing_model.update()
+import pdb; pdb.set_trace()
+full_model.set_value('rfc_discharges', np.array( DAforcing_model._model._rfc_timeseries_discharges))
+
+
+# Dataframes for saving all output
+full_fvd = pd.DataFrame()
+full_wbdy = pd.DataFrame()
+
+# Loop through hourly timesteps calling update_until
+for hr in range(120):
+    # Full network
+    # Set dynamic values
+    full_model.set_value('land_surface_water_source__volume_flow_rate', forcing_vals[hr,:])
+    #full_model.set_value('gage_observations', gage_vals)
+    #full_model.set_value('gage_time', gage_times)
+    nts = 1
+    n = nts*300
+    import pdb; pdb.set_trace()
+    full_model.update_until(n)
+    
+    test = lastobs_df_output(
+        full_model._model._data_assimilation.lastobs_df,
+        full_model._model._time_step,
+        nts,
+        full_model._model._network.t0 - timedelta(seconds=n),
+        full_model._model._network.link_gage_df)
+
+    import pdb; pdb.set_trace()
+    '''
+    flowveldepth = pd.DataFrame(full_model.get_value('fvd_results').reshape(313,36),index=full_model.get_value('fvd_index'))
+    full_fvd = pd.concat([full_fvd, flowveldepth], axis=1)
+    '''
+import pdb; pdb.set_trace()
+
+
+
+
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_14:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_14:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..0a5f38af4
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_14:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_14:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_14:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..5dfeaf541
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_14:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_14:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_14:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..e234f8c45
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_14:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_14:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_14:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..3dacf536c
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_14:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_15:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_15:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..96fffe6ad
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_15:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_15:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_15:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..63e8e428c
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_15:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_15:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_15:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..123299b5b
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_15:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_15:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_15:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..5c030d495
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_15:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_16:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_16:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..06729a1f7
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_16:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_16:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_16:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..7528a6057
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_16:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_16:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_16:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..0399885e5
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_16:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_16:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_16:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..5d9642729
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_16:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_17:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_17:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..a253936bd
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_17:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_17:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_17:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..205037853
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_17:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_17:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_17:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..2d7075f96
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_17:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_17:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_17:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..7af13f689
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_17:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_18:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_18:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..77da10e0b
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_18:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_18:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_18:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..582fc2d6a
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_18:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_18:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_18:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..07d26a768
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_18:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_18:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_18:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..1f61242e3
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_18:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_19:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_19:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..936e487db
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_19:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_19:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_19:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..27b3bd427
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_19:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_19:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_19:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..5464728d6
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_19:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_19:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_19:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..bf745b8d7
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_19:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_20:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_20:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..1aa8fdfe3
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_20:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_20:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_20:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..8602cf257
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_20:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_20:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_20:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..bb9b873cb
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_20:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_20:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_20:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..dd0603265
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_20:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_21:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_21:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..faed5d015
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_21:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_21:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_21:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..97fb6da28
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_21:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_21:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_21:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..c245b6a82
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_21:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_21:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_21:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..601a33a54
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_21:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_22:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_22:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..d6f95820d
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_22:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_22:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_22:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..95bcb393f
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_22:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_22:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_22:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..20bc3c96b
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_22:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_22:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_22:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..3101b3f72
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_22:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_23:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_23:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..052bef735
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_23:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_23:15:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_23:15:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..c2f80098e
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_23:15:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_23:30:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_23:30:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..cf8b968ae
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_23:30:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-23_23:45:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-23_23:45:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..bb08cedd4
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-23_23:45:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-24_19:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-24_19:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..eb8bd48f7
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-24_19:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-24_20:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-24_20:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..95c8bc259
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-24_20:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-24_21:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-24_21:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..6c61e8475
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-24_21:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-24_22:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-24_22:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..0f7cde9c4
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-24_22:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usace_TimeSlice/2021-08-24_23:00:00.15min.usaceTimeSlice.ncdf b/test/BMI/usace_TimeSlice/2021-08-24_23:00:00.15min.usaceTimeSlice.ncdf
new file mode 100644
index 000000000..4e462abeb
Binary files /dev/null and b/test/BMI/usace_TimeSlice/2021-08-24_23:00:00.15min.usaceTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_00:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_00:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..c6fb22307
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_00:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_00:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_00:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3c5dde839
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_00:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_00:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_00:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..fb8e495f2
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_00:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_00:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_00:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..21cbd92da
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_00:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_01:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_01:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..91d371630
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_01:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_01:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_01:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..f3d14b285
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_01:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_01:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_01:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..747ba514e
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_01:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_01:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_01:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..c87181f77
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_01:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_02:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_02:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..02a76f3a0
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_02:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_02:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_02:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..4ef72b20f
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_02:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_02:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_02:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..0a9610152
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_02:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_02:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_02:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..0a0c4f96a
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_02:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_03:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_03:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..4fa2a06b3
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_03:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_03:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_03:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3fad22c0f
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_03:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_03:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_03:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..78f88a9b1
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_03:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_03:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_03:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..1cbb8c591
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_03:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_04:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_04:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..df1275a08
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_04:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_04:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_04:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..9dbdede5e
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_04:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_04:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_04:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..7ec35be5c
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_04:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_04:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_04:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..be9fadbf8
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_04:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_05:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_05:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..ae0e4ce8d
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_05:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_05:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_05:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..f0a4b4c7c
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_05:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_05:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_05:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..4767789e1
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_05:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_05:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_05:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..0fc3ac989
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_05:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_06:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_06:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..8b2c92d5b
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_06:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_06:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_06:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..30df953b4
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_06:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_06:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_06:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..272d7d534
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_06:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_06:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_06:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..7632d42c8
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_06:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_07:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_07:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..292c1c216
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_07:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_07:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_07:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..68eb3a482
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_07:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_07:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_07:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3b0c6bfa0
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_07:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_07:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_07:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..64d499e82
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_07:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_08:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_08:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..1e8f35c88
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_08:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_08:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_08:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..7c10d73da
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_08:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_08:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_08:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..44db00c05
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_08:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_08:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_08:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..faf0dd744
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_08:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_09:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_09:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..cee143815
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_09:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_09:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_09:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..17796f1fa
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_09:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_09:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_09:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..c8a23d163
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_09:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_09:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_09:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3282d2ea2
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_09:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_10:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_10:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..ba035910f
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_10:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_10:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_10:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..726bb51bd
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_10:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_10:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_10:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..b5eba3312
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_10:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_10:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_10:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..4bf16e268
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_10:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_11:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_11:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3eb24bbc2
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_11:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_11:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_11:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..15c75b83a
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_11:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_11:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_11:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..683d4e57b
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_11:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_11:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_11:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..2fd77ead4
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_11:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_12:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_12:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..11905b01c
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_12:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_12:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_12:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..071c4ed79
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_12:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_12:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_12:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..abfa21d9d
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_12:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_12:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_12:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..20843f99e
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_12:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_13:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_13:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..0e14a7c2d
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_13:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_13:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_13:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..73a1365a7
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_13:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_13:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_13:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..2147fb0b9
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_13:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_13:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_13:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..815623f63
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_13:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_14:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_14:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..239dab9d6
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_14:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_14:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_14:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..05b175262
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_14:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_14:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_14:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..899f0e62d
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_14:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_14:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_14:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..e41ad701a
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_14:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_15:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_15:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..c9028f44d
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_15:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_15:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_15:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..97f2c6693
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_15:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_15:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_15:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..9fb0b3ffa
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_15:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_15:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_15:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..1d25df672
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_15:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_16:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_16:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..d27419f9c
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_16:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_16:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_16:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..f390fecb1
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_16:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_16:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_16:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..0d8b11086
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_16:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_16:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_16:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..66edd8d58
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_16:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_17:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_17:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..60ea3519a
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_17:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_17:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_17:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..ece3b3b88
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_17:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_17:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_17:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..1abb3b636
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_17:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_17:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_17:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..c0d691bb8
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_17:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_18:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_18:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..addf4f4a2
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_18:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_18:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_18:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..066e44a33
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_18:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_18:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_18:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..d30fb2d3f
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_18:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_18:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_18:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..e320e0748
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_18:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_19:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_19:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..645c04915
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_19:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_19:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_19:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..a8c11c0a1
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_19:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_19:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_19:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..91ac423fd
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_19:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_19:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_19:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..a20549dc5
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_19:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_20:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_20:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3ba6e5ccd
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_20:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_20:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_20:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..b6e4a334b
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_20:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_20:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_20:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..f9384c20a
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_20:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_20:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_20:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..ab7e3290b
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_20:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_21:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_21:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..b7a857494
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_21:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_21:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_21:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..5cbdfb68b
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_21:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_21:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_21:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..c9aa14367
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_21:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_21:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_21:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..167bed7df
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_21:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_22:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_22:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..be2a9b68e
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_22:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_22:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_22:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..22b4b5dbd
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_22:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_22:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_22:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..e31447184
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_22:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_22:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_22:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..3adac5349
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_22:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_23:00:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_23:00:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..5351957e6
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_23:00:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_23:15:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_23:15:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..babea0a8b
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_23:15:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_23:30:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_23:30:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..54249835f
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_23:30:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/BMI/usgs_TimeSlice/2021-08-23_23:45:00.15min.usgsTimeSlice.ncdf b/test/BMI/usgs_TimeSlice/2021-08-23_23:45:00.15min.usgsTimeSlice.ncdf
new file mode 100644
index 000000000..d1ede7488
Binary files /dev/null and b/test/BMI/usgs_TimeSlice/2021-08-23_23:45:00.15min.usgsTimeSlice.ncdf differ
diff --git a/test/ngen/demonstrate_BMI_CONUS.ipynb b/test/ngen/demonstrate_BMI_CONUS.ipynb
new file mode 100644
index 000000000..352028479
--- /dev/null
+++ b/test/ngen/demonstrate_BMI_CONUS.ipynb
@@ -0,0 +1,1860 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run t-route through BMI functions"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import glob\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import geopandas as gpd\n",
+    "import xarray as xr\n",
+    "\n",
+    "sys.path.append(\"../t-route/src/\")\n",
+    "import bmi_troute"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load geopackage data tables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "file_path = '/home/sean.horvath/projects/data/large_network/conus.gpkg'\n",
+    "flowpaths = gpd.read_file(file_path, layer='flowpaths')\n",
+    "flowpath_attributes = gpd.read_file(file_path, layer='flowpath_attributes')\n",
+    "lakes = gpd.read_file(file_path, layer='lakes')\n",
+    "network = gpd.read_file(file_path, layer='network')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Initialize our t-route model and set static variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize model with configuration file\n",
+    "troute = bmi_troute.bmi_troute()\n",
+    "troute.initialize(bmi_cfg_file='/home/sean.horvath/projects/t-route/test/ngen/test_conus_AnA.yaml')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Provide t-route model each geopackage table column for static variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "troute.set_value('id', np.array(flowpaths['id']))\n",
+    "troute.set_value('toid', np.array(flowpaths['toid']))\n",
+    "troute.set_value('lengthkm', np.array(flowpaths['lengthkm']))\n",
+    "troute.set_value('attributes_id', np.array(flowpath_attributes['id']))\n",
+    "troute.set_value('rl_gages', np.array(flowpath_attributes['rl_gages']))\n",
+    "troute.set_value('rl_NHDWaterbodyComID', np.array(flowpath_attributes['rl_NHDWaterbodyComID']))\n",
+    "troute.set_value('MusK', np.array(flowpath_attributes['MusK']))\n",
+    "troute.set_value('MusX', np.array(flowpath_attributes['MusX']))\n",
+    "troute.set_value('n', np.array(flowpath_attributes['n']))\n",
+    "troute.set_value('So', np.array(flowpath_attributes['So']))\n",
+    "troute.set_value('ChSlp', np.array(flowpath_attributes['ChSlp']))\n",
+    "troute.set_value('BtmWdth', np.array(flowpath_attributes['BtmWdth']))\n",
+    "troute.set_value('nCC', np.array(flowpath_attributes['nCC']))\n",
+    "troute.set_value('TopWdthCC', np.array(flowpath_attributes['TopWdthCC']))\n",
+    "troute.set_value('TopWdth', np.array(flowpath_attributes['TopWdth']))\n",
+    "troute.set_value('hl_link', np.array(lakes['hl_link']))\n",
+    "troute.set_value('ifd', np.array(lakes['ifd']))\n",
+    "troute.set_value('LkArea', np.array(lakes['LkArea']))\n",
+    "troute.set_value('LkMxE', np.array(lakes['LkMxE']))\n",
+    "troute.set_value('OrificeA', np.array(lakes['OrificeA']))\n",
+    "troute.set_value('OrificeC', np.array(lakes['OrificeC']))\n",
+    "troute.set_value('OrificeE', np.array(lakes['OrificeE']))\n",
+    "troute.set_value('WeirC', np.array(lakes['WeirC']))\n",
+    "troute.set_value('WeirE', np.array(lakes['WeirE']))\n",
+    "troute.set_value('WeirL', np.array(lakes['WeirL']))\n",
+    "troute.set_value('network_id', np.array(network['id']))\n",
+    "troute.set_value('hydroseq', np.array(network['hydroseq']))\n",
+    "troute.set_value('hl_uri', np.array(network['hl_uri']))\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Read forcing files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "forcing_files = glob.glob('/home/sean.horvath/projects/data/large_network/sample_qlat_files/2021*')\n",
+    "forcing_vals = pd.DataFrame()\n",
+    "for file in forcing_files:\n",
+    "    df = pd.read_csv(file).set_index('feature_id')\n",
+    "    if forcing_vals.empty:\n",
+    "        forcing_vals = df\n",
+    "    else:\n",
+    "        forcing_vals = pd.merge(forcing_vals, df, on='feature_id')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Read DA data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "usgs_timeslice_files = glob.glob('/home/sean.horvath/projects/data/extended_AnA/usgs_timeslices/*')\n",
+    "usgs_timeslice = pd.DataFrame()\n",
+    "for file in usgs_timeslice_files:\n",
+    "    df = xr.open_dataset(file).to_dataframe()\n",
+    "    usgs_timeslice = pd.concat([usgs_timeslice, df])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "usace_timeslice_files = glob.glob('/home/sean.horvath/projects/data/extended_AnA/usace_timeslices/*')\n",
+    "usace_timeslice = pd.DataFrame()\n",
+    "for file in usace_timeslice_files:\n",
+    "    df = xr.open_dataset(file).to_dataframe()\n",
+    "    if usace_timeslice.empty:\n",
+    "        usace_timeslice = df\n",
+    "    else:\n",
+    "        usace_timeslice = pd.concat([usace_timeslice, df])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run our model for 1 hour"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING: LEVELPOOL USING COLDSTART WATER ELEVATION\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING: LEVELPOOL USING COLDSTART WATER ELEVATION\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING: LEVELPOOL USING COLDSTART WATER ELEVATION\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:520: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n",
+      "/home/sean.horvath/projects/t-route/src/troute-routing/troute/routing/compute.py:524: FutureWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  pd.Series(index=lastobs_df_sub.index, name=\"Null\"),\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING: LEVELPOOL USING COLDSTART WATER ELEVATION\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Dataframes for saving all output\n",
+    "full_fvd = pd.DataFrame()\n",
+    "\n",
+    "# Loop through hourly timesteps calling update_until\n",
+    "for hr in range(4):\n",
+    "    # Full network\n",
+    "    # Set dynamic values\n",
+    "    troute.set_value('land_surface_water_source__volume_flow_rate', np.array(forcing_vals.iloc[:,hr]))\n",
+    "    troute.set_value('land_surface_water_source__id', np.array(forcing_vals.index))\n",
+    "\n",
+    "    # Set duration to run model for\n",
+    "    nts = 12\n",
+    "    n = nts*300\n",
+    "\n",
+    "    # Run our model\n",
+    "    troute.update_until(n)\n",
+    "\n",
+    "\n",
+    "    \n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/test/ngen/demonstrate_BMI_CONUS.py b/test/ngen/demonstrate_BMI_CONUS.py
new file mode 100644
index 000000000..320a9ea3f
--- /dev/null
+++ b/test/ngen/demonstrate_BMI_CONUS.py
@@ -0,0 +1,22 @@
+import sys
+import glob
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+import xarray as xr
+
+sys.path.append("../t-route/src/")
+import bmi_troute
+
+#--------- Load geopackage data tables
+
+file_path = '/home/dongha.kim/github/data/bmi_conus_hyfeature/conus.gpkg'
+flowpaths = gpd.read_file(file_path, layer='flowpaths')
+flowpath_attributes = gpd.read_file(file_path, layer='flowpath_attributes')
+lakes = gpd.read_file(file_path, layer='lakes')
+network = gpd.read_file(file_path, layer='network')
+
+import pdb; pdb.set_trace()
+# Initialize model with configuration file
+troute = bmi_troute.bmi_troute()
+troute.initialize(bmi_cfg_file='/home/sean.horvath/projects/t-route/test/ngen/test_conus_AnA.yaml')
\ No newline at end of file
diff --git a/test/ngen/test_AnA.yaml b/test/ngen/test_AnA.yaml
index 1794094fb..efbaf3320 100644
--- a/test/ngen/test_AnA.yaml
+++ b/test/ngen/test_AnA.yaml
@@ -1,4 +1,4 @@
-# $ python -m nwm_routing -f -V3 test_AnA.yaml
+c# $ python -m nwm_routing -f -V3 test_AnA.yaml
 #--------------------------------------------------------------------------------
 log_parameters:
     #----------