diff --git a/dorado/lagrangian_walker.py b/dorado/lagrangian_walker.py
index 4d312f7..5dd6cce 100644
--- a/dorado/lagrangian_walker.py
+++ b/dorado/lagrangian_walker.py
@@ -467,7 +467,7 @@ def steep_descent(probs):
     return idx
 
 
-def particle_stepper(Particles, current_inds, travel_times):
+def particle_stepper(Particles, current_inds, travel_times, start_optional):
     """Step particles a single iteration.
 
     **Inputs** :
@@ -481,6 +481,10 @@ def particle_stepper(Particles, current_inds, travel_times):
         travel_times : `list`
             List of initial travel times for the particles
 
+        start_optional: 'dict of lists'
+            A dictionary of lists of optional user inputs for the particle stepper. Options are shown in the particles object documentation.
+        
+
     **Outputs** :
 
         new_inds : `list`
@@ -488,8 +492,14 @@ def particle_stepper(Particles, current_inds, travel_times):
 
         travel_times : `list`
             List of the travel times associated with the particle movements
+            
+        updated_optional : `dict of lists`
+            A dictionary of lists of optional outputs for the particle stepper. Options are shown in the particles object documentation.
 
     """
+    # Use roi_grid from the particle object if it exists, otherwise use None
+    ROI = getattr(Particles, 'roi_grid', None)
+        
     inds = current_inds  # get indices as coordinates in the domain
     # split the indices into tuples
     inds_tuple = [(inds[i][0], inds[i][1]) for i in range(len(inds))]
@@ -522,4 +532,16 @@ def particle_stepper(Particles, current_inds, travel_times):
                     for i in range(0, len(travel_times))]
     travel_times = list(travel_times)
 
-    return new_inds, travel_times
+    # Optional variables
+    updated_optional = {}
+    
+    if ROI is not None:
+        updated_optional['roi_flag'] = [1 if ROI[x, y] == 1 else 0 for x, y in new_inds]
+
+    for var, _ in start_optional.items():
+        if var not in updated_optional:
+            if var in Particles.available_particle_vars:
+                grid = Particles.available_particle_vars[var]
+                updated_optional[var] = [grid[x, y] for x, y in new_inds]
+
+    return new_inds, travel_times, updated_optional
diff --git a/dorado/parallel_routing.py b/dorado/parallel_routing.py
index 774d4fe..38aee2a 100644
--- a/dorado/parallel_routing.py
+++ b/dorado/parallel_routing.py
@@ -33,8 +33,8 @@ class to hold a bunch of attributes and do the particle generation and
     **Outputs** :
 
         all_walk_data : `list`
-            Nested list of all x and y locations and travel times, with
-            details same as input previous_walk_data
+            Nested list of all x and y locations, travel times, and 
+            any optional variables, with details same as input previous_walk_data
 
     """
     pobj.particles.generate_particles(pobj.Np_tracer, pobj.seed_xloc,
@@ -59,27 +59,18 @@ def combine_result(par_result):
         par_result : `list`
             List of length(num_cores) with a dictionary of the beg/end indices
             and travel times for each particle computed by that process/core
-
+    
     **Outputs** :
-
-        single_result : `list`
-            Nested list that matches 'all_walk_data'
-
+        single_result : `dict`
+            Combined results dictionary containing all tracked variables.
     """
     # initiate final results dictionary
-    single_result = dict()
-    single_result['x_inds'] = []
-    single_result['y_inds'] = []
-    single_result['travel_times'] = []
+    single_result = {var: [] for var in par_result[0].keys()}
 
     # populate the dictionary
-    # loop through results for each core
-    for i in range(0, len(par_result)):
-        # append results for each category
-        for j in range(0, len(par_result[i][0])):
-            single_result['x_inds'].append(par_result[i][0][j])
-            single_result['y_inds'].append(par_result[i][1][j])
-            single_result['travel_times'].append(par_result[i][2][j])
+    for result in par_result:
+        for var in result.keys():
+            single_result[var].extend(result[var])
 
     return single_result
 
@@ -139,7 +130,7 @@ def parallel_routing(particles, num_iter, Np_tracer, seed_xloc, seed_yloc,
 
     """
     # make parallel object to assign to function
-    pobj = parallel_obj
+    pobj = parallel_obj()
     pobj.particles = particles
     pobj.num_iter = num_iter
     pobj.Np_tracer = Np_tracer
@@ -154,4 +145,7 @@ def parallel_routing(particles, num_iter, Np_tracer, seed_xloc, seed_yloc,
     par_result = p.map(run_iter, p_list)
     p.terminate()
 
-    return par_result
+    # combine results before returning to user
+    combined = combine_result(par_result)
+
+    return combined
diff --git a/dorado/particle_track.py b/dorado/particle_track.py
index 010bd93..00ec552 100644
--- a/dorado/particle_track.py
+++ b/dorado/particle_track.py
@@ -388,7 +388,19 @@ def __init__(self, params):
             self.angles = np.array([[3*pi/4, pi/2, pi/4],
                                     [pi, 0, 0],
                                     [5*pi/4, 3*pi/2, 7*pi/4]])
-
+            
+        # Binary roi in the shape of model grid for particle flagging with each step
+        if getattr(params, 'roi_grid', None) is not None:
+            if params.roi_grid.shape != self.depth.shape:
+                raise ValueError("roi_grid shape " + str(params.roi_grid.shape) +
+                                " does not match model grid shape " +
+                                str(self.depth.shape) +
+                                ". roi_grid must be the same shape as the depth array.")
+            self.roi_grid = params.roi_grid
+            logger.info("roi provided and stored in the particle object.")
+        else:
+            self.roi_grid = None
+                
         # initialize number of particles as 0
         self.Np_tracer = 0
 
@@ -398,6 +410,37 @@ def __init__(self, params):
         # initialize routing weights array
         lw.make_weight(self)
 
+        # -------------------------------------------------------
+        # Define additional variables to track with particle movement (beyond xinds, yinds, and travel_times)
+        # Usage: params = pt.modelParams(); params.particle_variables = ['depth', 'roi_flag']
+        # -------------------------------------------------------
+        # Base variables always stored
+        self.base_walk_variables = ['xinds', 'yinds', 'travel_times']
+
+        # Available grid variables that can be sampled
+        self.available_particle_vars = {
+            'depth': self.depth,
+            'stage': self.stage,
+            'qx': self.qx,
+            'qy': self.qy,
+            'u': self.u,
+            'v': self.v,
+        }
+
+        # Read optional variables from params
+        if getattr(params, 'particle_variables', None) is not None:
+            self.particle_variables = params.particle_variables
+        else:
+            self.particle_variables = []
+
+        if 'roi_flag' not in self.particle_variables and self.roi_grid is not None:
+            self.particle_variables.append('roi_flag')
+
+        # optional outputs follow particle variables
+        self.optional_outputs = list(self.particle_variables)
+
+        # Combine base + optional variables
+        self.tracked_variables = self.base_walk_variables + self.particle_variables
 
     # function to clear walk data if you've made a mistake while generating it
     def clear_walk_data(self):
@@ -474,6 +517,8 @@ def generate_particles(self,
                                                                      method)
 
         init_walk_data = dict()  # create init_walk_data dictionary
+        # define base variables again
+        base_vars = self.base_walk_variables
 
         # initialize new travel times list
         if (seed_time != 0) and (self.verbose is True):
@@ -512,6 +557,20 @@ def generate_particles(self,
         start_yindices = new_yinds
         start_times = new_times
 
+        # initialize optional variables from available_particle_vars
+        optional_start_vars = dict()
+        for var in self.tracked_variables:
+            if var not in base_vars:
+                if var == 'roi_flag' and self.roi_grid is not None:
+                    optional_start_vars[var] = [[1 if self.roi_grid[x, y] == 1 else 0]
+                                                for x, y in zip(new_start_xindices, new_start_yindices)]
+                elif var in self.available_particle_vars:
+                    grid_values = self.available_particle_vars[var]
+                    optional_start_vars[var] = [[grid_values[x, y]] for x, y in zip(new_start_xindices, new_start_yindices)]
+                else:
+                    raise ValueError(f"Variable {var} is not a recognized variable to track. Available variables are: {list(self.available_particle_vars.keys())} and 'roi_flag' (if roi_grid is provided).")
+
+
         if self.walk_data is not None:
             # if there is walk_data from a previous call to the generator,
             # or from simulating particle transport previously, then we want
@@ -524,6 +583,12 @@ def generate_particles(self,
             start_xindices = internal_xinds + start_xindices
             start_yindices = internal_yinds + start_yindices
             start_times = internal_times + start_times
+            
+            # merge optional variables with self.walk_data
+            for var, new_var_list in optional_start_vars.items():
+                if var in self.walk_data:
+                    internal_var = self.walk_data[var]
+                    optional_start_vars[var] = internal_var + new_var_list
 
         if previous_walk_data is not None:
             # If the generator has been run before, or if new
@@ -539,6 +604,12 @@ def generate_particles(self,
             start_yindices = prev_yinds + start_yindices
             start_times = prev_times + start_times
 
+            # merge optional variables with previous_walk_data
+            for var, new_var_list in optional_start_vars.items():
+                if var in previous_walk_data:
+                    prev_var = previous_walk_data[var]
+                    optional_start_vars[var] = prev_var + new_var_list
+
         # determine the new total number of particles we have now
         self.Np_tracer = len(start_xindices)
 
@@ -546,6 +617,7 @@ def generate_particles(self,
         init_walk_data['xinds'] = start_xindices
         init_walk_data['yinds'] = start_yindices
         init_walk_data['travel_times'] = start_times
+        init_walk_data.update(optional_start_vars)
 
         # store the initialized walk data within self
         self.walk_data = init_walk_data
@@ -607,6 +679,17 @@ def run_iteration(self, target_time=None, max_iter=1e4):
         all_times = self.walk_data['travel_times']
         start_times = [all_times[i][-1] for i in
                        list(range(self.Np_tracer))]
+        # optional variables
+        optional_vars = {}
+        for var in self.tracked_variables:
+            if var not in ['xinds', 'yinds', 'travel_times']:
+                if var in self.walk_data:
+                    optional_vars[var] = self.walk_data[var]
+                else:
+                    optional_vars[var] = [[None] for _ in range(self.Np_tracer)]
+        
+        start_optional = {var: [optional_vars[var][i][-1] for i in range(self.Np_tracer)]
+                        for var in optional_vars}
 
         # merge x and y indices into list of [x,y] pairs
         start_pairs = [[start_xindices[i], start_yindices[i]] for i in
@@ -615,8 +698,8 @@ def run_iteration(self, target_time=None, max_iter=1e4):
         # Do the particle movement
         if target_time is None:
             # If we're not aiming for a specific time, step the particles
-            new_inds, travel_times = lw.particle_stepper(self, start_pairs,
-                                                         start_times)
+            new_inds, travel_times, updated_optional = lw.particle_stepper(self, start_pairs,
+                                                         start_times, start_optional)
 
             for ii in list(range(self.Np_tracer)):
                 # Don't duplicate location
@@ -626,11 +709,15 @@ def run_iteration(self, target_time=None, max_iter=1e4):
                     all_xinds[ii].append(new_inds[ii][0])
                     all_yinds[ii].append(new_inds[ii][1])
                     all_times[ii].append(travel_times[ii])
-
+                    for var in optional_vars:
+                        optional_vars[var][ii].append(updated_optional[var][ii])
+                    
             # Store travel information in all_walk_data
             all_walk_data['xinds'] = all_xinds
             all_walk_data['yinds'] = all_yinds
             all_walk_data['travel_times'] = all_times
+            for var in optional_vars:
+                all_walk_data[var] = optional_vars[var]
 
         else:
             # If we ARE aiming for a specific time
@@ -657,10 +744,9 @@ def run_iteration(self, target_time=None, max_iter=1e4):
                     while abs(all_times[ii][-1] - target_time) >= \
                           abs(all_times[ii][-1] + est_next_dt - target_time):
                         # for particle ii, take a step from most recent index
-                        new_inds, travel_times = lw.particle_stepper(
-                            self, [[all_xinds[ii][-1], all_yinds[ii][-1]]],
-                            [all_times[ii][-1]])
-
+                        new_inds, travel_times, updated_optional = lw.particle_stepper(self, [[all_xinds[ii][-1], all_yinds[ii][-1]]],[all_times[ii][-1]],
+                                                                                       {var: [optional_vars[var][ii][-1]] for var in optional_vars})
+                
                         # Don't duplicate location
                         # if particle is standing still at a boundary
                         if new_inds[0] != [all_xinds[ii][-1],
@@ -668,6 +754,8 @@ def run_iteration(self, target_time=None, max_iter=1e4):
                             all_xinds[ii].append(new_inds[0][0])
                             all_yinds[ii].append(new_inds[0][1])
                             all_times[ii].append(travel_times[0])
+                            for var in optional_vars:
+                                optional_vars[var][ii].append(updated_optional[var][0])
                         else:
                             break
 
@@ -684,7 +772,9 @@ def run_iteration(self, target_time=None, max_iter=1e4):
             all_walk_data['xinds'] = all_xinds
             all_walk_data['yinds'] = all_yinds
             all_walk_data['travel_times'] = all_times
-
+            for var in optional_vars:
+                all_walk_data[var] = optional_vars[var]
+            
             # write out warning if particles exceed step limit
             if (len(_iter_particles) > 0) and (self.verbose is True):
                 warnings.warn(str(len(_iter_particles)) + "Particles"
@@ -917,7 +1007,7 @@ def exposure_time(walk_data,
     Np_tracer = len(walk_data['xinds'])  # Number of particles
     # Array to be populated
     exposure_times = np.zeros([Np_tracer], dtype='float')
-    # list of particles that don't exit ROI
+    # list of particles that don't exit roi
     _short_list = []
 
     # Loop through particles to measure exposure time
@@ -1244,3 +1334,61 @@ def interp_func(data):
     gridded_quantity = interp_func(quantity)
 
     return interp_func, gridded_quantity
+
+def flux_proportional_seeding(Q, 
+                             N_total,
+                             num_steps):
+    """ Compute flux-proportional particle counts per timestep.
+
+    This function is useful if seeding particles under unsteady discharge conditions
+    by enforcing that the number of particles seeded at each timestep is proportional 
+    to the magnitude of discharge at that timestep.
+
+    **Inputs** :
+    ----------
+        Q : 'np.ndarray'
+            Discharge array where:
+            rows = timestep since model start where seeding is occurring
+            column = discharge values at those intervals
+       
+        N_total : 'int'
+            Total number of particles to seed.
+
+        num_steps : 'int', 
+            Number of timesteps where seeding occurs.
+
+    **Outputs** :
+    -------
+
+        particles_per_timestep : `numpy.ndarray`
+            Array of integer particle counts per seeding timestep.
+
+    """
+    # Take absolute value for flow reversals
+    Q_abs = np.abs(Q)
+
+    # Ensure correct number of steps
+    if len(Q_abs) < num_steps:
+        raise ValueError("Not enough timesteps in the discharge array to match num_steps.")
+
+    # Ensure total discharge is nonzero
+    Q_sum = Q_abs.sum()
+    if Q_sum == 0:
+        raise ValueError("All discharge values are zero. Cannot distribute particles.")
+    
+    # Compute ideal particle counts
+    N_float = Q_abs / Q_abs.sum() * N_total
+    N_int = np.floor(N_float).astype(int)
+
+    # Remainder distribution
+    remainders = N_float - N_int
+    N_remaining = N_total - N_int.sum()
+
+    if N_remaining > 0:
+        add_idx = np.argsort(remainders)[-N_remaining:]
+        N_int[add_idx] += 1
+
+    # Final check
+    assert N_int.sum() == N_total, "Particle rounding failed!"
+
+    return N_int
\ No newline at end of file
diff --git a/dorado/routines.py b/dorado/routines.py
index 6b3ff3a..2d43068 100644
--- a/dorado/routines.py
+++ b/dorado/routines.py
@@ -400,7 +400,7 @@ def get_state(walk_data, iteration=-1, verbose=None):
     **Inputs** :
 
         walk_data : `dict`
-            Dictionary of all x and y locations and travel times
+            Dictionary of all x and y locations,travel times, and flags
 
         iteration : `int`, optional
             Iteration number at which to slice the dictionary. Defaults
@@ -423,6 +423,11 @@ def get_state(walk_data, iteration=-1, verbose=None):
         times : `list`
             List containing equivalent of
             walk_data['travel_times'][:][iteration]
+            
+        optional_data : `dict of lists`, optional 
+            A dictionary of lists of optional outputs for the particle stepper
+            containing equivalent of walk_data[var][:][iteration] for each var.
+
 
     """
     iteration = int(iteration)
@@ -431,18 +436,31 @@ def get_state(walk_data, iteration=-1, verbose=None):
     xinds = []
     yinds = []
     times = []
+    optional_data = {} 
+
     iter_exceeds_warning = 0
+
+    base_vars = ['xinds', 'yinds', 'travel_times']
+    optional_vars = [var for var in walk_data.keys() if var not in base_vars]
+
+    for key in optional_vars:
+        optional_data[key] = []
+
     # Pull out the specified value
     for ii in list(range(Np_tracer)):
         try:
             xinds.append(walk_data['xinds'][ii][iteration])
             yinds.append(walk_data['yinds'][ii][iteration])
             times.append(walk_data['travel_times'][ii][iteration])
+            for var in optional_vars:
+                optional_data[var].append(walk_data[var][ii][iteration])
         except IndexError:
             # If target iter exceeds walk history, return last iter
             xinds.append(walk_data['xinds'][ii][-1])
             yinds.append(walk_data['yinds'][ii][-1])
             times.append(walk_data['travel_times'][ii][-1])
+            for var in optional_vars:
+                optional_data[var].append(walk_data[var][ii][-1])
             iter_exceeds_warning += 1
 
     if iter_exceeds_warning > 0:
@@ -450,8 +468,10 @@ def get_state(walk_data, iteration=-1, verbose=None):
         logger.info('Note: %s particles have not reached %s iterations' % \
               (iter_exceeds_warning, iteration))
 
-    return xinds, yinds, times
-
+    if optional_vars:
+        return xinds, yinds, times, optional_data
+    else:
+        return xinds, yinds, times
 
 def get_time_state(walk_data, target_time, verbose=None):
     """Pull walk_data values nearest to a specific time.
@@ -489,12 +509,25 @@ def get_time_state(walk_data, target_time, verbose=None):
             to input. Times will differ slightly from input time due to
             the nature of the method.
 
+        optional_data : `dict of lists`, optional 
+            A dictionary of lists of optional outputs for the particle stepper
+            containing equivalent of walk_data[var][:][iteration] for each var.
+
+
     """
     Np_tracer = len(walk_data['xinds'])  # Number of particles
 
     xinds = []
     yinds = []
     times = []
+    optional_data = {}
+
+    base_vars = ['xinds', 'yinds', 'travel_times']
+    optional_vars = [var for var in walk_data.keys() if var not in base_vars]
+
+    for key in optional_vars:
+        optional_data[key] = []
+    
     # Pull out the specified value
     for ii in list(range(Np_tracer)):
         times_ii = np.array(walk_data['travel_times'][ii])
@@ -504,12 +537,16 @@ def get_time_state(walk_data, target_time, verbose=None):
         xinds.append(walk_data['xinds'][ii][tt])
         yinds.append(walk_data['yinds'][ii][tt])
         times.append(walk_data['travel_times'][ii][tt])
-
+        for var in optional_vars:
+            optional_data[var].append(walk_data[var][ii][tt])
         if times_ii[-1] < target_time:
             handle_verbose_deprecation(verbose)
             logger.info('Note: Particle '+str(ii)+' never reached target_time')
 
-    return xinds, yinds, times
+    if optional_vars:
+        return xinds, yinds, times, optional_data
+    else:
+        return xinds, yinds, times
 
 
 def plot_exposure_time(walk_data,
@@ -577,7 +614,7 @@ def plot_exposure_time(walk_data,
     # Initialize arrays to record exposure time of each particle
     Np_tracer = len(walk_data['xinds'])  # Number of particles
     # Record final travel times
-    x, y, end_time = get_state(walk_data)
+    x, y, end_time, optional_state = get_state(walk_data)
 
     # Handle the timedelta
     if timedelta == 1:
diff --git a/examples/particle_flagging_with_additional_outputs.ipynb b/examples/particle_flagging_with_additional_outputs.ipynb
new file mode 100644
index 0000000..fda32d8
--- /dev/null
+++ b/examples/particle_flagging_with_additional_outputs.ipynb
@@ -0,0 +1,537 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6bafbaeb",
+   "metadata": {},
+   "source": [
+    "## Example workflow to demonstrate particle flagging and optional outputs\n",
+    "### Eleanor Henson, March 2026\n",
+    "\n",
+    "This workbook provides a quick example workflow for tracking multiple variables not included in the original `walk_data`, i.e. any variables besides locations and travel times. This notebook uses the presaved `unstructured_model.txt` dictionary for the hydrodynamic inputs. For more information on generating those inputs, please refer to the `unstructured_grid_anuga.ipynb` notebook.\n",
+    "\n",
+    "In this notebook, we are specifically demonstrating a use-case of `dorado` to analyze \"potential nutrient transport and removal\" - citation hopefully coming soon. Two key factors of nutrient removal in hydrologic systems are the residence times and depths of soluble materials in particular regions. \n",
+    "\n",
+    "For this reason, we are show-casing the optional ability to track `depth` at each particle step along with a binary flag. The `roi_flag` in the particle `walk_data` is == 1 when the particle takes a step within a user-defined roi. In our example of nutrient removal, the roi may be an important indicator of heavily vegetated regions, stimulating removal potential."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e917f991",
+   "metadata": {},
+   "source": [
+    "### Import dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bcaca047",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import scipy\n",
+    "import matplotlib\n",
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "import json\n",
+    "import os\n",
+    "import dorado\n",
+    "import dorado.particle_track as pt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a4b9e96",
+   "metadata": {},
+   "source": [
+    "#### Load in model outputs\n",
+    "Again, we are using the same hydrodynamic data as `unstructured_grid_anuga.ipynb` - for more information on the functions used to set-up the particle routing with the hydrodynamic data, please refer to that notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0e0c3f52",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[(31, 42)]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(101.0, 1.0)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "unstructured = json.load(open('unstructured_model.txt'))\n",
+    "\n",
+    "# Combine (x,y) coordinates into a list of types for dorado to use\n",
+    "coordinates = [(unstructured['x'][i], unstructured['y'][i]) for i in list(range(len(unstructured['x'])))]\n",
+    "\n",
+    "# Run the unstruct2grid function once to acquire the Interp function for all variables\n",
+    "# Use IDW interpolation interpolate unstructured data into uniform grid\n",
+    "myInterp, depth = pt.unstruct2grid(coordinates, unstructured['depth'], 1.0, 3)\n",
+    "\n",
+    "# Grid other data products with new interpolation function\n",
+    "stage = myInterp(np.array(unstructured['stage']))\n",
+    "qx = myInterp(np.array(unstructured['qx']))\n",
+    "qy = myInterp(np.array(unstructured['qy']))\n",
+    "\n",
+    "# They previously found a nice release location - let's convert it to index notation:\n",
+    "seedloc = [(624464, 3347078)] # Coordinates are in meters UTM\n",
+    "\n",
+    "# Call the coordinate transform function\n",
+    "seedind = pt.coord2ind(seedloc, \n",
+    "                       (min(unstructured['x']), \n",
+    "                        min(unstructured['y'])), \n",
+    "                       np.shape(depth), 1.0)\n",
+    "print(seedind)\n",
+    "\n",
+    "# Visualize the location on our gridded depth array\n",
+    "plt.figure(figsize=(5,5), dpi=200)\n",
+    "plt.scatter(seedind[0][1], seedind[0][0], c='r')\n",
+    "plt.imshow(depth)\n",
+    "plt.colorbar(fraction=0.03)\n",
+    "plt.title('Gridded Depth Array')\n",
+    "plt.xlim([seedind[0][1]-40, seedind[0][1]+100])\n",
+    "plt.ylim([seedind[0][0]+70, seedind[0][0]-30])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d4bc67b",
+   "metadata": {},
+   "source": [
+    "#### Now we are going to use the depth array to define an arbitrary region we think may have enhanced nutrient processing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "89f2f86f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Gridded Depth Array')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Let's plot the depth\n",
+    "plt.figure(figsize=(5,5), dpi=200)\n",
+    "plt.imshow(depth, cmap='jet')\n",
+    "plt.colorbar(fraction=0.018)\n",
+    "plt.title('Gridded Depth Array')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "928587c2",
+   "metadata": {},
+   "source": [
+    "Let's theoretically say that any depths between 0.2m and 0.5m are ideal for some form of nutrient processing. Anytime a particle enters that region we want it to be flagged for potential uptake. Here we will make an roi corresponding to this criteria. \n",
+    "\n",
+    "Please note, this is not accurate for nutrient processing. The user should likely delineate the roi using a shapefile or such over the domain. In that case though, the user does have to ensure the shapefile is in the same gridded shape as the model domain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ec28f218",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0. 1.]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Gridded ROI for Flagging')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Let's base the roi on depth\n",
+    "roi_grid = np.zeros_like(depth)\n",
+    "roi_grid[(depth > 0.2) & (depth < 0.5)] = 1\n",
+    "\n",
+    "print(np.unique(roi_grid))\n",
+    "\n",
+    "# Let's plot the roi\n",
+    "plt.figure(figsize=(5,5), dpi=200)\n",
+    "plt.imshow(roi_grid, cmap='seismic')\n",
+    "plt.colorbar(fraction=0.018)\n",
+    "plt.title('Gridded ROI for Flagging')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "088f13fb",
+   "metadata": {},
+   "source": [
+    "#### Set up particle class\n",
+    "We can input any of the hydrodynamic variables dorado uses (`u`, `v`, `qx`, `qy`, `depth`, `stage`) to the `particle_variables` in the `modelParams` class to track along with particle movement. Here we are going to assign the roi we built and track depth, along with the three core variables of `xinds`, `yinds`, and `travel_times`.\n",
+    "\n",
+    "Nutrients are assumed to flow with the bulk of water, assuming a `theta` coefficient == 1. We are also using the default `diff_coeff` in this example, but it is encouraged, especially for soluble material transport, to evaluate the sensitivity of that choice on your results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "640b18c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create the parameters object and then assign the values\n",
+    "params = pt.modelParams()\n",
+    "\n",
+    "# Populate the params attributes\n",
+    "params.stage = stage\n",
+    "params.depth = depth\n",
+    "params.qx = qx\n",
+    "params.qy = qy\n",
+    "\n",
+    "# Other choices/parameters\n",
+    "params.dx = 1. # Grid size\n",
+    "params.dry_depth = 0.01 # 1 cm considered dry\n",
+    "params.theta = 1.0\n",
+    "params.particle_variables =['depth']\n",
+    "params.roi_grid = roi_grid"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14db5e12",
+   "metadata": {},
+   "source": [
+    "#### Now time to generate some particles!\n",
+    "Even thought this is a steady flow field, we want to watch how the particles propagate through each step here, as opposed to running the all-inclusive `routines.steady_plots` function. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "679a652e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Let's assume we have hydrodynamic results every minute\n",
+    "model_timestep = 60. # units in seconds\n",
+    "\n",
+    "# Let's say we want to run all the particles until a certain number of steps \n",
+    "num_steps = 10\n",
+    "num_particles = 50\n",
+    "\n",
+    "# Create a vector of target times\n",
+    "# We want the particles to move until their travel time is close to this target_time iteration\n",
+    "target_times = np.arange(model_timestep, model_timestep*(num_steps+1), model_timestep)\n",
+    "\n",
+    "# Now we seed in the region +/- 1 cell of the seed location we computed earlier\n",
+    "# Note that \"xloc\" and \"yloc\" are x and y in the particle coordinate system!\n",
+    "seed_xloc = [seedind[0][0]-1, seedind[0][0]+1]\n",
+    "seed_yloc = [seedind[0][1]-1, seedind[0][1]+1]\n",
+    "\n",
+    "# Initialize particles!\n",
+    "particles = pt.Particles(params)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eda43ccb",
+   "metadata": {},
+   "source": [
+    "Now we will iterate through each model timestep to propagate the particles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "63336d75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Specify folder to save figures:\n",
+    "path2folder = 'particle_flagging_example'\n",
+    "os.makedirs(path2folder, exist_ok=True)\n",
+    "\n",
+    "# initialize walk_data\n",
+    "walk_data = None \n",
+    "\n",
+    "# Iterate through timesteps\n",
+    "for i in list(range(num_steps)): # 0 to 19\n",
+    "    # The main functional difference with an unsteady model is re-instantiating the \n",
+    "    # particle class with updated params *inside* the particle routing loop\n",
+    "\n",
+    "    # Update the flow field by gridding new time-step\n",
+    "    # We don't have additional timesteps, but if we did, we update params here:\n",
+    "    params.depth = myInterp(unstructured['depth'])\n",
+    "    params.stage = myInterp(unstructured['stage'])\n",
+    "    params.qx = myInterp(unstructured['qx'])\n",
+    "    params.qy = myInterp(unstructured['qy'])\n",
+    "\n",
+    "    # Update the particle class with *new flow field* that we should be importing for each timestep above\n",
+    "    particle = pt.Particles(params)\n",
+    "    # Generate some particles only at the first timestep, then let them propagate *on what should be a changing flow field*\n",
+    "    if i == 0:\n",
+    "        particle.generate_particles(num_particles, seed_xloc, seed_yloc, 0, 'random', walk_data)\n",
+    "    else:\n",
+    "        particle.generate_particles(0, [], [], previous_walk_data = walk_data)\n",
+    "    \n",
+    "    # Run the random walk for this \"model timestep\"\n",
+    "    walk_data = particle.run_iteration(target_times[i])\n",
+    "\n",
+    "    # Use get_state() to return original and most recent locations - optional data should include the flag and depth\n",
+    "    x0, y0, t0, optional_data0 = dorado.routines.get_state(walk_data, 0) # Starting locations\n",
+    "    xi, yi, ti, optional_datai = dorado.routines.get_state(walk_data) # Most recent locations\n",
+    "\n",
+    "    # Convert to numpy array for plotting differences\n",
+    "    xi = np.array(xi)\n",
+    "    yi = np.array(yi)\n",
+    "    fi = np.array(optional_datai['roi_flag'])\n",
+    "\n",
+    "    # Separate the two groups for plotting - we want to change the particle color when they enter the roi\n",
+    "    mask_fi0 = fi == 0\n",
+    "    mask_fi1 = fi == 1   \n",
+    "\n",
+    "    if i % 2 == 0: # only plot the every other timestep\n",
+    "\n",
+    "        fig = plt.figure(dpi=200)\n",
+    "        ax = fig.add_subplot(111)\n",
+    "        # Plot initial locations\n",
+    "        ax.scatter(y0, x0, c='b', s=0.75)\n",
+    "        # Plot particles in blue when not flagged (fi = 0)\n",
+    "        ax.scatter(yi[mask_fi0], xi[mask_fi0], c='blue', s=0.75, label='fi = 0')\n",
+    "        # Plot particles in red when flagged (fi = 1, in ROI)\n",
+    "        ax.scatter(yi[mask_fi1], xi[mask_fi1], c='red', s=0.25, label='fi = 1')\n",
+    "        ax = plt.gca()\n",
+    "        \n",
+    "        # Also plot depth with positions\n",
+    "        im = ax.imshow(particle.depth)\n",
+    "        plt.title('Depth at Time ' + str(target_times[i]))\n",
+    "        cax = fig.add_axes([ax.get_position().x1+0.01,\n",
+    "                            ax.get_position().y0,\n",
+    "                            0.02,\n",
+    "                            ax.get_position().height])\n",
+    "        cbar = plt.colorbar(im, cax=cax)\n",
+    "        cbar.set_label('Water Depth [m]')\n",
+    "\n",
+    "        # Save and close\n",
+    "        plt.savefig(path2folder + '/output_by_dt'+str(i)+'.png')\n",
+    "        plt.close()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46d5d6ad",
+   "metadata": {},
+   "source": [
+    "#### Now in the particle_flagging_example folder, we have the particle locations through time\n",
+    "The particles turn red when they are in our defined shallow-er roi. Let's look at the walk data a little more."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "582b02e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "What keys were tracked in the walk_data?: dict_keys(['xinds', 'yinds', 'travel_times', 'depth', 'roi_flag'])\n",
+      "All unique roi_flag values across all particles: {0, 1}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"What keys were tracked in the walk_data?:\", walk_data.keys())\n",
+    "\n",
+    "# Check across all particles that the flag is binary\n",
+    "all_flag_values = set()\n",
+    "for ii in range(len(walk_data['xinds'])):\n",
+    "    all_flag_values.update(walk_data['roi_flag'][ii])\n",
+    "print(f\"All unique roi_flag values across all particles: {all_flag_values}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22e725c5",
+   "metadata": {},
+   "source": [
+    "#### Now let's answer the question, do particles that entered the roi have increased residence times?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "41adc686",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of particles ever in ROI: 28\n",
+      "Number of particles never in ROI: 22\n",
+      "Mean final travel time - ROI particles: 600.12 s\n",
+      "Mean final travel time - non-ROI particles: 600.05 s\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 960x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Here is where we compute the total travel time for each particle\n",
+    "n_particles = len(walk_data['roi_flag'])\n",
+    "roi_time = np.zeros(n_particles)\n",
+    "\n",
+    "for p in range(n_particles):\n",
+    "    flags = walk_data['roi_flag'][p]\n",
+    "    times = walk_data['travel_times'][p]\n",
+    "\n",
+    "    for i in range(1, len(times)):\n",
+    "        dt = times[i] - times[i - 1]\n",
+    "        curr_flag = flags[i]\n",
+    "        prev_flag = flags[i - 1]\n",
+    "\n",
+    "        # Fully in ROI\n",
+    "        if curr_flag == 1 and prev_flag == 1:\n",
+    "            roi_time[p] += dt\n",
+    "        # Transitional step: split in half\n",
+    "        elif curr_flag != prev_flag:\n",
+    "            roi_time[p] += 0.5 * dt\n",
+    "        # else: fully outside ROI (add nothing)\n",
+    "\n",
+    "# Separate into ever-flagged vs never-flagged based on roi_time > 0\n",
+    "flagged_travel_times = []\n",
+    "never_flagged_travel_times = []\n",
+    "\n",
+    "for ii in range(len(walk_data['xinds'])):\n",
+    "    last_travel_time = walk_data['travel_times'][ii][-1]\n",
+    "    if roi_time[ii] > 0:\n",
+    "        flagged_travel_times.append(last_travel_time)\n",
+    "    else:\n",
+    "        never_flagged_travel_times.append(last_travel_time)\n",
+    "\n",
+    "# Summary statistics\n",
+    "print(f\"Number of particles ever in ROI: {len(flagged_travel_times)}\")\n",
+    "print(f\"Number of particles never in ROI: {len(never_flagged_travel_times)}\")\n",
+    "if flagged_travel_times:\n",
+    "    print(f\"Mean final travel time - ROI particles: {np.mean(flagged_travel_times):.2f} s\")\n",
+    "if never_flagged_travel_times:\n",
+    "    print(f\"Mean final travel time - non-ROI particles: {np.mean(never_flagged_travel_times):.2f} s\")\n",
+    "\n",
+    "# Plot distributions\n",
+    "fig, ax = plt.subplots(dpi=150)\n",
+    "ax.hist(flagged_travel_times, alpha=0.6, label='Ever in ROI', color='red')\n",
+    "ax.hist(never_flagged_travel_times, alpha=0.6, label='Never in ROI', color='blue')\n",
+    "ax.set_xlabel('Final Travel Time [s]')\n",
+    "ax.set_ylabel('Count')\n",
+    "ax.set_title('Final Travel Time Distribution by ROI Flagging')\n",
+    "ax.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac3f79bc",
+   "metadata": {},
+   "source": [
+    "#### Welp, doesn't seem to matter here - seems like our ROI was a bit too arbitrary. We hope you can think of some more useful cases for tracking the additional hydrodynamic outputs in the `walk_data` along with the user-defined `roi_grid` than this example provided!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac4442c8",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "dorado2_env",
+   "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.21"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/test_particle_track.py b/tests/test_particle_track.py
index 9eac940..d4ce044 100644
--- a/tests/test_particle_track.py
+++ b/tests/test_particle_track.py
@@ -8,6 +8,7 @@
 sys.path.append(os.path.realpath(os.path.dirname(__file__)+"/.."))
 
 from dorado import particle_track
+from dorado import parallel_routing
 import numpy as np
 
 # init some parameters
@@ -25,6 +26,8 @@ class pobj():
 params.qy = np.ones((3,3))
 params.theta = 1
 params.model = 'DeltaRCM'
+params.roi_grid = np.ones((3,3))
+params.particle_variables = ['depth', 'qx'] # optional variables to track with particles
 goodparams = copy.deepcopy(params)  # don't corrupt these good parameters
 particle = particle_track.Particles(params)
 
@@ -105,6 +108,24 @@ def test_steep_other():
     particle = particle_track.Particles(params)
     assert particle.steepest_descent == False
 
+def test_roi_grid():
+    if getattr(params, 'roi_grid', None) is not None:
+        assert particle.roi_grid is not None
+    else:
+        assert particle.roi_grid is None
+
+def test_optional_particle_variables():
+    for var in getattr(params, 'particle_variables', []):
+        assert var in particle.particle_variables
+
+    if getattr(params, 'roi_grid', None) is not None:
+        assert 'roi_flag' in particle.particle_variables
+    else:
+        assert 'roi_flag' not in particle.particle_variables
+
+    # optional_outputs should exactly match particle_variables
+    assert set(particle.optional_outputs) == set(particle.particle_variables)
+
 # testing of the run_iteration function
 def test_start_pairs_X():
     particle = particle_track.Particles(params)
@@ -266,6 +287,19 @@ def test_manual_reset():
     particle.clear_walk_data()
     assert (particle.walk_data is None) is True
 
+def test_run_iteration_optional_variables():
+    # test that optional variables are being tracked in walk data
+    particle = particle_track.Particles(params)
+    particle.generate_particles(Np_tracer, seed_xloc, seed_yloc)
+    all_walk_data = particle.run_iteration()
+    # Check that all optional particle variables are in the returned walk_data
+    for var in getattr(params, 'particle_variables', []):
+        assert var in all_walk_data, f"{var} missing from walk_data"
+    # roi_flag is included only if roi_grid exists
+    if getattr(params, 'roi_grid', None) is not None:
+        assert 'roi_flag' in all_walk_data, "roi_flag missing from walk_data"
+    else:
+        assert 'roi_flag' not in all_walk_data
 
 class TestValueErrors:
     """
@@ -348,6 +382,29 @@ def test_missing_stage(self):
         params.v = np.ones((3,3))
         with pytest.raises(ValueError):
             particle = particle_track.Particles(params)
+    
+    def test_roi_grid_shape_mismatch(self):
+        params = particle_track.modelParams()
+        params.dx = 1
+        params.depth = np.ones((3,3))
+        params.topography = np.zeros((3,3))
+        params.u = np.ones((3,3))
+        params.v = np.ones((3,3))
+        params.roi_grid = np.ones((4,4))  # Mismatched shape
+        with pytest.raises(ValueError):
+            particle = particle_track.Particles(params)
+
+    def test_roi_with_only_stage(self):
+        params = particle_track.modelParams()
+        params.dx = 1
+        params.stage = np.ones((3,3))
+        params.topography = np.zeros((3,3))
+        params.u = np.ones((3,3))
+        params.v = np.ones((3,3))
+        params.roi_grid = np.ones((3,3))
+        particle = particle_track.Particles(params)
+        # should work so make assertion
+        assert particle.roi_grid.shape == (3,3)
 
     def test_rcm_model_uv(self):
         params = particle_track.modelParams()
@@ -606,3 +663,44 @@ def test_unstruct2grid_bounds():
                                      [2., 2., 2.],
                                      [2., 2., 2.],
                                      [1., 1., 1.]]))
+    
+def test_flux_proportional_seeding():
+    num_total_particles = 1000
+    num_seeding_steps = 10
+    q = np.ones((10,1))*200
+    q[0] = 400  # Increase flux in the first cell
+    q[1] = 100  # Decrease flux in the second cell
+    q[9] = 100  # Decrease flux in the last cell (q sums to 1000)
+    flux_normalized_particle_counts = particle_track.flux_proportional_seeding(q, num_total_particles, num_seeding_steps)
+    assert len(flux_normalized_particle_counts) == num_seeding_steps
+    assert sum(flux_normalized_particle_counts) == num_total_particles
+    assert flux_normalized_particle_counts[0] > flux_normalized_particle_counts[1]
+    assert flux_normalized_particle_counts[1] == flux_normalized_particle_counts[9]
+
+
+def test_parallel_routing():
+    """Test the parallel routing functionality of the particle tracking model with optional outputs."""
+    # Set up parameters for the particle tracking
+    params = particle_track.modelParams()
+    params.dx = 1
+    params.depth = np.ones((5, 5))
+    params.stage = np.ones((5, 5))
+    params.qx = np.zeros((5, 5))
+    params.qy = np.ones((5, 5))
+    params.particle_variables = ['depth', 'qx']  # Optional variables to track
+    params.seed_xloc = [1, 2]
+    params.seed_yloc = [1, 2]
+    params.Np_tracer = 2  # Number of particles to generate
+    params.model = 'DeltaRCM'
+
+    # Create the particle object
+    particle = particle_track.Particles(params)
+
+    # Run parallel routing with a specified number of cores
+    num_cores = 2  # Adjust based on your machine's capabilities
+    num_iter = 5   # Number of iterations to run
+    par_result = parallel_routing.parallel_routing(particle, num_iter, params.Np_tracer, params.seed_xloc, params.seed_yloc, num_cores)
+
+    assert len(par_result['xinds']) == params.Np_tracer * num_cores
+    assert 'depth' in par_result
+    assert 'qx' in par_result