From dbfd7edcdc4e204f2ed7b51437a87ee6b0253f50 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Sun, 12 May 2024 12:10:15 -0500 Subject: [PATCH 01/41] start to create constituents class --- src/clearwater_riverine/constituents.py | 131 ++++++++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 src/clearwater_riverine/constituents.py diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py new file mode 100644 index 0000000..49b73ea --- /dev/null +++ b/src/clearwater_riverine/constituents.py @@ -0,0 +1,131 @@ +from typing import Dict +from pathlib import Path + +import pandas as pd +from xarray import xr +import numpy as np + +from clearwater_riverine.linalg import RHS + + +class Constituent: + """Constituent class.""" + def __init__( + self, + name: str, + constituent_config: Dict, + mesh: xr.Dataset, + ): + self.name = name + + # TODO: make units optional + self.units = constituent_config['units'] + + # add to model mesh + mesh[self.name] = xr.DataArray( + np.nan( + (len(self.mesh.time), len(self.mesh.nface)) + ), + dims = ('time', 'nface'), + attrs = { + 'Units': f'{self.units}' + } + ) + + # define initial and boundary conditions + self.set_initial_conditions( + filepath=constituent_config['initial_conditions'], + mesh=mesh, + ) + self.set_boundary_conditions( + filepath=constituent_config['boundary_conditions'], + mesh=mesh, + ) + + # set up RHS matrix + self.b = RHS( + mesh, + + ) + + + def set_initial_conditions( + self, + filepath: str | Path, + mesh: xr.Dataset + ): + """Define initial conditions for costituents from CSV file. + + Args: + filepath (str): Filepath to a CSV containing initial conditions. + The CSV should have two columns: one called `Cell_Index` and + one called `Concentration`. The file should the concentration + in each cell within the model domain at the first timestep. + """ + initial_condition_df = pd.read_csv(filepath) + initial_condition_df['Cell_Index'] = initial_condition_df.Cell_Index.astype(int) + # self.input_array[0, [init['Cell_Index']]] = init['Concentration'] + mesh[self.name][0, [initial_condition_df['Cell_Index']]] = initial_condition_df['Concentration'] + + def set_boundary_conditions( + self, + filepath: str | Path, + mesh: xr.Dataset): + """Define boundary conditions for Clearwater Riverine model from a CSV file. + + Args: + filepath (str): Filepath to a CSV containing boundary conditions. + The CSV should have the following columns: `RAS2D_TS_Name` + (the timeseries name, as labeled in the HEC-RAS model), `Datetime`, + `Concentration`. This file should contain the concentration for all + relevant boundary cells at every RAS timestep. If a timestep / boundary + cell is not included in this CSV file, the concentration will be set to 0 + in the Clearwater Riverine model. + """ + # Read in boundary condition data from user + bc_df = pd.read_csv( + filepath, + parse_dates=['Datetime'] + ) + + xarray_time_index = pd.DatetimeIndex( + mesh.time.values + ) + model_dataframe = pd.DataFrame({ + 'Datetime': xarray_time_index, + 'Time Index': range(len(xarray_time_index)) + }) + + result_df = pd.DataFrame() + for boundary, group_df in bc_df.groupby('RAS2D_TS_Name'): + # Merge with model timestep + merged_group = pd.merge_asof( + model_dataframe, + group_df, + on='Datetime' + ) + # Interpolate + merged_group['Concentration'] = merged_group['Concentration'].interpolate( + method='linear' + ) + # Append to dataframe + result_df = pd.concat( + [result_df, merged_group], + ignore_index=True + ) + + # Merge with boundary data + boundary_df = pd.merge( + result_df, + self.boundary_data, + left_on = 'RAS2D_TS_Name', + right_on = 'Name', + how='left' + ) + boundary_df['Ghost Cell'] = mesh.edges_face2[boundary_df['Face Index'].to_list()] + boundary_df['Domain Cell'] = mesh.edges_face1[boundary_df['Face Index'].to_list()] + + # Assign to appropriate position in array + # self.input_array[[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] + mesh[self.name][[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] + From a190a656c398dbe3772afd0c2fd4d652f39aea99 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Sun, 12 May 2024 12:18:18 -0500 Subject: [PATCH 02/41] start updating RHS matrix --- src/clearwater_riverine/constituents.py | 3 +-- src/clearwater_riverine/linalg.py | 25 ++++++++++++++++--------- 2 files changed, 17 insertions(+), 11 deletions(-) diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py index 49b73ea..8ff34eb 100644 --- a/src/clearwater_riverine/constituents.py +++ b/src/clearwater_riverine/constituents.py @@ -44,8 +44,7 @@ def __init__( # set up RHS matrix self.b = RHS( - mesh, - + mesh=mesh, ) diff --git a/src/clearwater_riverine/linalg.py b/src/clearwater_riverine/linalg.py index 85674f5..122e152 100644 --- a/src/clearwater_riverine/linalg.py +++ b/src/clearwater_riverine/linalg.py @@ -156,21 +156,24 @@ def update_values(self, mesh: xr.Dataset, t: float): self.coef[start:end] = -1 * mesh[COEFFICIENT_TO_DIFFUSION_TERM][t][self.internal_edges] class RHS: - def __init__(self, mesh: xr.Dataset, inp: np.array): + def __init__(self, mesh: xr.Dataset): """ Initialize the right-hand side matrix of concentrations based on user-defined boundary conditions. Args: mesh (xr.Dataset): UGRID-complaint xarray Dataset with all data required for the transport equation. - inp (np.array): Array of shape (time x nface) with user-defined inputs of concentrations - in each cell at each timestep. """ self.nreal_count = mesh.nreal + 1 # 0 indexed - self.inp = inp self.vals = np.zeros(self.nreal_count) self.ghost_cells = np.where(mesh[EDGES_FACE2] > mesh.nreal)[0] - def update_values(self, solution: np.array, mesh: xr.Dataset, t: int): + def update_values( + self, + solution: np.array, + mesh: xr.Dataset, + t: int, + name: str, + ): """ Update right hand side data based on the solution from the previous timestep solution: solution from solving the sparse matrix @@ -179,12 +182,16 @@ def update_values(self, solution: np.array, mesh: xr.Dataset, t: int): solution (np.array): Solution of concentrations at timestep t from solving sparse matrix. mesh (xr.Dataset): UGRID-complaint xarray Dataset with all data required for the transport equation. t (int): Timestep - inp (np.array): Array of shape (time x nface) with user-defined inputs of concentrations - in each cell at each timestep [boundary conditions] + name (str): Constituent name. """ - solver = np.zeros(len(self.inp[t])) + solver = np.zeros( + len( + mesh[name].isel(time=t) + ) + ) solver[0:self.nreal_count] = solution - solver[self.inp[t].nonzero()] = self.inp[t][self.inp[t].nonzero()] + # TODO: make this work with xarray, probably with xr.where() + solver[mesh[name].isel(time=t).nonzero()] = self.inp[t][self.inp[t].nonzero()] self.vals[:] = self._calculate_rhs(mesh, t, solver[0:self.nreal_count]) def _calculate_change_in_time(self, mesh: xr.Dataset, t: int): From 52baca578d113ddd5aa81a433777e464e8e6b22f Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Sun, 12 May 2024 12:47:19 -0500 Subject: [PATCH 03/41] add changes to update method --- src/clearwater_riverine/constituents.py | 4 +- src/clearwater_riverine/transport.py | 199 +++++++++--------------- 2 files changed, 77 insertions(+), 126 deletions(-) diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py index 8ff34eb..b419774 100644 --- a/src/clearwater_riverine/constituents.py +++ b/src/clearwater_riverine/constituents.py @@ -69,7 +69,9 @@ def set_initial_conditions( def set_boundary_conditions( self, filepath: str | Path, - mesh: xr.Dataset): + mesh: xr.Dataset, + boundary_data: pd.DataFrame + ): """Define boundary conditions for Clearwater Riverine model from a CSV file. Args: diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 60d9716..42cdcd9 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -8,10 +8,12 @@ from shapely.geometry import Polygon hv.extension("bokeh") from typing import ( + Dict, Literal, Optional, Tuple, ) +from pathlib import Path from clearwater_riverine.mesh import model_mesh from clearwater_riverine import variables @@ -27,7 +29,7 @@ from clearwater_riverine.utilities import UnitConverter from clearwater_riverine.linalg import LHS, RHS from clearwater_riverine.io.hdf import _hdf_to_xarray - +from clearwater_riverine.constituents import Constituent UNIT_DETAILS = {'Metric': {'Length': 'm', 'Velocity': 'm/s', @@ -77,100 +79,51 @@ class ClearwaterRiverine: def __init__( self, - ras_file_path: str, + flow_field_file_path: str | Path, diffusion_coefficient_input: float, + config_filepath: Optional[str] = None, verbose: Optional[bool] = False, - datetime_range: Optional[Tuple[int, int] | Tuple[str, str]] = None + datetime_range: Optional[Tuple[int, int] | Tuple[str, str]] = None, ) -> None: - """ Initialize a Clearwater Riverine WQ model mesh by reading HDF output from a RAS2D model to an xarray.""" + """ + Initialize a Clearwater Riverine WQ model mesh + reading HDF output from a RAS2D model to an xarray. + """ self.gdf = None + self.time_step = 0 + + # TODO: add config parsing + if config_filepath: + model_config = {} + diffusion_coefficient_input = model_config['diffusion_coefficient'] + flow_field_file_path = model_config['flow_field_filepath'] + self.constituents = model_config['constituents'].keys() + else: + model_config = {} + self.constituents = ['constituent'] + + self.contsituent_dict = {} # define model mesh self.mesh = model_mesh(diffusion_coefficient_input) if verbose: print("Populating Model Mesh...") self.mesh = self.mesh.cwr.read_ras( - ras_file_path, + flow_field_file_path, datetime_range=datetime_range ) self.boundary_data = self.mesh.attrs['boundary_data'] if verbose: print("Calculating Required Parameters...") self.mesh = self.mesh.cwr.calculate_required_parameters() - self.input_array = np.zeros((len(self.mesh.time), len(self.mesh.nface))) - - - def initial_conditions(self, filepath: str): - """Define initial conditions for Clearwater Riverine model from a CSV file. - - Args: - filepath (str): Filepath to a CSV containing initial conditions. The CSV should have two columns: - one called `Cell_Index` and one called `Concentration`. The file should the concentration - in each cell within the model domain at the first timestep. - """ - init = pd.read_csv(filepath) - init['Cell_Index'] = init.Cell_Index.astype(int) - self.input_array[0, [init['Cell_Index']]] = init['Concentration'] - return - - def boundary_conditions(self, filepath: str): - """Define boundary conditions for Clearwater Riverine model from a CSV file. - - Args: - filepath (str): Filepath to a CSV containing boundary conditions. The CSV should have the following columns: - `RAS2D_TS_Name` (the timeseries name, as labeled in the HEC-RAS model), `Datetime`, `Concentration`. - This file should contain the concentration for all relevant boundary cells at every RAS timestep. - If a timestep / boundary cell is not included in this CSV file, the concentration will be set to 0 - in the Clearwater Riverine model. - """ - # Read in boundary condition data from user - bc_df = pd.read_csv( - filepath, - parse_dates=['Datetime'] - ) - - xarray_time_index = pd.DatetimeIndex( - self.mesh.time.values - ) - model_dataframe = pd.DataFrame({ - 'Datetime': xarray_time_index, - 'Time Index': range(len(xarray_time_index)) - }) - - result_df = pd.DataFrame() - for boundary, group_df in bc_df.groupby('RAS2D_TS_Name'): - # Merge with model timestep - merged_group = pd.merge_asof( - model_dataframe, - group_df, - on='Datetime' - ) - # Interpolate - merged_group['Concentration'] = merged_group['Concentration'].interpolate(method='linear') - # Append to dataframe - result_df = pd.concat( - [result_df, merged_group], - ignore_index=True - ) - - # Merge with boundary data - boundary_df = pd.merge( - result_df, - self.boundary_data, - left_on = 'RAS2D_TS_Name', - right_on = 'Name', - how='left' + + self.lhs = LHS(self.mesh) + self.initialize_constituents( + model_config=model_config ) - boundary_df['Ghost Cell'] = self.mesh.edges_face2[boundary_df['Face Index'].to_list()] - boundary_df['Domain Cell'] = self.mesh.edges_face1[boundary_df['Face Index'].to_list()] - # Assign to appropriate position in array - self.input_array[[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] - - def initialize( + def initialize_constituents( self, - initial_condition_path: Optional[str] = None, - boundary_condition_path: Optional[str] = None, - units: Optional[str] = None, + model_config: Dict, ): """Initializes model, developed to be BMI-adjacent. @@ -191,67 +144,63 @@ def initialize( units: the units of the concentration timeseries. If not provided, defaults to 'Unknown.' """ - # Set initial and boundary conditions if provided - if initial_condition_path: - self.initial_conditions(initial_condition_path) - if boundary_condition_path: - self.boundary_conditions(boundary_condition_path) - - if not units: - units = 'unknown' - self.time_step = 0 - self.concentrations = np.zeros((len(self.mesh.time), len(self.mesh.nface))) - self.concentrations[0] = self.input_array[0] - self.mesh[CONCENTRATION] = _hdf_to_xarray( - self.concentrations, - dims = ('time', 'nface'), - attrs={'Units': f'{units}'}) - self.mesh[CONCENTRATION][self.time_step][:] = self.concentrations[0] - - self.b = RHS(self.mesh, self.input_array) - self.lhs = LHS(self.mesh) + self.constituent_dict = {} + + for constituent in self.constituents: + self.constituent_dict[constituent] = Constituent( + name=constituent, + constituent_config=model_config['constituents'][constituent], + mesh=self.mesh + ) def update( self, update_concentration: Optional[dict[str, xr.DataArray]] = None, ): """Update a single timestep.""" - # Allow users to override concentration - if update_concentration: - for var_name, value in update_concentration.items(): - self.mesh['concentration'][self.time_step][0: self.mesh.nreal+1] = update_concentration[var_name].values[0:self.mesh.nreal + 1] - x = update_concentration[var_name].values[0:self.mesh.nreal + 1] - else: - x = self.concentrations[self.time_step][0:self.mesh.nreal + 1] + ## TODO: update to iterate through dict keys and items + for constituent in self.constituents: + # Allow users to override concentration + ## TODO: confirm this is working as expected + if constituent in update_concentration.keys(): + # for var_name, value in update_concentration.items(): + self.mesh[constituent.name][self.time_step][0: self.mesh.nreal+1] = \ + update_concentration[constituent].values[0:self.mesh.nreal + 1] + x = update_concentration[constituent].values[0:self.mesh.nreal + 1] + else: + x = self.mesh[constituent.name][self.time_step][0:self.mesh.nreal + 1] - # Update the right hand side of the matrix - self.b.update_values( - x, - self.mesh, - self.time_step - ) + # Update the right hand side of the matrix + constituent.b.update_values( + x, + self.mesh, + self.time_step + ) - # Update the left hand side of the matrix - self.lhs.update_values( - self.mesh, - self.time_step - ) + # Update the left hand side of the matrix + self.lhs.update_values( + self.mesh, + self.time_step + ) - # Define compressed sparse row matrix - A = csr_matrix( - (self.lhs.coef, (self.lhs.rows, self.lhs.cols)), - shape=(self.mesh.nreal + 1, self.mesh.nreal + 1) - ) + # Define compressed sparse row matrix + A = csr_matrix( + (self.lhs.coef, (self.lhs.rows, self.lhs.cols)), + shape=(self.mesh.nreal + 1, self.mesh.nreal + 1) + ) - # Solve - x = linalg.spsolve(A, self.b.vals) + # Solve + x = linalg.spsolve(A, constituent.b.vals) + + # Update timestep and save data + ## TODO: figure out how to handle input array... maybe this does need to stay. + self.concentrations[self.time_step][0:self.mesh.nreal+1] = x + self.concentrations[self.time_step][self.input_array[self.time_step].nonzero()] = self.input_array[self.time_step][self.input_array[self.time_step].nonzero()] + self.mesh[constituent.name][self.time_step][:] = self.concentrations[self.time_step] - # Update timestep and save data self.time_step += 1 - self.concentrations[self.time_step][0:self.mesh.nreal+1] = x - self.concentrations[self.time_step][self.input_array[self.time_step].nonzero()] = self.input_array[self.time_step][self.input_array[self.time_step].nonzero()] - self.mesh['concentration'][self.time_step][:] = self.concentrations[self.time_step] + def simulate_wq( self, From a2d9d46b6a79e99b4e41fcd945b65775be9f66c7 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Sun, 12 May 2024 15:06:05 -0500 Subject: [PATCH 04/41] update xarray and dict handling --- src/clearwater_riverine/constituents.py | 19 ++++-- src/clearwater_riverine/transport.py | 87 ++++++++++++++----------- 2 files changed, 61 insertions(+), 45 deletions(-) diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py index b419774..7843f1a 100644 --- a/src/clearwater_riverine/constituents.py +++ b/src/clearwater_riverine/constituents.py @@ -17,7 +17,10 @@ def __init__( mesh: xr.Dataset, ): self.name = name - + self.advection_mass_flux = np.zeros((len(mesh.time), len(mesh.nedge))) + self.diffusion_mass_flux = np.zeros((len(mesh.time), len(mesh.nedge))) + self.total_mass_flux = np.zeros((len(mesh.time), len(mesh.nedge))) + self.input_array = np.zeros((len(mesh.time), len(mesh.nface))) # TODO: make units optional self.units = constituent_config['units'] @@ -63,8 +66,13 @@ def set_initial_conditions( """ initial_condition_df = pd.read_csv(filepath) initial_condition_df['Cell_Index'] = initial_condition_df.Cell_Index.astype(int) - # self.input_array[0, [init['Cell_Index']]] = init['Concentration'] - mesh[self.name][0, [initial_condition_df['Cell_Index']]] = initial_condition_df['Concentration'] + self.input_array[0, [initial_condition_df['Cell_Index']]] = initial_condition_df['Concentration'] + mesh[self.name].loc[ + { + 'time': 0, + 'nface': [initial_condition_df['Cell_Index']] + } + ] = self.input_array[0] def set_boundary_conditions( self, @@ -118,7 +126,7 @@ def set_boundary_conditions( # Merge with boundary data boundary_df = pd.merge( result_df, - self.boundary_data, + boundary_data, left_on = 'RAS2D_TS_Name', right_on = 'Name', how='left' @@ -127,6 +135,5 @@ def set_boundary_conditions( boundary_df['Domain Cell'] = mesh.edges_face1[boundary_df['Face Index'].to_list()] # Assign to appropriate position in array - # self.input_array[[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] - mesh[self.name][[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] + self.input_array[[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 42cdcd9..31e5485 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -159,17 +159,29 @@ def update( update_concentration: Optional[dict[str, xr.DataArray]] = None, ): """Update a single timestep.""" - ## TODO: update to iterate through dict keys and items - for constituent in self.constituents: + + # Update the left hand side of the matrix + # This is the same for all constituents + self.lhs.update_values( + self.mesh, + self.time_step + ) + + # Define compressed sparse row matrix for LHS + A = csr_matrix( + (self.lhs.coef, (self.lhs.rows, self.lhs.cols)), + shape=(self.mesh.nreal + 1, self.mesh.nreal + 1) + ) + + for constituent_name, constituent in self.constituents.items(): # Allow users to override concentration ## TODO: confirm this is working as expected if constituent in update_concentration.keys(): - # for var_name, value in update_concentration.items(): - self.mesh[constituent.name][self.time_step][0: self.mesh.nreal+1] = \ - update_concentration[constituent].values[0:self.mesh.nreal + 1] - x = update_concentration[constituent].values[0:self.mesh.nreal + 1] + self.mesh[constituent_name][self.time_step][0: self.mesh.nreal + 1] = \ + update_concentration[constituent_name].values[0:self.mesh.nreal + 1] + x = update_concentration[constituent_name].values[0:self.mesh.nreal + 1] else: - x = self.mesh[constituent.name][self.time_step][0:self.mesh.nreal + 1] + x = self.mesh[constituent_name][self.time_step][0:self.mesh.nreal + 1] # Update the right hand side of the matrix constituent.b.update_values( @@ -178,27 +190,17 @@ def update( self.time_step ) - # Update the left hand side of the matrix - self.lhs.update_values( - self.mesh, - self.time_step - ) - - # Define compressed sparse row matrix - A = csr_matrix( - (self.lhs.coef, (self.lhs.rows, self.lhs.cols)), - shape=(self.mesh.nreal + 1, self.mesh.nreal + 1) - ) - # Solve x = linalg.spsolve(A, constituent.b.vals) # Update timestep and save data - ## TODO: figure out how to handle input array... maybe this does need to stay. - self.concentrations[self.time_step][0:self.mesh.nreal+1] = x - self.concentrations[self.time_step][self.input_array[self.time_step].nonzero()] = self.input_array[self.time_step][self.input_array[self.time_step].nonzero()] - self.mesh[constituent.name][self.time_step][:] = self.concentrations[self.time_step] + self.mesh[constituent_name].loc[ + self.time_step, 0:self.mesh.nreal+1 + ] = x + nonzero_indices = np.nonzero(self.input_array[self.time_step]) + self.mesh[constituent_name].loc[self.time_step, nonzero_indices] = self.input_array[self.time_step][nonzero_indices] + # increment timestep self.time_step += 1 @@ -235,33 +237,40 @@ def simulate_wq( self.inp_converted = unit_converter._convert_units(self.input_array, convert_to=True) # self.inp_converted = self.input_array / input_liter_conversion / conversion_factor # convert to mass/ft3 or mass/m3 - output = np.zeros((len(self.mesh.time), self.mesh.nreal + 1)) - advection_mass_flux = np.zeros((len(self.mesh.time), len(self.mesh.nedge))) - diffusion_mass_flux = np.zeros((len(self.mesh.time), len(self.mesh.nedge))) - total_mass_flux = np.zeros((len(self.mesh.time), len(self.mesh.nedge))) - concentrations = np.zeros((len(self.mesh.time), len(self.mesh.nface))) - - b = RHS(self.mesh, self.inp_converted) lhs = LHS(self.mesh) - concentrations[0] = self.inp_converted[0] - x = concentrations[0][0:self.mesh.nreal + 1] + # concentrations[0] = self.inp_converted[0] + # x = concentrations[0][0:self.mesh.nreal + 1] # loop over time to solve for t in range(len(self.mesh['time']) - 1): self.time_step = t self._timer(t) - b.update_values(x, self.mesh, t) lhs.update_values(self.mesh, t) A = csr_matrix((lhs.coef,(lhs.rows, lhs.cols)), shape=(self.mesh.nreal + 1, self.mesh.nreal + 1)) - x = linalg.spsolve(A, b.vals) - # reactions would go here - concentrations[t+1][0:self.mesh.nreal+1] = x - concentrations[t+1][self.inp_converted[t].nonzero()] = self.inp_converted[t][self.inp_converted[t].nonzero()] - self._mass_flux(concentrations, advection_mass_flux, diffusion_mass_flux, total_mass_flux, t) + + # solve for each constituent + for constituent_name, constituent in self.constituents_dict.items(): + constituent.b.update_values(x, self.mesh, t) + x = linalg.spsolve(A, constituent.b.vals) + self.mesh[constituent_name].loc[ + {'time': self.time_step} + ] = x + # TODO: add nonzero logic from input array! + # concentrations[t+1][0:self.mesh.nreal+1] = x + # concentrations[t+1][self.inp_converted[t].nonzero()] = self.inp_converted[t][self.inp_converted[t].nonzero()] + self._mass_flux( + self.mesh[constituent_name], + constituent.advection_mass_flux, + constituent.diffusion_mass_flux, + constituent.total_mass_flux, + t + ) # self._mass_flux(concentrations, advection_mass_flux, diffusion_mass_flux, total_mass_flux, t+1) print(' 100%') + + ## TODO: add model wrap-up tasks --> align with BMI concentrations_converted = unit_converter._convert_units(concentrations, convert_to=False) self.mesh[CONCENTRATION] = _hdf_to_xarray(concentrations_converted, dims = ('time', 'nface'), attrs={'Units': f'{input_mass_units}/{input_volume_units}'}) @@ -270,7 +279,7 @@ def simulate_wq( self.mesh['mass_flux_diffusion'] = _hdf_to_xarray(diffusion_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) self.mesh['mass_flux_total'] = _hdf_to_xarray(total_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) - # may need to move this if we want to plot things besides concentration + # TODO: moe this to plot things besides concentration self.max_value = int(self.mesh[CONCENTRATION].sel(nface=slice(0, self.mesh.attrs[NUMBER_OF_REAL_CELLS])).max()) self.min_value = int(self.mesh[CONCENTRATION].sel(nface=slice(0, self.mesh.attrs[NUMBER_OF_REAL_CELLS])).min()) From 2979f2fb1df326ad8bd90ebcae03ce098b063f4b Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Sun, 12 May 2024 15:35:32 -0500 Subject: [PATCH 05/41] general cleanup --- src/clearwater_riverine/constituents.py | 13 ++- src/clearwater_riverine/linalg.py | 4 +- src/clearwater_riverine/transport.py | 118 ++++++++++++++---------- 3 files changed, 85 insertions(+), 50 deletions(-) diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py index 7843f1a..53968be 100644 --- a/src/clearwater_riverine/constituents.py +++ b/src/clearwater_riverine/constituents.py @@ -6,6 +6,7 @@ import numpy as np from clearwater_riverine.linalg import RHS +from clearwater_riverine.variables import NUMBER_OF_REAL_CELLS class Constituent: @@ -23,11 +24,13 @@ def __init__( self.input_array = np.zeros((len(mesh.time), len(mesh.nface))) # TODO: make units optional self.units = constituent_config['units'] + self.max_value = None + self.min_value = None # add to model mesh mesh[self.name] = xr.DataArray( np.nan( - (len(self.mesh.time), len(self.mesh.nface)) + (len(mesh.time), len(mesh.nface)) ), dims = ('time', 'nface'), attrs = { @@ -137,3 +140,11 @@ def set_boundary_conditions( # Assign to appropriate position in array self.input_array[[boundary_df['Time Index']], [boundary_df['Ghost Cell']]] = boundary_df['Concentration'] + ## TODO: probably a more elegant way to do this + def set_value_range( + self, + mesh: xr.Dataset + ): + self.max_value = int(mesh[self.name].sel(nface=slice(0, mesh.attrs[NUMBER_OF_REAL_CELLS])).max()) + self.min_value = int(mesh[self.name].sel(nface=slice(0, mesh.attrs[NUMBER_OF_REAL_CELLS])).min()) + diff --git a/src/clearwater_riverine/linalg.py b/src/clearwater_riverine/linalg.py index 122e152..ade3949 100644 --- a/src/clearwater_riverine/linalg.py +++ b/src/clearwater_riverine/linalg.py @@ -173,6 +173,7 @@ def update_values( mesh: xr.Dataset, t: int, name: str, + input_array: np.array, ): """ Update right hand side data based on the solution from the previous timestep @@ -190,8 +191,7 @@ def update_values( ) ) solver[0:self.nreal_count] = solution - # TODO: make this work with xarray, probably with xr.where() - solver[mesh[name].isel(time=t).nonzero()] = self.inp[t][self.inp[t].nonzero()] + solver[input_array[t].nonzero()] = input_array[t][input_array[t].nonzero()] self.vals[:] = self._calculate_rhs(mesh, t, solver[0:self.nreal_count]) def _calculate_change_in_time(self, mesh: xr.Dataset, t: int): diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 31e5485..30a2177 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -185,9 +185,11 @@ def update( # Update the right hand side of the matrix constituent.b.update_values( - x, - self.mesh, - self.time_step + solution=x, + mesh=self.mesh, + t=self.time_step, + name=constituent_name, + input_array=constituent.input_array ) # Solve @@ -200,6 +202,15 @@ def update( nonzero_indices = np.nonzero(self.input_array[self.time_step]) self.mesh[constituent_name].loc[self.time_step, nonzero_indices] = self.input_array[self.time_step][nonzero_indices] + # Calculate mass flux + self._mass_flux( + self.mesh[constituent_name], + constituent.advection_mass_flux, + constituent.diffusion_mass_flux, + constituent.total_mass_flux, + t+1 + ) + # increment timestep self.time_step += 1 @@ -212,7 +223,9 @@ def simulate_wq( save: bool = False, output_file_path: str = './clearwater-riverine-wq-model.zarr' ): - """Runs water quality model. + """Deprecated + + Runs water quality model. Steps through each timestep of the HEC-RAS 2D output and solves the total-load advection-diffusion transport equation using user-defined boundary and initial conditions. Users must use `initial_conditions()` and `boundary_conditions()` @@ -233,59 +246,78 @@ def simulate_wq( print("Starting WQ Simulation...") # Convert Units - unit_converter = UnitConverter(self.mesh, input_mass_units, input_volume_units, input_liter_conversion) - self.inp_converted = unit_converter._convert_units(self.input_array, convert_to=True) + # unit_converter = UnitConverter(self.mesh, input_mass_units, input_volume_units, input_liter_conversion) + # self.inp_converted = unit_converter._convert_units(self.input_array, convert_to=True) # self.inp_converted = self.input_array / input_liter_conversion / conversion_factor # convert to mass/ft3 or mass/m3 - lhs = LHS(self.mesh) - # concentrations[0] = self.inp_converted[0] - # x = concentrations[0][0:self.mesh.nreal + 1] - - # loop over time to solve + # Loop over time to solve for t in range(len(self.mesh['time']) - 1): self.time_step = t self._timer(t) lhs.update_values(self.mesh, t) - A = csr_matrix((lhs.coef,(lhs.rows, lhs.cols)), shape=(self.mesh.nreal + 1, self.mesh.nreal + 1)) + A = csr_matrix( + (lhs.coef,(lhs.rows, lhs.cols)), + shape=(self.mesh.nreal + 1, self.mesh.nreal + 1) + ) # solve for each constituent for constituent_name, constituent in self.constituents_dict.items(): - constituent.b.update_values(x, self.mesh, t) + # Solve sparse matrix + constituent.b.update_values( + solution=x, + mesh=self.mesh, + t=self.time_step, + name=constituent_name, + input_array=constituent.input_array + ) x = linalg.spsolve(A, constituent.b.vals) + + # Save solution self.mesh[constituent_name].loc[ - {'time': self.time_step} + t+1, 0:self.mesh.nreal+1 ] = x - # TODO: add nonzero logic from input array! - # concentrations[t+1][0:self.mesh.nreal+1] = x - # concentrations[t+1][self.inp_converted[t].nonzero()] = self.inp_converted[t][self.inp_converted[t].nonzero()] + nonzero_indices = np.nonzero(self.input_array[self.time_step]) + self.mesh[constituent_name].loc[self.time_step, nonzero_indices] = self.input_array[self.time_step][nonzero_indices] + self._mass_flux( self.mesh[constituent_name], constituent.advection_mass_flux, constituent.diffusion_mass_flux, constituent.total_mass_flux, - t + t+1 ) # self._mass_flux(concentrations, advection_mass_flux, diffusion_mass_flux, total_mass_flux, t+1) + # concentrations_converted = unit_converter._convert_units(concentrations, convert_to=False) + # self.mesh[CONCENTRATION] = _hdf_to_xarray(concentrations_converted, dims = ('time', 'nface'), attrs={'Units': f'{input_mass_units}/{input_volume_units}'}) - print(' 100%') + # # add advection / diffusion mass flux + # self.mesh['mass_flux_advection'] = _hdf_to_xarray(advection_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) + # self.mesh['mass_flux_diffusion'] = _hdf_to_xarray(diffusion_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) + # self.mesh['mass_flux_total'] = _hdf_to_xarray(total_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) - ## TODO: add model wrap-up tasks --> align with BMI - concentrations_converted = unit_converter._convert_units(concentrations, convert_to=False) - self.mesh[CONCENTRATION] = _hdf_to_xarray(concentrations_converted, dims = ('time', 'nface'), attrs={'Units': f'{input_mass_units}/{input_volume_units}'}) + # # TODO: move this to plot things besides concentration + # self.max_value = int(self.mesh[CONCENTRATION].sel(nface=slice(0, self.mesh.attrs[NUMBER_OF_REAL_CELLS])).max()) + # self.min_value = int(self.mesh[CONCENTRATION].sel(nface=slice(0, self.mesh.attrs[NUMBER_OF_REAL_CELLS])).min()) - # add advection / diffusion mass flux - self.mesh['mass_flux_advection'] = _hdf_to_xarray(advection_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) - self.mesh['mass_flux_diffusion'] = _hdf_to_xarray(diffusion_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) - self.mesh['mass_flux_total'] = _hdf_to_xarray(total_mass_flux, dims=('time', 'nedge'), attrs={'Units': f'{input_mass_units}'}) + # if save == True: + # self.mesh.cwr.save_clearwater_xarray(output_file_path) + + print(' 100%') - # TODO: moe this to plot things besides concentration - self.max_value = int(self.mesh[CONCENTRATION].sel(nface=slice(0, self.mesh.attrs[NUMBER_OF_REAL_CELLS])).max()) - self.min_value = int(self.mesh[CONCENTRATION].sel(nface=slice(0, self.mesh.attrs[NUMBER_OF_REAL_CELLS])).min()) + + def finalize( + self, + save: Optional[bool] = False, + output_filepath: Optional[str] = None + ): + for _, constituent in self.constituent_dict.items(): + constituent.set_value_range(self.mesh) if save == True: - self.mesh.cwr.save_clearwater_xarray(output_file_path) - + self.mesh.cwr.save_clearwater_exarray(output_filepath) + + def _timer(self, t): if t == int(len(self.mesh['time']) / 4): print(' 25%') @@ -341,24 +373,16 @@ def _prep_plot(self, crs: str): p1 = Polygon(list(zip(xs.values, ys.values))) polygon_list.append(p1) - poly_gdf = gpd.GeoDataFrame({ - 'nface': self.mesh.nface[0:self.nreal_index], - 'geometry': polygon_list}, - crs = crs) + poly_gdf = gpd.GeoDataFrame( + { + 'nface': self.mesh.nface[0:self.nreal_index], + 'geometry': polygon_list + }, + crs = crs + ) self.poly_gdf = poly_gdf.to_crs('EPSG:4326') self._update_gdf() - - # gdf_ls = [] - - # for t in range(len(self.mesh.time)): - # temp_gdf = gpd.GeoDataFrame({'cell': self.mesh.nface[0:nreal_index], - # 'datetime': pd.to_datetime(self.mesh.time[t].values), - # 'concentration': self.mesh.concentration.isel(time=t, nface=slice(0,nreal_index)), - # 'volume': self.mesh.volume.isel(time=t, nface=slice(0,nreal_index)), - # 'cell': self.mesh.nface[0:nreal_index], - # 'geometry': poly_gdf['geometry']}, - # crs = 'EPSG:4326') - # gdf_ls.append(temp_gdf) + def _update_gdf(self): """Update gdf values.""" From 036571292ebcdf863ae3e0c70c4b88fc50d99e4d Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Sun, 12 May 2024 15:59:17 -0500 Subject: [PATCH 06/41] parse config #48 --- src/clearwater_riverine/io/config.py | 48 ++++++++++++++++++++++++++++ src/clearwater_riverine/transport.py | 11 ++++--- 2 files changed, 54 insertions(+), 5 deletions(-) create mode 100644 src/clearwater_riverine/io/config.py diff --git a/src/clearwater_riverine/io/config.py b/src/clearwater_riverine/io/config.py new file mode 100644 index 0000000..8c237cf --- /dev/null +++ b/src/clearwater_riverine/io/config.py @@ -0,0 +1,48 @@ +import yaml +from pathlib import Path +from typing import Dict + +REQUIRED_CONFIG_KEYS = [ + 'diffusion_coefficient', + 'flow_field_filepath', + 'constituents' +] + +REQUIRED_CONSTITUENT_KEYS = [ + 'initial_conditions', + 'boundary_conditions' +] + + +def validate_config( + config: Dict, +): + missing_keys = [] + for key in REQUIRED_CONFIG_KEYS: + if key not in config: + missing_keys.append(key) + return missing_keys + +def validate_constituents(config): + for constituent in config['constituents']: + for key in REQUIRED_CONSTITUENT_KEYS: + if key not in config['constituents'][constituent]: + return (key, constituent) + return None + +def parse_config( + config_filepath: str | Path, +): + with open(config_filepath, 'r') as file: + model_config = yaml.safe_load(file) + + # ensure required information is in config + missing_keys = validate_config(model_config) + if len(missing_keys) > 0: + raise ValueError(f'Missing {missing_keys} from configuration file.') + + cd = validate_constituents(model_config) + if cd is not None: + raise ValueError(f'Missing {cd[0]} from {cd[1]} in the model config.') + + return model_config \ No newline at end of file diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 30a2177..7fa2997 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -5,6 +5,7 @@ import holoviews as hv import geoviews as gv import geopandas as gpd +import yaml from shapely.geometry import Polygon hv.extension("bokeh") from typing import ( @@ -29,6 +30,7 @@ from clearwater_riverine.utilities import UnitConverter from clearwater_riverine.linalg import LHS, RHS from clearwater_riverine.io.hdf import _hdf_to_xarray +from clearwater_riverine.io.config import parse_config from clearwater_riverine.constituents import Constituent UNIT_DETAILS = {'Metric': {'Length': 'm', @@ -80,7 +82,7 @@ class ClearwaterRiverine: def __init__( self, flow_field_file_path: str | Path, - diffusion_coefficient_input: float, + diffusion_coefficient_input: Optional[float] = 0.0, config_filepath: Optional[str] = None, verbose: Optional[bool] = False, datetime_range: Optional[Tuple[int, int] | Tuple[str, str]] = None, @@ -92,14 +94,13 @@ def __init__( self.gdf = None self.time_step = 0 - # TODO: add config parsing if config_filepath: - model_config = {} + model_config = parse_config(config_filepath=config_filepath) diffusion_coefficient_input = model_config['diffusion_coefficient'] flow_field_file_path = model_config['flow_field_filepath'] self.constituents = model_config['constituents'].keys() else: - model_config = {} + # TODO: add functionality to build model_config from inputs self.constituents = ['constituent'] self.contsituent_dict = {} @@ -261,7 +262,7 @@ def simulate_wq( ) # solve for each constituent - for constituent_name, constituent in self.constituents_dict.items(): + for constituent_name, constituent in self.constituent_dict.items(): # Solve sparse matrix constituent.b.update_values( solution=x, From 95cdafc3eb4f6578d25f8ab9110a123c909159ba Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Wed, 15 May 2024 15:33:27 -0400 Subject: [PATCH 07/41] add demo config --- examples/dev_sandbox/demo_config.yml | 11 +++++++++++ src/clearwater_riverine/transport.py | 4 ++-- 2 files changed, 13 insertions(+), 2 deletions(-) create mode 100644 examples/dev_sandbox/demo_config.yml diff --git a/examples/dev_sandbox/demo_config.yml b/examples/dev_sandbox/demo_config.yml new file mode 100644 index 0000000..56a3630 --- /dev/null +++ b/examples/dev_sandbox/demo_config.yml @@ -0,0 +1,11 @@ +flow_field_filepath: path_name.hdf +diffusion_coefficient: 0.1 +constituents: + conservative_tracer: + initial_conditions: + boundary_conditions: + units: + temperature: + initial_conditions: + boundary_conditions: + units: diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 7fa2997..2dc4b90 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -250,7 +250,8 @@ def simulate_wq( # unit_converter = UnitConverter(self.mesh, input_mass_units, input_volume_units, input_liter_conversion) # self.inp_converted = unit_converter._convert_units(self.input_array, convert_to=True) # self.inp_converted = self.input_array / input_liter_conversion / conversion_factor # convert to mass/ft3 or mass/m3 - + lhs = LHS(self.mesh) + # Loop over time to solve for t in range(len(self.mesh['time']) - 1): self.time_step = t @@ -306,7 +307,6 @@ def simulate_wq( print(' 100%') - def finalize( self, save: Optional[bool] = False, From ee13b3750cdd5a43685205522900cfc476b94864 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Fri, 17 May 2024 10:08:58 -0400 Subject: [PATCH 08/41] bug fixes in init and constituents --- examples/dev_sandbox/demo_config.yml | 14 ++++---- examples/dev_sandbox/prof_riverine_config.py | 36 ++++++++++++++++++++ src/clearwater_riverine/constituents.py | 13 ++++--- src/clearwater_riverine/transport.py | 2 +- 4 files changed, 50 insertions(+), 15 deletions(-) create mode 100644 examples/dev_sandbox/prof_riverine_config.py diff --git a/examples/dev_sandbox/demo_config.yml b/examples/dev_sandbox/demo_config.yml index 56a3630..788f29c 100644 --- a/examples/dev_sandbox/demo_config.yml +++ b/examples/dev_sandbox/demo_config.yml @@ -1,11 +1,11 @@ -flow_field_filepath: path_name.hdf +flow_field_filepath: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\clearWaterTestCases.p48.hdf diffusion_coefficient: 0.1 constituents: conservative_tracer: - initial_conditions: - boundary_conditions: - units: + initial_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_initial_conditions_tracer.csv + boundary_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_boundary_conditions_tracer.csv + units: mg/m3 temperature: - initial_conditions: - boundary_conditions: - units: + initial_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_initial_conditions_temp.csv + boundary_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_boundary_conditions_temp.csv + units: degC diff --git a/examples/dev_sandbox/prof_riverine_config.py b/examples/dev_sandbox/prof_riverine_config.py new file mode 100644 index 0000000..c0b7152 --- /dev/null +++ b/examples/dev_sandbox/prof_riverine_config.py @@ -0,0 +1,36 @@ +""" +Script to help with debugging Clearwater-Riverine. +""" +from pathlib import Path +from typing import ( + Optional, + Tuple +) +import clearwater_riverine as cwr + +def run_clearwater_riverine_model( + config_filepath: str | Path, + datetime_range: Optional[Tuple[int, int]] = None, +): + transport_model = cwr.ClearwaterRiverine( + config_filepath=config_filepath, + verbose=True, + datetime_range=datetime_range, + ) + + transport_model.update() + + return transport_model + + +if __name__ == '__main__': + config_filepath = r'C:\Users\sjordan\OneDrive - LimnoTech\Documents\GitHub\ClearWater-riverine\examples\dev_sandbox\demo_config.yml' + start_index = 0 + end_index = 100 + + transport_model = run_clearwater_riverine_model( + config_filepath=config_filepath, + datetime_range=(start_index, end_index) + ) + + diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py index 53968be..4b8bfa1 100644 --- a/src/clearwater_riverine/constituents.py +++ b/src/clearwater_riverine/constituents.py @@ -2,7 +2,7 @@ from pathlib import Path import pandas as pd -from xarray import xr +import xarray as xr import numpy as np from clearwater_riverine.linalg import RHS @@ -29,8 +29,9 @@ def __init__( # add to model mesh mesh[self.name] = xr.DataArray( - np.nan( - (len(mesh.time), len(mesh.nface)) + np.full( + (len(mesh.time), len(mesh.nface)), + np.nan ), dims = ('time', 'nface'), attrs = { @@ -72,8 +73,7 @@ def set_initial_conditions( self.input_array[0, [initial_condition_df['Cell_Index']]] = initial_condition_df['Concentration'] mesh[self.name].loc[ { - 'time': 0, - 'nface': [initial_condition_df['Cell_Index']] + 'time': mesh['time'][0], } ] = self.input_array[0] @@ -81,7 +81,6 @@ def set_boundary_conditions( self, filepath: str | Path, mesh: xr.Dataset, - boundary_data: pd.DataFrame ): """Define boundary conditions for Clearwater Riverine model from a CSV file. @@ -129,7 +128,7 @@ def set_boundary_conditions( # Merge with boundary data boundary_df = pd.merge( result_df, - boundary_data, + mesh.boundary_data, left_on = 'RAS2D_TS_Name', right_on = 'Name', how='left' diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 2dc4b90..f3543ea 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -81,7 +81,7 @@ class ClearwaterRiverine: def __init__( self, - flow_field_file_path: str | Path, + flow_field_file_path: Optional[str | Path] = None, diffusion_coefficient_input: Optional[float] = 0.0, config_filepath: Optional[str] = None, verbose: Optional[bool] = False, From e98a0a38863867b6c2a3a2eeae990e9d0f967871 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 30 May 2024 12:02:44 -0500 Subject: [PATCH 09/41] debugging - pass flow field boundaries to constituents - fix RHS matrix handling (each constituent has an input array with data provided by user) - general bug fixes in transport module (esp with .loc for xarray and dictionary handling) --- src/clearwater_riverine/constituents.py | 21 ++++++++++++++------- src/clearwater_riverine/linalg.py | 16 +++++++++++----- src/clearwater_riverine/transport.py | 25 ++++++++++++++++--------- 3 files changed, 41 insertions(+), 21 deletions(-) diff --git a/src/clearwater_riverine/constituents.py b/src/clearwater_riverine/constituents.py index 4b8bfa1..6512ff4 100644 --- a/src/clearwater_riverine/constituents.py +++ b/src/clearwater_riverine/constituents.py @@ -16,6 +16,7 @@ def __init__( name: str, constituent_config: Dict, mesh: xr.Dataset, + flow_field_boundaries: pd.DataFrame, ): self.name = name self.advection_mass_flux = np.zeros((len(mesh.time), len(mesh.nedge))) @@ -47,11 +48,13 @@ def __init__( self.set_boundary_conditions( filepath=constituent_config['boundary_conditions'], mesh=mesh, + flow_field_boundaries=flow_field_boundaries, ) # set up RHS matrix self.b = RHS( mesh=mesh, + input_array=self.input_array, ) @@ -81,17 +84,21 @@ def set_boundary_conditions( self, filepath: str | Path, mesh: xr.Dataset, + flow_field_boundaries: pd.DataFrame ): """Define boundary conditions for Clearwater Riverine model from a CSV file. Args: filepath (str): Filepath to a CSV containing boundary conditions. - The CSV should have the following columns: `RAS2D_TS_Name` - (the timeseries name, as labeled in the HEC-RAS model), `Datetime`, - `Concentration`. This file should contain the concentration for all - relevant boundary cells at every RAS timestep. If a timestep / boundary - cell is not included in this CSV file, the concentration will be set to 0 - in the Clearwater Riverine model. + The CSV should have the following columns: `RAS2D_TS_Name` + (the timeseries name, as labeled in the HEC-RAS model), `Datetime`, + `Concentration`. This file should contain the concentration for all + relevant boundary cells at every RAS timestep. If a timestep / boundary + cell is not included in this CSV file, the concentration will be set to 0 + in the Clearwater Riverine model. + mesh (xr.Dataset): Unstructured model mesh. + flow_field_boundaries (pd.DataFrame): pandas dataframe definining how the + boundaries are configured within the flow field. """ # Read in boundary condition data from user bc_df = pd.read_csv( @@ -128,7 +135,7 @@ def set_boundary_conditions( # Merge with boundary data boundary_df = pd.merge( result_df, - mesh.boundary_data, + flow_field_boundaries, left_on = 'RAS2D_TS_Name', right_on = 'Name', how='left' diff --git a/src/clearwater_riverine/linalg.py b/src/clearwater_riverine/linalg.py index ade3949..8a5d351 100644 --- a/src/clearwater_riverine/linalg.py +++ b/src/clearwater_riverine/linalg.py @@ -156,14 +156,21 @@ def update_values(self, mesh: xr.Dataset, t: float): self.coef[start:end] = -1 * mesh[COEFFICIENT_TO_DIFFUSION_TERM][t][self.internal_edges] class RHS: - def __init__(self, mesh: xr.Dataset): + def __init__( + self, + mesh: xr.Dataset, + input_array: np.array, + ): """ Initialize the right-hand side matrix of concentrations based on user-defined boundary conditions. Args: mesh (xr.Dataset): UGRID-complaint xarray Dataset with all data required for the transport equation. + inp (np.array): Array of shape (time x nface) with user-defined inputs of concentrations + in each cell at each timestep. """ - self.nreal_count = mesh.nreal + 1 # 0 indexed + self.nreal_count = mesh.nreal + 1 # 0 indexed + self.input_array = input_array self.vals = np.zeros(self.nreal_count) self.ghost_cells = np.where(mesh[EDGES_FACE2] > mesh.nreal)[0] @@ -173,7 +180,6 @@ def update_values( mesh: xr.Dataset, t: int, name: str, - input_array: np.array, ): """ Update right hand side data based on the solution from the previous timestep @@ -191,7 +197,7 @@ def update_values( ) ) solver[0:self.nreal_count] = solution - solver[input_array[t].nonzero()] = input_array[t][input_array[t].nonzero()] + solver[self.input_array[t].nonzero()] = self.input_array[t][self.input_array[t].nonzero()] self.vals[:] = self._calculate_rhs(mesh, t, solver[0:self.nreal_count]) def _calculate_change_in_time(self, mesh: xr.Dataset, t: int): @@ -369,7 +375,7 @@ def _ghost_cell(self, mesh: xr.Dataset, t: int, flowing_in: bool): external_cell_index = mesh[EDGES_FACE2][index_list] concentration_multipliers = np.zeros(len(mesh.nface)) - concentration_multipliers[internal_cell_index] = self.inp[t][external_cell_index] + concentration_multipliers[internal_cell_index] = self.input_array[t][external_cell_index] if len(index_list) != 0: if advection: diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index f3543ea..d9d5a2d 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -152,7 +152,8 @@ def initialize_constituents( self.constituent_dict[constituent] = Constituent( name=constituent, constituent_config=model_config['constituents'][constituent], - mesh=self.mesh + mesh=self.mesh, + flow_field_boundaries=self.boundary_data, ) def update( @@ -174,10 +175,9 @@ def update( shape=(self.mesh.nreal + 1, self.mesh.nreal + 1) ) - for constituent_name, constituent in self.constituents.items(): + for constituent_name, constituent in self.constituent_dict.items(): # Allow users to override concentration - ## TODO: confirm this is working as expected - if constituent in update_concentration.keys(): + if isinstance(update_concentration, dict) and constituent in update_concentration.keys(): self.mesh[constituent_name][self.time_step][0: self.mesh.nreal + 1] = \ update_concentration[constituent_name].values[0:self.mesh.nreal + 1] x = update_concentration[constituent_name].values[0:self.mesh.nreal + 1] @@ -190,7 +190,6 @@ def update( mesh=self.mesh, t=self.time_step, name=constituent_name, - input_array=constituent.input_array ) # Solve @@ -198,10 +197,18 @@ def update( # Update timestep and save data self.mesh[constituent_name].loc[ - self.time_step, 0:self.mesh.nreal+1 + { + 'time': self.mesh.time[self.time_step], + 'nface': self.mesh.nface.values[0:self.mesh.nreal+1] + } ] = x - nonzero_indices = np.nonzero(self.input_array[self.time_step]) - self.mesh[constituent_name].loc[self.time_step, nonzero_indices] = self.input_array[self.time_step][nonzero_indices] + nonzero_indices = np.nonzero(constituent.input_array[self.time_step]) + self.mesh[constituent_name].loc[ + { + 'time': self.mesh.time[self.time_step], + 'nface': nonzero_indices[0] + } + ] = constituent.input_array[self.time_step][nonzero_indices] # Calculate mass flux self._mass_flux( @@ -209,7 +216,7 @@ def update( constituent.advection_mass_flux, constituent.diffusion_mass_flux, constituent.total_mass_flux, - t+1 + self.time_step ) # increment timestep From 7e30414be3c67a959466a7753d4db07481dbfa41 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 30 May 2024 12:16:13 -0500 Subject: [PATCH 10/41] allow users to skip the config --- src/clearwater_riverine/transport.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index d9d5a2d..db40733 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -9,6 +9,7 @@ from shapely.geometry import Polygon hv.extension("bokeh") from typing import ( + Any, Dict, Literal, Optional, @@ -83,9 +84,11 @@ def __init__( self, flow_field_file_path: Optional[str | Path] = None, diffusion_coefficient_input: Optional[float] = 0.0, + constituent_dict: Optional[Dict[str: Dict[str: Any]]] = None, config_filepath: Optional[str] = None, verbose: Optional[bool] = False, datetime_range: Optional[Tuple[int, int] | Tuple[str, str]] = None, + ) -> None: """ Initialize a Clearwater Riverine WQ model mesh @@ -100,8 +103,15 @@ def __init__( flow_field_file_path = model_config['flow_field_filepath'] self.constituents = model_config['constituents'].keys() else: - # TODO: add functionality to build model_config from inputs - self.constituents = ['constituent'] + if flow_field_file_path: + ## TODO: add some checking that input set up correctly + if isinstance(constituent_dict, Dict): + self.constituents = constituent_dict + model_config = {'constituents': constituent_dict} + else: + raise TypeError( + 'Missing a `config_filepath` or a `constituent_dict` and `flow_field_file_path` to run the model.' + ) self.contsituent_dict = {} @@ -140,7 +150,7 @@ def initialize_constituents( This file should contain the concentration for all relevant boundary cells at every RAS timestep. If a timestep / boundary cell is not included in this CSV file, the concentration will be set to 0 in the Clearwater Riverine model. - If not provide,d no boundary condtiions will be set up as part of the initialize + If not provided no boundary condtiions will be set up as part of the initialize call. units: the units of the concentration timeseries. If not provided, defaults to 'Unknown.' From 36497c99732d0c6e2e3d7d114576364b7aecd398 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 6 Jun 2024 14:05:13 -0500 Subject: [PATCH 11/41] fix dict type hinting --- src/clearwater_riverine/transport.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index db40733..f453903 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -84,7 +84,7 @@ def __init__( self, flow_field_file_path: Optional[str | Path] = None, diffusion_coefficient_input: Optional[float] = 0.0, - constituent_dict: Optional[Dict[str: Dict[str: Any]]] = None, + constituent_dict: Optional[Dict[str, Dict[str, Any]]] = None, config_filepath: Optional[str] = None, verbose: Optional[bool] = False, datetime_range: Optional[Tuple[int, int] | Tuple[str, str]] = None, From eabac01ddeefb936bd47ca7e5f506fb38442e862 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 6 Jun 2024 14:38:09 -0500 Subject: [PATCH 12/41] update timestep placement --- src/clearwater_riverine/transport.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index f453903..206b76f 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -208,17 +208,17 @@ def update( # Update timestep and save data self.mesh[constituent_name].loc[ { - 'time': self.mesh.time[self.time_step], + 'time': self.mesh.time[self.time_step + 1], 'nface': self.mesh.nface.values[0:self.mesh.nreal+1] } ] = x - nonzero_indices = np.nonzero(constituent.input_array[self.time_step]) + nonzero_indices = np.nonzero(constituent.input_array[self.time_step + 1]) self.mesh[constituent_name].loc[ { - 'time': self.mesh.time[self.time_step], + 'time': self.mesh.time[self.time_step + 1], 'nface': nonzero_indices[0] } - ] = constituent.input_array[self.time_step][nonzero_indices] + ] = constituent.input_array[self.time_step + 1][nonzero_indices] # Calculate mass flux self._mass_flux( From c768512ac22367f60bb307a967de39f051f1e768 Mon Sep 17 00:00:00 2001 From: Nick Grewe Date: Thu, 6 Jun 2024 14:59:27 -0500 Subject: [PATCH 13/41] demo notebook --- examples/dev_sandbox/demo_config.yml | 10 +- examples/dev_sandbox/demo_config_single.yml | 7 + .../dev_sandbox/multiple_constituents.ipynb | 2062 +++++++++++++++++ 3 files changed, 2074 insertions(+), 5 deletions(-) create mode 100644 examples/dev_sandbox/demo_config_single.yml create mode 100644 examples/dev_sandbox/multiple_constituents.ipynb diff --git a/examples/dev_sandbox/demo_config.yml b/examples/dev_sandbox/demo_config.yml index 788f29c..24c2756 100644 --- a/examples/dev_sandbox/demo_config.yml +++ b/examples/dev_sandbox/demo_config.yml @@ -1,11 +1,11 @@ -flow_field_filepath: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\clearWaterTestCases.p48.hdf +flow_field_filepath: W:\2ERDC12 - Clearwater\config\clearWaterTestCases.p48.hdf diffusion_coefficient: 0.1 constituents: conservative_tracer: - initial_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_initial_conditions_tracer.csv - boundary_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_boundary_conditions_tracer.csv + initial_conditions: W:\2ERDC12 - Clearwater\config\cwr_initial_conditions_tracer.csv + boundary_conditions: W:\2ERDC12 - Clearwater\config\cwr_boundary_conditions_tracer.csv units: mg/m3 temperature: - initial_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_initial_conditions_temp.csv - boundary_conditions: C:\Users\sjordan\OneDrive - LimnoTech\Desktop\cwr_boundary_conditions_temp.csv + initial_conditions: W:\2ERDC12 - Clearwater\config\cwr_initial_conditions_temp.csv + boundary_conditions: W:\2ERDC12 - Clearwater\config\cwr_boundary_conditions_temp.csv units: degC diff --git a/examples/dev_sandbox/demo_config_single.yml b/examples/dev_sandbox/demo_config_single.yml new file mode 100644 index 0000000..e8f35d4 --- /dev/null +++ b/examples/dev_sandbox/demo_config_single.yml @@ -0,0 +1,7 @@ +flow_field_filepath: W:\2ERDC12 - Clearwater\config\clearWaterTestCases.p48.hdf +diffusion_coefficient: 0.1 +constituents: + conservative_tracer: + initial_conditions: W:\2ERDC12 - Clearwater\config\cwr_initial_conditions_tracer.csv + boundary_conditions: W:\2ERDC12 - Clearwater\config\cwr_boundary_conditions_tracer.csv + units: mg/m3 \ No newline at end of file diff --git a/examples/dev_sandbox/multiple_constituents.ipynb b/examples/dev_sandbox/multiple_constituents.ipynb new file mode 100644 index 0000000..f535838 --- /dev/null +++ b/examples/dev_sandbox/multiple_constituents.ipynb @@ -0,0 +1,2062 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3278aa96-42ab-4b29-8d31-10b1fada56f0", + "metadata": {}, + "source": [ + "# Constituents\n", + "\n", + "## Set up" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d541cb6a-71c8-4982-8ca0-19af15478122", + "metadata": {}, + "outputs": [], + "source": [ + "# import modules" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "87602459-30f0-4419-bb36-b92b77ef32e4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " var force = true;\n", + " var py_version = '3.3.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " var reloading = false;\n", + " var Bokeh = root.Bokeh;\n", + "\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " if (!reloading) {\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error() {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " var skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n", + " require([\"jspanel\"], function(jsPanel) {\n", + "\twindow.jsPanel = jsPanel\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-modal\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-tooltip\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-hint\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-layout\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-contextmenu\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-dock\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"gridstack\"], function(GridStack) {\n", + "\twindow.GridStack = GridStack\n", + "\ton_load()\n", + " })\n", + " require([\"notyf\"], function() {\n", + "\ton_load()\n", + " })\n", + " root._bokeh_is_loading = css_urls.length + 9;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " var existing_stylesheets = []\n", + " var links = document.getElementsByTagName('link')\n", + " for (var i = 0; i < links.length; i++) {\n", + " var link = links[i]\n", + " if (link.href != null) {\n", + "\texisting_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (var i = 0; i < css_urls.length; i++) {\n", + " var url = css_urls[i];\n", + " if (existing_stylesheets.indexOf(url) !== -1) {\n", + "\ton_load()\n", + "\tcontinue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.4/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.4/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } var existing_scripts = []\n", + " var scripts = document.getElementsByTagName('script')\n", + " for (var i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + "\texisting_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (var i = 0; i < js_urls.length; i++) {\n", + " var url = js_urls[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (var i = 0; i < js_modules.length; i++) {\n", + " var url = js_modules[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " var url = js_exports[name];\n", + " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.2.min.js\", \"https://cdn.holoviz.org/panel/1.3.4/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n", + " var js_modules = [];\n", + " var js_exports = {};\n", + " var css_urls = [];\n", + " var inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (var i = 0; i < inline_js.length; i++) {\n", + "\ttry {\n", + " inline_js[i].call(root, root.Bokeh);\n", + "\t} catch(e) {\n", + "\t if (!reloading) {\n", + "\t throw e;\n", + "\t }\n", + "\t}\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + "\tvar NewBokeh = root.Bokeh;\n", + "\tif (Bokeh.versions === undefined) {\n", + "\t Bokeh.versions = new Map();\n", + "\t}\n", + "\tif (NewBokeh.version !== Bokeh.version) {\n", + "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + "\t}\n", + "\troot.Bokeh = Bokeh;\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + " if (!reloading && !bokeh_loaded) {\n", + "\troot.Bokeh = undefined;\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + "\trun_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.4/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.4/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.4/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.2.min.js\", \"https://cdn.holoviz.org/panel/1.3.4/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1009" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import clearwater_riverine as cwr" + ] + }, + { + "cell_type": "markdown", + "id": "4f37b89c-66a5-4ca4-9811-f52e29f1bfee", + "metadata": {}, + "source": [ + "## Model Set Up" + ] + }, + { + "cell_type": "markdown", + "id": "49adc7b0-a67c-4303-945b-edf17e0c4558", + "metadata": {}, + "source": [ + "We now set up the model with the `config_filepath` parameter. If a config is provided, the model will use all information from the config by default (i.e., it will override any of the other optional input parameters in the Python interface). \n", + "\n", + "Users can still set up without a config, but would require the following parameters instead:\n", + "* `flow_field_file_path`\n", + "* `diffusion_coefficient`\n", + "* `constituent_dict`: a dictionary containing constituent names, initial conditions, boundary conditions, and optionally units.\n", + "\n", + "Here we show how to use the `config_filepath`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9adc08e3-4b22-4f72-a377-10c03d58dddc", + "metadata": {}, + "outputs": [], + "source": [ + "# point to config\n", + "config_filepath = \"./demo_config.yml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "37960472-ef4e-4316-8562-0379f51d38fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n" + ] + } + ], + "source": [ + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_filepath,\n", + " verbose=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9224ad48-83d6-43d7-affd-ad6ea394958f", + "metadata": {}, + "source": [ + "Examining the model mesh, we can now see that instead of having a constituent variable automatically named \"concentration,\" we now have two different variables that are named according to the names provided in the model config:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5db39450-868d-48dd-8b35-aa4ff038c2fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'conservative_tracer' (time: 5761, nface: 444)>\n",
+       "array([[100., 100., 100., ...,   0.,   0.,   0.],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       ...,\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan]])\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 2022-05-13 2022-05-13T00:00:30 ... 2022-05-15\n",
+       "    face_x   (nface) float64 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n",
+       "    face_y   (nface) float64 2.45e+03 2.45e+03 2.45e+03 ... 2.5e+03 500.0 564.4\n",
+       "Dimensions without coordinates: nface\n",
+       "Attributes:\n",
+       "    Units:    mg/m3
" + ], + "text/plain": [ + "\n", + "array([[100., 100., 100., ..., 0., 0., 0.],\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " ...,\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " [ nan, nan, nan, ..., nan, nan, nan]])\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2022-05-13 2022-05-13T00:00:30 ... 2022-05-15\n", + " face_x (nface) float64 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n", + " face_y (nface) float64 2.45e+03 2.45e+03 2.45e+03 ... 2.5e+03 500.0 564.4\n", + "Dimensions without coordinates: nface\n", + "Attributes:\n", + " Units: mg/m3" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transport_model.mesh['conservative_tracer']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "69320991-16b3-4d35-8d3f-0cc3eff90d31", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'temperature' (time: 5761, nface: 444)>\n",
+       "array([[15., 15., 15., ...,  0.,  0.,  0.],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       ...,\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan]])\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 2022-05-13 2022-05-13T00:00:30 ... 2022-05-15\n",
+       "    face_x   (nface) float64 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n",
+       "    face_y   (nface) float64 2.45e+03 2.45e+03 2.45e+03 ... 2.5e+03 500.0 564.4\n",
+       "Dimensions without coordinates: nface\n",
+       "Attributes:\n",
+       "    Units:    degC
" + ], + "text/plain": [ + "\n", + "array([[15., 15., 15., ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " ...,\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 2022-05-13 2022-05-13T00:00:30 ... 2022-05-15\n", + " face_x (nface) float64 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n", + " face_y (nface) float64 2.45e+03 2.45e+03 2.45e+03 ... 2.5e+03 500.0 564.4\n", + "Dimensions without coordinates: nface\n", + "Attributes:\n", + " Units: degC" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transport_model.mesh['temperature']" + ] + }, + { + "cell_type": "markdown", + "id": "38266fd6-149e-4d8a-b341-7edfe03c7389", + "metadata": {}, + "source": [ + "## Run Model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7f571d41-40b3-46fb-b8d1-8cfb7d9104cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 3min 56s\n", + "Wall time: 3min 56s\n" + ] + } + ], + "source": [ + "%%time\n", + "for t in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "15de87e1-970e-45b3-a47d-b4ce050673c7", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(nface=217).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "09502d12-c011-4e0f-b160-c806f4bc4589", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "transport_model.gdf" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "bbeef6be-43c3-4ae5-8548-d4269804292c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.conservative_tracer.isel(nface=217).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "b7a2e19d-ec31-4fcd-b7b9-2966010302e9", + "metadata": {}, + "source": [ + "## Compare Runtime of 1 Constituent" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4c1e9132-64d5-46ba-b0e1-fdd8067a0d88", + "metadata": {}, + "outputs": [], + "source": [ + "del transport_model" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2c2900f7-1c85-48d9-97e6-92844bf1dc78", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n" + ] + } + ], + "source": [ + "# point to config\n", + "config_filepath = \"./demo_config_single.yml\"\n", + "\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_filepath,\n", + " verbose=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "7743acea-fca2-4dfa-ab24-4ce4d809450c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 2min 23s\n", + "Wall time: 2min 23s\n" + ] + } + ], + "source": [ + "%%time\n", + "for t in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()" + ] + }, + { + "cell_type": "markdown", + "id": "17585b6e-2462-4f03-9b41-ebef99d1e760", + "metadata": {}, + "source": [ + "It takes 2 min, 23 seconds to run one constituent vs. 3 min 56 seconds to run two, so it doesn't have a NX slowdown per constiutent, but it's close. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b37e04ad-fa4d-4c0a-81a3-33448821994f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 2e2770620d7f102925330057c97956053a6739d1 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Fri, 7 Jun 2024 09:37:46 -0500 Subject: [PATCH 14/41] post processing notebook @jrutyna --- .../prof_riverine_config_post_proc.py | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 examples/dev_sandbox/prof_riverine_config_post_proc.py diff --git a/examples/dev_sandbox/prof_riverine_config_post_proc.py b/examples/dev_sandbox/prof_riverine_config_post_proc.py new file mode 100644 index 0000000..913cefa --- /dev/null +++ b/examples/dev_sandbox/prof_riverine_config_post_proc.py @@ -0,0 +1,40 @@ +""" +Script to help with debugging Clearwater-Riverine. +""" +from pathlib import Path +from typing import ( + Optional, + Tuple +) +import clearwater_riverine as cwr +from clearwater_riverine.postproc_util import _mass_bal_global + +def run_clearwater_riverine_model( + config_filepath: str | Path, + datetime_range: Optional[Tuple[int, int]] = None, +): + transport_model = cwr.ClearwaterRiverine( + config_filepath=config_filepath, + verbose=True, + datetime_range=datetime_range, + ) + + for t in range(99): + transport_model.update() + + mass_bal_df = _mass_bal_global(transport_model) + + return transport_model + + +if __name__ == '__main__': + config_filepath = r'C:\Users\sjordan\OneDrive - LimnoTech\Documents\GitHub\ClearWater-riverine\examples\dev_sandbox\demo_config.yml' + start_index = 0 + end_index = 100 + + transport_model = run_clearwater_riverine_model( + config_filepath=config_filepath, + datetime_range=(start_index, end_index) + ) + + From 36a9433ab370b0a09ef56f859f828988c90c8f1c Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Fri, 7 Jun 2024 17:03:05 -0400 Subject: [PATCH 15/41] working on updating post process mass balance function working on updating post process mass balance function --- .../dev_sandbox/prof_riverine_postproc.py | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 examples/dev_sandbox/prof_riverine_postproc.py diff --git a/examples/dev_sandbox/prof_riverine_postproc.py b/examples/dev_sandbox/prof_riverine_postproc.py new file mode 100644 index 0000000..1840c96 --- /dev/null +++ b/examples/dev_sandbox/prof_riverine_postproc.py @@ -0,0 +1,81 @@ +""" +Script to help with debugging Clearwater-Riverine. +""" +from pathlib import Path +import os +from typing import ( + Optional, + Tuple +) +import clearwater_riverine as cwr +from clearwater_riverine.postproc_util import _mass_bal_global + +def run_clearwater_riverine_model( + hdf_file_path: str | Path, + initial_condition_path: str | Path, + boundary_condition_path: str | Path, + config_filepath: str | Path, + datetime_range: Optional[Tuple[int, int]] = None, +): + transport_model = cwr.ClearwaterRiverine( + hdf_file_path, + diffusion_coefficient_input=0, + config_filepath=config_filepath, + verbose=True, + datetime_range=datetime_range, + ) + + #transport_model.initialize( + # initial_condition_path=initial_condition_path, + # boundary_condition_path=boundary_condition_path, + # units='mg/m3' + #) + + # transport_model.simulate_wq(save=False, + # input_mass_units = 'g', + # input_volume_units = 'm3', + # ) + + return transport_model + + +if __name__ == '__main__': + hdf_name = 'clearWaterTestCases.p49.hdf' + initial_condition_name = 'cwr_initial_conditions_fine_mesh.csv' + boundary_condition_name = 'cwr_boundary_conditions_coriolis_creek.csv' + root = Path( + r'\\limno.com\files\AAO\AAOWorking\2ERDC12 - Clearwater\ClearwaterHECRAS_testCases\sumwereCreek_TSM_testing_timestep' + ) + + hdf_file_path = root / hdf_name + initial_condition_path = root / initial_condition_name + boundary_condition_path = root / boundary_condition_name + + time = 30 + start_index = int((60/time) * 60 * 12) # start six hours in + #end_index = int((60 / time) * 60 * 24 * 2) + 1 # end + end_index = start_index + 10 + print(start_index, end_index) + + # point to config + dir_str = os.path.abspath("") + print(dir_str) + dir = Path(dir_str) + dir_sandbox = dir / "examples" / "dev_sandbox" + print(dir) + config_filepath = dir_sandbox / "demo_config_single.yml" + print(config_filepath) + print(config_filepath.exists()) + + transport_model = run_clearwater_riverine_model( + hdf_file_path=hdf_file_path, + initial_condition_path=initial_condition_path, + boundary_condition_path=boundary_condition_path, + config_filepath=config_filepath, + datetime_range=(start_index, end_index) + ) + + print(f'Running {hdf_name}.') + + _mass_bal_global(transport_model) + From d1f3d934ef8ce86825fe4030eba28217c5ae7b22 Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Mon, 10 Jun 2024 16:56:09 -0400 Subject: [PATCH 16/41] The post-processing function "_mass_bal_global" is now working The post-processing function "_mass_bal_global" is now working. Please use the "prof_riverine_config_post_proc.py" for troubleshooting. --- .../prof_riverine_config_post_proc.py | 15 +++++++-- .../dev_sandbox/prof_riverine_postproc.py | 2 +- src/clearwater_riverine/postproc_util.py | 33 +++++++++++-------- 3 files changed, 32 insertions(+), 18 deletions(-) diff --git a/examples/dev_sandbox/prof_riverine_config_post_proc.py b/examples/dev_sandbox/prof_riverine_config_post_proc.py index 913cefa..dc55ea5 100644 --- a/examples/dev_sandbox/prof_riverine_config_post_proc.py +++ b/examples/dev_sandbox/prof_riverine_config_post_proc.py @@ -2,6 +2,7 @@ Script to help with debugging Clearwater-Riverine. """ from pathlib import Path +import os from typing import ( Optional, Tuple @@ -22,13 +23,21 @@ def run_clearwater_riverine_model( for t in range(99): transport_model.update() - mass_bal_df = _mass_bal_global(transport_model) + #mass_bal_df = _mass_bal_global(transport_model) return transport_model if __name__ == '__main__': - config_filepath = r'C:\Users\sjordan\OneDrive - LimnoTech\Documents\GitHub\ClearWater-riverine\examples\dev_sandbox\demo_config.yml' + # point to config + dir_str = os.path.abspath("") + dir = Path(dir_str) + dir_sandbox = dir / "examples" / "dev_sandbox" + config_filepath = dir_sandbox / "demo_config_single.yml" + print(dir) + print(config_filepath) + print(config_filepath.exists()) + #config_filepath = r'C:\Users\sjordan\OneDrive - LimnoTech\Documents\GitHub\ClearWater-riverine\examples\dev_sandbox\demo_config.yml' start_index = 0 end_index = 100 @@ -37,4 +46,4 @@ def run_clearwater_riverine_model( datetime_range=(start_index, end_index) ) - + mass_bal_df = _mass_bal_global(transport_model, 'conservative_tracer') diff --git a/examples/dev_sandbox/prof_riverine_postproc.py b/examples/dev_sandbox/prof_riverine_postproc.py index 1840c96..6b66c34 100644 --- a/examples/dev_sandbox/prof_riverine_postproc.py +++ b/examples/dev_sandbox/prof_riverine_postproc.py @@ -77,5 +77,5 @@ def run_clearwater_riverine_model( print(f'Running {hdf_name}.') - _mass_bal_global(transport_model) + _mass_bal_global(transport_model, 'conservative_tracer') diff --git a/src/clearwater_riverine/postproc_util.py b/src/clearwater_riverine/postproc_util.py index 1be35fc..130ebf4 100644 --- a/src/clearwater_riverine/postproc_util.py +++ b/src/clearwater_riverine/postproc_util.py @@ -21,13 +21,13 @@ def _run_simulation(ras_hdf, diff_coef, intl_cnd, bndry): return simulation -def _mass_bal_global(simulation) -> pd.DataFrame: +def _mass_bal_global(simulation:cwr.ClearwaterRiverine, constituent_name: str) -> pd.DataFrame: """Returns entire domain and overall simulation period mass balance values""" #Find Mass at the start of simulation nreal_index = simulation.mesh.attrs[variables.NUMBER_OF_REAL_CELLS] + 1 vol_start = simulation.mesh.volume[0][0:nreal_index] - conc_start = simulation.mesh.concentration[0][0:nreal_index] + conc_start = simulation.mesh[constituent_name].data[0][0:nreal_index] mass_start = vol_start * conc_start vol_start_sum = vol_start.sum() mass_start_sum = mass_start.sum() @@ -39,7 +39,7 @@ def _mass_bal_global(simulation) -> pd.DataFrame: #Find Mass at the end of simulation t_max_index = len(simulation.mesh.time) - 1 vol_end = simulation.mesh.volume[t_max_index][0:nreal_index] - conc_end = simulation.mesh.concentration[t_max_index][0:nreal_index] + conc_end = simulation.mesh[constituent_name].data[t_max_index][0:nreal_index] mass_end = vol_end * conc_end vol_end_sum = vol_end.sum() mass_end_sum = mass_end.sum() @@ -86,10 +86,11 @@ def _mass_bal_global(simulation) -> pd.DataFrame: df[bc_name_vol] = bc_totalVol_xda_val_np bcTotalVolInOutAll = bcTotalVolInOutAll + bc_totalVol_xda_val_np - bc_edgeMass_xda = simulation.mesh.mass_flux_total.sel(nedge=bndryData_n_Face_arrF) + bc_edgeMass_xda = simulation.constituent_dict[constituent_name].total_mass_flux[:, bndryData_n_Face_arrF] bc_totalMass_xda = bc_edgeMass_xda.sum() - bc_totalMass_xda_val = bc_totalMass_xda.values - bc_totalMass_xda_val_np = np.array([bc_totalMass_xda_val]) + #bc_totalMass_xda_val = bc_totalMass_xda.values + #bc_totalMass_xda_val_np = np.array([bc_totalMass_xda_val]) + bc_totalMass_xda_val_np = bc_totalMass_xda bc_name_mass = bc_name + '_mass' df[bc_name_mass] = bc_totalMass_xda_val_np bcTotalMassInOutAll = bcTotalMassInOutAll + bc_totalMass_xda_val_np @@ -103,10 +104,12 @@ def _mass_bal_global(simulation) -> pd.DataFrame: df[bc_name_in_vol] = bc_totalVol_xda_val_np_in bcTotalVolInAll = bcTotalVolInAll + bc_totalVol_xda_val_np_in - bc_edgeMass_xda_in = bc_edgeMass_xda.where(bc_edgeMass_xda<=0, other=0) + #bc_edgeMass_xda_in = bc_edgeMass_xda.where(bc_edgeMass_xda<=0, other=0) + bc_edgeMass_xda_in = np.where(bc_edgeMass_xda<=0, bc_edgeMass_xda, bc_edgeMass_xda*0) bc_totalMass_xda_in = bc_edgeMass_xda_in.sum() - bc_totalMass_xda_val_in = bc_totalMass_xda_in.values - bc_totalMass_xda_val_np_in = np.array([bc_totalMass_xda_val_in]) + #bc_totalMass_xda_val_in = bc_totalMass_xda_in.values + #bc_totalMass_xda_val_np_in = np.array([bc_totalMass_xda_val_in]) + bc_totalMass_xda_val_np_in = bc_totalMass_xda_in bc_name_in_mass = bc_name + '_in_mass' df[bc_name_in_mass] = bc_totalMass_xda_val_np_in bcTotalMassInAll = bcTotalMassInAll + bc_totalMass_xda_val_np_in @@ -120,12 +123,14 @@ def _mass_bal_global(simulation) -> pd.DataFrame: df[bc_name_out_vol] = bc_totalVol_xda_val_np_out bcTotalVolOutAll = bcTotalVolOutAll + bc_totalVol_xda_val_np_out - bc_edgeMass_xda_out = bc_edgeMass_xda.where(bc_edgeMass_xda>=0, other=0) + #bc_edgeMass_xda_out = bc_edgeMass_xda.where(bc_edgeMass_xda>=0, other=0) + bc_edgeMass_xda_out = np.where(bc_edgeMass_xda>=0, bc_edgeMass_xda, bc_edgeMass_xda*0) bc_totalMass_xda_out = bc_edgeMass_xda_out.sum() - bc_totalMass_xda_val_out = bc_totalMass_xda_out.values - bc_totalMass_xda_val_np_out = np.array([bc_totalMass_xda_val_out]) - bc_name_out = bc_name + '_out' - df[bc_name_out] = bc_totalMass_xda_val_np_out + #bc_totalMass_xda_val_out = bc_totalMass_xda_out.values + #bc_totalMass_xda_val_np_out = np.array([bc_totalMass_xda_val_out]) + bc_totalMass_xda_val_np_out = bc_totalMass_xda_out + bc_name_out_mass = bc_name + '_out_mass' + df[bc_name_out_mass] = bc_totalMass_xda_val_np_out bcTotalMassOutAll = bcTotalMassOutAll + bc_totalMass_xda_val_np_out df['bcTotalVolInOutAll'] = bcTotalVolInOutAll From 73148c11f707c75d6e68aeb6904b81b7628133b2 Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Tue, 11 Jun 2024 17:07:22 -0400 Subject: [PATCH 17/41] "_mass_bal_global_100_Ans" post-processing function now working "_mass_bal_global_100_Ans" post-processing function now working --- .../prof_riverine_config_post_proc.py | 3 ++- src/clearwater_riverine/postproc_util.py | 16 +++++++++------- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/examples/dev_sandbox/prof_riverine_config_post_proc.py b/examples/dev_sandbox/prof_riverine_config_post_proc.py index dc55ea5..7eafc7d 100644 --- a/examples/dev_sandbox/prof_riverine_config_post_proc.py +++ b/examples/dev_sandbox/prof_riverine_config_post_proc.py @@ -8,7 +8,7 @@ Tuple ) import clearwater_riverine as cwr -from clearwater_riverine.postproc_util import _mass_bal_global +from clearwater_riverine.postproc_util import _mass_bal_global, _mass_bal_global_100_Ans def run_clearwater_riverine_model( config_filepath: str | Path, @@ -47,3 +47,4 @@ def run_clearwater_riverine_model( ) mass_bal_df = _mass_bal_global(transport_model, 'conservative_tracer') + mass_bal_df_100 = _mass_bal_global_100_Ans(transport_model, 'conservative_tracer') diff --git a/src/clearwater_riverine/postproc_util.py b/src/clearwater_riverine/postproc_util.py index 130ebf4..7104db9 100644 --- a/src/clearwater_riverine/postproc_util.py +++ b/src/clearwater_riverine/postproc_util.py @@ -21,7 +21,8 @@ def _run_simulation(ras_hdf, diff_coef, intl_cnd, bndry): return simulation -def _mass_bal_global(simulation:cwr.ClearwaterRiverine, constituent_name: str) -> pd.DataFrame: +def _mass_bal_global(simulation:cwr.ClearwaterRiverine, + constituent_name: str) -> pd.DataFrame: """Returns entire domain and overall simulation period mass balance values""" #Find Mass at the start of simulation @@ -156,7 +157,8 @@ def _mass_bal_global(simulation:cwr.ClearwaterRiverine, constituent_name: str) - -def _mass_bal_global_100_Ans(simulation) -> pd.DataFrame: +def _mass_bal_global_100_Ans(simulation:cwr.ClearwaterRiverine, + constituent_name: str) -> pd.DataFrame: """Returns entire domain and overall simulation period mass balance values assuming intial conditions are 100 mg/L everywhere and any boundary conditions inputs are also 100mg/L @@ -165,8 +167,8 @@ def _mass_bal_global_100_Ans(simulation) -> pd.DataFrame: #Find Mass at the start of simulation nreal_index = simulation.mesh.attrs[variables.NUMBER_OF_REAL_CELLS] + 1 vol_start = simulation.mesh.volume[0][0:nreal_index] - conc_start = simulation.mesh.concentration[0][0:nreal_index] - conc_start_100 = conc_start.copy(deep=True) + conc_start = simulation.mesh[constituent_name].data[0][0:nreal_index] + conc_start_100 = vol_start.copy(deep=True) conc_start_100 = conc_start_100.where(conc_start_100==100, other=100) mass_start = vol_start * conc_start_100 vol_start_sum = vol_start.sum() @@ -179,8 +181,8 @@ def _mass_bal_global_100_Ans(simulation) -> pd.DataFrame: #Find Mass at the end of simulation t_max_index = len(simulation.mesh.time) - 1 vol_end = simulation.mesh.volume[t_max_index][0:nreal_index] - conc_end = simulation.mesh.concentration[t_max_index][0:nreal_index] - conc_end_100 = conc_end.copy(deep=True) + conc_end = simulation.mesh[constituent_name].data[t_max_index][0:nreal_index] + conc_end_100 = vol_end.copy(deep=True) conc_end_100 = conc_end_100.where(conc_end_100==100, other=100) mass_end = vol_end * conc_end_100 vol_end_sum = vol_end.sum() @@ -268,7 +270,7 @@ def _mass_bal_global_100_Ans(simulation) -> pd.DataFrame: bc_totalMass_xda_out = bc_edgeMass_xda_out.sum() bc_totalMass_xda_val_out = bc_totalMass_xda_out.values bc_totalMass_xda_val_np_out = np.array([bc_totalMass_xda_val_out]) - bc_name_out = bc_name + '_out' + bc_name_out = bc_name + '_out_mass' df[bc_name_out] = bc_totalMass_xda_val_np_out bcTotalMassOutAll = bcTotalMassOutAll + bc_totalMass_xda_val_np_out From b27f6318054d78b1afa87c06c7f8a5040b450c7d Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Thu, 13 Jun 2024 14:58:24 -0400 Subject: [PATCH 18/41] checking mass balance function on plan48_simulation checking mass balance function on plan48_simulation --- .../multiple_constituents_check_massBal.ipynb | 1361 +++++++++++++++++ 1 file changed, 1361 insertions(+) create mode 100644 examples/dev_sandbox/multiple_constituents_check_massBal.ipynb diff --git a/examples/dev_sandbox/multiple_constituents_check_massBal.ipynb b/examples/dev_sandbox/multiple_constituents_check_massBal.ipynb new file mode 100644 index 0000000..384a8b9 --- /dev/null +++ b/examples/dev_sandbox/multiple_constituents_check_massBal.ipynb @@ -0,0 +1,1361 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3278aa96-42ab-4b29-8d31-10b1fada56f0", + "metadata": {}, + "source": [ + "# Constituents\n", + "\n", + "## Set up" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "87602459-30f0-4419-bb36-b92b77ef32e4", + "metadata": {}, + "outputs": [], + "source": [ + "# import modules\n", + "from pathlib import Path\n", + "import clearwater_riverine as cwr\n", + "from clearwater_riverine.postproc_util import _mass_bal_global, _mass_bal_global_100_Ans" + ] + }, + { + "cell_type": "markdown", + "id": "4f37b89c-66a5-4ca4-9811-f52e29f1bfee", + "metadata": {}, + "source": [ + "## Model Set Up" + ] + }, + { + "cell_type": "markdown", + "id": "49adc7b0-a67c-4303-945b-edf17e0c4558", + "metadata": {}, + "source": [ + "We now set up the model with the `config_filepath` parameter. If a config is provided, the model will use all information from the config by default (i.e., it will override any of the other optional input parameters in the Python interface). \n", + "\n", + "Users can still set up without a config, but would require the following parameters instead:\n", + "* `flow_field_file_path`\n", + "* `diffusion_coefficient`\n", + "* `constituent_dict`: a dictionary containing constituent names, initial conditions, boundary conditions, and optionally units.\n", + "\n", + "Here we show how to use the `config_filepath`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9adc08e3-4b22-4f72-a377-10c03d58dddc", + "metadata": {}, + "outputs": [], + "source": [ + "# point to config\n", + "config_filepath = \"./demo_config.yml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "37960472-ef4e-4316-8562-0379f51d38fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n" + ] + } + ], + "source": [ + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_filepath,\n", + " verbose=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9224ad48-83d6-43d7-affd-ad6ea394958f", + "metadata": {}, + "source": [ + "Examining the model mesh, we can now see that instead of having a constituent variable automatically named \"concentration,\" we now have two different variables that are named according to the names provided in the model config:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5db39450-868d-48dd-8b35-aa4ff038c2fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'conservative_tracer' (time: 5761, nface: 444)> Size: 20MB\n",
+       "array([[100., 100., 100., ...,   0.,   0.,   0.],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       ...,\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan],\n",
+       "       [ nan,  nan,  nan, ...,  nan,  nan,  nan]])\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 46kB 2022-05-13 ... 2022-05-15\n",
+       "    face_x   (nface) float64 4kB 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n",
+       "    face_y   (nface) float64 4kB 2.45e+03 2.45e+03 2.45e+03 ... 500.0 564.4\n",
+       "Dimensions without coordinates: nface\n",
+       "Attributes:\n",
+       "    Units:    mg/m3
" + ], + "text/plain": [ + " Size: 20MB\n", + "array([[100., 100., 100., ..., 0., 0., 0.],\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " ...,\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " [ nan, nan, nan, ..., nan, nan, nan],\n", + " [ nan, nan, nan, ..., nan, nan, nan]])\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 46kB 2022-05-13 ... 2022-05-15\n", + " face_x (nface) float64 4kB 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n", + " face_y (nface) float64 4kB 2.45e+03 2.45e+03 2.45e+03 ... 500.0 564.4\n", + "Dimensions without coordinates: nface\n", + "Attributes:\n", + " Units: mg/m3" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transport_model.mesh['conservative_tracer']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "69320991-16b3-4d35-8d3f-0cc3eff90d31", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'temperature' (time: 5761, nface: 444)> Size: 20MB\n",
+       "array([[15., 15., 15., ...,  0.,  0.,  0.],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       ...,\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan],\n",
+       "       [nan, nan, nan, ..., nan, nan, nan]])\n",
+       "Coordinates:\n",
+       "  * time     (time) datetime64[ns] 46kB 2022-05-13 ... 2022-05-15\n",
+       "    face_x   (nface) float64 4kB 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n",
+       "    face_y   (nface) float64 4kB 2.45e+03 2.45e+03 2.45e+03 ... 500.0 564.4\n",
+       "Dimensions without coordinates: nface\n",
+       "Attributes:\n",
+       "    Units:    degC
" + ], + "text/plain": [ + " Size: 20MB\n", + "array([[15., 15., 15., ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " ...,\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 46kB 2022-05-13 ... 2022-05-15\n", + " face_x (nface) float64 4kB 5.005e+05 5.006e+05 ... 5.005e+05 5.024e+05\n", + " face_y (nface) float64 4kB 2.45e+03 2.45e+03 2.45e+03 ... 500.0 564.4\n", + "Dimensions without coordinates: nface\n", + "Attributes:\n", + " Units: degC" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transport_model.mesh['temperature']" + ] + }, + { + "cell_type": "markdown", + "id": "38266fd6-149e-4d8a-b341-7edfe03c7389", + "metadata": {}, + "source": [ + "## Run Model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7f571d41-40b3-46fb-b8d1-8cfb7d9104cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 3min 37s\n", + "Wall time: 3min 37s\n" + ] + } + ], + "source": [ + "%%time\n", + "for t in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b4c32fa2", + "metadata": {}, + "outputs": [], + "source": [ + "massBal = _mass_bal_global(transport_model, 'conservative_tracer')\n", + "massBal_Ans = _mass_bal_global_100_Ans(transport_model, 'conservative_tracer')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "28ed0115", + "metadata": {}, + "outputs": [], + "source": [ + "simDir = Path(r'W:\\2ERDC12 - Clearwater\\Clearwater_testing_TSM\\plan_48_simulation')\n", + "massBal_file = simDir / 'massBal.csv'\n", + "massBal_Ans_file = simDir / 'massBal_Ans.csv'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7c185ec0", + "metadata": {}, + "outputs": [], + "source": [ + "massBal.transpose().to_csv(massBal_file)\n", + "massBal_Ans.transpose().to_csv(massBal_Ans_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "15de87e1-970e-45b3-a47d-b4ce050673c7", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(nface=217).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "09502d12-c011-4e0f-b160-c806f4bc4589", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "transport_model.gdf" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "bbeef6be-43c3-4ae5-8548-d4269804292c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.conservative_tracer.isel(nface=217).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "b7a2e19d-ec31-4fcd-b7b9-2966010302e9", + "metadata": {}, + "source": [ + "## Compare Runtime of 1 Constituent" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4c1e9132-64d5-46ba-b0e1-fdd8067a0d88", + "metadata": {}, + "outputs": [], + "source": [ + "del transport_model" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2c2900f7-1c85-48d9-97e6-92844bf1dc78", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n" + ] + } + ], + "source": [ + "# point to config\n", + "config_filepath = \"./demo_config_single.yml\"\n", + "\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_filepath,\n", + " verbose=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "7743acea-fca2-4dfa-ab24-4ce4d809450c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 2min 23s\n", + "Wall time: 2min 23s\n" + ] + } + ], + "source": [ + "%%time\n", + "for t in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()" + ] + }, + { + "cell_type": "markdown", + "id": "17585b6e-2462-4f03-9b41-ebef99d1e760", + "metadata": {}, + "source": [ + "It takes 2 min, 23 seconds to run one constituent vs. 3 min 56 seconds to run two, so it doesn't have a NX slowdown per constiutent, but it's close. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b37e04ad-fa4d-4c0a-81a3-33448821994f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 433e7c5d31b04792aa11412e342a1646a7945923 Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Mon, 17 Jun 2024 17:48:46 -0400 Subject: [PATCH 19/41] working through riverine-TSM coupling working through riverine-TSM coupling --- ...ne_modules_updated_(scaled)_crs_1sec.ipynb | 1776 +++++++++++++++++ 1 file changed, 1776 insertions(+) create mode 100644 examples/02_coupling_riverine_modules_updated_(scaled)_crs_1sec.ipynb diff --git a/examples/02_coupling_riverine_modules_updated_(scaled)_crs_1sec.ipynb b/examples/02_coupling_riverine_modules_updated_(scaled)_crs_1sec.ipynb new file mode 100644 index 0000000..028f98b --- /dev/null +++ b/examples/02_coupling_riverine_modules_updated_(scaled)_crs_1sec.ipynb @@ -0,0 +1,1776 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9466a47a-b847-4d63-b323-ca996a0650b3", + "metadata": {}, + "source": [ + "# ClearWater-Riverine Demo 2: Coupling Transport to Water Quality Reactions with ClearWater-Modules\n", + "\n", + "**Objective**: Demonstrate a more complex scenario of coupled transport and reaction models in Sumwere Creek, using the [ClearWater-modules](https://github.com/EcohydrologyTeam/ClearWater-modules) to simulate heat exchange with the atmosphere.\n", + "\n", + "This second notebook builds on the introduction to using [ClearWater-riverine](https://github.com/EcohydrologyTeam/ClearWater-riverine) provided in demo notebook 1.\n", + "\n", + "## Background \n", + "This notebook couples Clearwater-riverine (transport) with Clearwater-modules (reactions) - specifically, the Temperature Simulation Model (TSM). The Temperature Simulation Module (TSM) is an essential component of ClearWater (Corps Library for Environmental Analysis and Restoration of Watersheds). TSM plays a crucial role in simulating and predicting water temperature within aquatic ecosystems. TSM utilizes a comprehensive energy balance approach to account for various factors contributing to heat inputs and outputs in the water environment. It considers both external forcing functions and heat exchanges occurring at the water surface and the sediment-water interface. The primary contributors to heat exchange at the water surface include shortwave solar radiation, longwave atmospheric radiation, heat conduction from the atmosphere to the water, and direct heat inputs. Conversely, the primary factors that remove heat from the system are longwave radiation emitted by the water, evaporation, and heat conduction from the water to the atmosphere. \n", + "The core principle behind TSM is the application of the laws of conservation of energy to compute water temperature. This means that the change in heat content of the water is directly related to changes in temperature, which, in turn, are influenced by various heat flux components. The specific heat of water is employed to establish this relationship. Each term of the heat flux equation can be calculated based on the input provided by the user, allowing for flexibility in modeling different environmental conditions\n", + "\n", + "## Example Case Study\n", + "\n", + "This example shows how to run Clearwater Riverine coupled with Clearwater Modules in a fictional location, \"Sumwere Creek\" (shown below). The flow field for Sumwere Creek comes from a HEC-RAS 2D model, which has a domain of 200x200 meters and a base mesh of 10x10 meters. \n", + "\n", + "![image.png](../docs/imgs/SumwereCreek_coarse.png)\n", + "\n", + "The upstream boundary for Sumwere Creek is at the top left of the model domain, flowing into the domain at a constant 3 cms. At the first bend in the creek, there is an additional boundary representing a spring-fed tributary to the creek (1 cms). Further downstream, there is a meander in the stream forming a slow-flowing oxbow lake. There is another boundary flowing into that oxbow lake, representing a powerplant discharge (0.5 cms). \n", + "\n", + "The downstream boundary is a constant stage set at 20.75 The upstream inflows have a water temperature of 15 degrees C; the spring-fed creek has constant inflows of 5 C, and the powerplant is steady at 20 C with periodic higher temperature (25 C) discharges in a downstream meander. \n", + "\n", + "We simulate this scenario over the course of two full days, using meteorological parameters from Arizona (extreme temperature swings between night and day) to help show off the impacts of TSM.\n", + "\n", + "### Data Availability\n", + "All data required run this notebook is available at this [Google Drive](https://drive.google.com/drive/folders/1I_di8WrK95QwBga-W8iuJaJJMZsnIYSS?usp=drive_link). Please download the entire folder and place it in the `data_temp` folder of this repository to run the rest of the notebook." + ] + }, + { + "cell_type": "markdown", + "id": "f34af218-4b58-447d-907c-3fc89f057499", + "metadata": {}, + "source": [ + "## Model Set-Up\n", + "### General Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c280997b-7e02-4079-b8fe-707a0729ed86", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1009" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import logging\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "import holoviews as hv\n", + "import geoviews as gv\n", + "# from holoviews import opts\n", + "import panel as pn\n", + "hv.extension(\"bokeh\")" + ] + }, + { + "cell_type": "markdown", + "id": "baed1b6e-f756-4ca1-b959-4628ab2df47a", + "metadata": {}, + "source": [ + "### Import ClearWater-riverine\n", + "These steps require first completing **[Installation](https://github.com/EcohydrologyTeam/ClearWater-riverine?tab=readme-ov-file#installation)** of a [conda](https://conda.io/docs/) virtual environment customized for the ClearWater-riverine library." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "41338e34-2b59-4cd4-b6b3-a52f6edf7768", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('d:/Clearwater/ClearWater-riverine')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Find project directory (i.e. the parent to `/examples` directory for this notebook)\n", + "project_path = Path.cwd().parent\n", + "project_path" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e2bcf299-c36b-432a-8e28-d1366d0b9c87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('d:/Clearwater/ClearWater-riverine/src')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your source directory should be: \n", + "src_path = project_path / 'src'\n", + "src_path" + ] + }, + { + "cell_type": "markdown", + "id": "5cd020f2-ace9-4f32-a818-9a8716d21e53", + "metadata": {}, + "source": [ + "Next, we'll need to import Clearwater Riverine. While the package is still under development, the easiest way to do this is to use the [`conda develop`](https://docs.conda.io/projects/conda-build/en/latest/resources/commands/conda-develop.html) command in the console or terminal like this, replacing the `'/path/to/module/src'` with your specific path to the source directory. In other words:\n", + "- Copy from the output of `src_path` from the cell above, and \n", + "- Paste it after `!conda develop` in the cell below (replacing the previous user's path). \n", + "\n", + "NOTE: If your path has any blank spaces, you must enclose the path with quotes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9874c4fb-a442-46d9-a442-0df0f3cd01b3", + "metadata": {}, + "outputs": [], + "source": [ + "!conda develop '/Users/aaufdenkampe/Documents/Python/ClearWater-riverine/src'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d0676e2a-bdc9-4774-ab6c-c81927353da4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1011" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import clearwater_riverine as cwr" + ] + }, + { + "cell_type": "markdown", + "id": "66bddd72-10d7-42f1-ad02-b8cc1e9a4cbf", + "metadata": {}, + "source": [ + "### Import ClearWater-Modules" + ] + }, + { + "cell_type": "markdown", + "id": "e56f2ee1-c9f6-4517-8f77-57d34c387b74", + "metadata": {}, + "source": [ + "We will also need to install Clearwater Modules' `Energy Budget` module. While this package is also still under development, the best way to install is with `conda develop`. You will need to clone the [ClearWater Modules](https://github.com/EcohydrologyTeam/ClearWater-modules) repository. Then, use conda develop pointing to the path of your `clearwater-modules` folder like below.\n", + "\n", + "NOTE: You will need to find this path yourself. Remember that if your path has any blank spaces, you must enclose the path with quotes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d081f53f-f7ef-4edb-81f2-e9cbcfcfabe6", + "metadata": {}, + "outputs": [], + "source": [ + "!conda develop '/Users/aaufdenkampe/Documents/Python/ClearWater-modules/src'" + ] + }, + { + "cell_type": "markdown", + "id": "cd44e256", + "metadata": {}, + "source": [ + "You now need to restart the Python kernel for this notebook, if the path didn't already exist." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ec258d25-c3b2-4b7e-a511-40f65c6058bc", + "metadata": {}, + "outputs": [], + "source": [ + "from clearwater_modules.tsm.model import EnergyBudget" + ] + }, + { + "cell_type": "markdown", + "id": "fb9b46da-dde2-42ca-a156-4320b9b55ba3", + "metadata": {}, + "source": [ + "## Instantiate Models\n", + "### Clearwater-Riverine\n", + "\n", + "Ensure that you have followed the instructions in the Data Availability Section, and that you have all files downloaded in `examples/data_temp/sumwere_creek_coarse_p38`. For a more detailed explanation of all the steps in this process, please see [01_getting_started_riverine.ipynb](./01_getting_started_riverine.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ae2ef0cd-b448-405a-bfb7-ea69f4bd638f", + "metadata": {}, + "outputs": [], + "source": [ + "test_case_path = project_path / 'examples/data_temp/sumwere_creek_coarse_p51'\n", + "#flow_field_fpath = test_case_path / 'clearWaterTestCases.p51.hdf'\n", + "#initial_condition_path = test_case_path / 'cwr_initial_conditions_waterTemp_p38.csv'\n", + "#boundary_condition_path = test_case_path / 'cwr_boundary_conditions_waterTemp_p38.csv'\n", + "wetted_surface_area_path = test_case_path / \"wetted_surface_area.zarr\"\n", + "q_solar_path = test_case_path / 'cwr_boundary_conditions_q_solar_p28.csv'\n", + "air_temp_path = test_case_path / 'cwr_boundary_conditions_TairC_p28.csv'\n", + "\n", + "config_file = Path(r'W:\\2ERDC12 - Clearwater\\Clearwater_testing_TSM\\plan_51_simulation\\demo_config.yml')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "c1f71478", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#flow_field_fpath.exists()\n", + "config_file.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f01b0796-d11e-4970-8ea3-85677f39df36", + "metadata": {}, + "outputs": [], + "source": [ + "start_index = 0*60*60 # start at 8:00 am on the first day of the simulation \n", + "end_index = start_index + 48*60*60 # end 48 hours later" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "5695e2db-0cb8-4272-a7a9-7c0137415bd8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "CPU times: total: 10.5 s\n", + "Wall time: 22.9 s\n" + ] + } + ], + "source": [ + "%%time\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_file,\n", + " verbose=True,\n", + " datetime_range= (start_index, end_index)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "db156a72-7733-47c2-9d38-543ca559e498", + "metadata": {}, + "outputs": [], + "source": [ + "#%%time\n", + "#transport_model.initialize(\n", + "# initial_condition_path=initial_condition_path,\n", + "# boundary_condition_path=boundary_condition_path,\n", + "# units='degC',\n", + "#)" + ] + }, + { + "cell_type": "markdown", + "id": "dcfb43d5-07c5-4c4a-842c-438734b71767", + "metadata": {}, + "source": [ + "The Clearwater Riverine currently has the cell surface area, not the *wetted* cell surface area, as required for TSM. Ultimately, we will work on incorporating this calculation into Clearwater Riverine; however, for the sake of this example, we have the wetted surface areas saved in a zarr. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "c0132f5a-2c31-4484-9680-44cb37407fd4", + "metadata": {}, + "outputs": [], + "source": [ + "wetted_sa = xr.open_zarr(wetted_surface_area_path)\n", + "wetted_sa = wetted_sa.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "6365f6de-a977-4975-a4fb-ad1f2b2275d3", + "metadata": {}, + "outputs": [], + "source": [ + "wetted_sa_subset = wetted_sa.isel(time=slice(start_index, end_index+1))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a2846c4d-d26f-4ed4-b86e-6624aba1e696", + "metadata": {}, + "outputs": [], + "source": [ + "#transport_model.mesh['wetted_surface_area'] = wetted_sa_subset['wetted_surface_area']\n", + "\n", + "transport_model.mesh['wetted_surface_area'] = xr.DataArray(\n", + " wetted_sa_subset['wetted_surface_area'].values,\n", + " dims=('time', 'nface')\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "ef31e680-4792-4e1d-85b0-ab682dd36a53", + "metadata": {}, + "source": [ + "### Clearwater-Modules\n", + "\n", + "#### Initial State Values\n", + "The initial state values are `water_temp_c`, `volume`, and `surface_area` come from Clearwater-riverine mesh at the first timestep." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "befc95d9-663d-42f7-9f96-ec96821dcf40", + "metadata": {}, + "outputs": [], + "source": [ + "# Provide xr.data array values for initial state values\n", + "initial_state_values = {\n", + " 'water_temp_c': transport_model.mesh['temperature'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'volume': transport_model.mesh['volume'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'surface_area': transport_model.mesh['wetted_surface_area'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal + 1)\n", + " ),\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "738c906c-2143-404a-982c-cba751248fc1", + "metadata": {}, + "source": [ + "#### Meteorological Parameters\n", + "The meteorological parameters that we'll be adjusting for this model are `q_solar` and `air_temp_c`. In this example, `q_solar` and `air_temp_c` are pulled from meteorological stations in Arizona. \n", + "We will need to interpolate these datasets to our model timestep, using the following function:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "3d319864-884e-40db-9a85-93f56c87ba53", + "metadata": {}, + "outputs": [], + "source": [ + "def interpolate_to_model_timestep(meteo_df, model_dates, col_name):\n", + " merged_df = pd.merge_asof(\n", + " pd.DataFrame({'time': model_dates}),\n", + " meteo_df,\n", + " left_on='time',\n", + " right_on='Datetime')\n", + " merged_df[col_name.lower()] = merged_df[col_name].interpolate(method='linear')\n", + " merged_df.drop(\n", + " columns=['Datetime', col_name],\n", + " inplace=True)\n", + " merged_df.rename(\n", + " columns={'time': 'Datetime'},\n", + " inplace=True,\n", + " )\n", + " return merged_df" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "abc09be6-f808-49bc-b6e9-dc2f792928d6", + "metadata": {}, + "outputs": [], + "source": [ + "xarray_time_index = pd.DatetimeIndex(\n", + " transport_model.mesh.time.values\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "48f7491a-25ee-48cb-8609-4c174ff53073", + "metadata": {}, + "source": [ + "Create timeseries of Q solar and Air Temperature aligned with the timestep of the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0145082a-c55b-43be-abd0-75647b5863bb", + "metadata": {}, + "outputs": [], + "source": [ + "# Q Solar\n", + "q_solar = pd.read_csv(\n", + " q_solar_path, \n", + " parse_dates=['Datetime'])\n", + "q_solar.dropna(axis=0, inplace=True)\n", + "\n", + "q_solar_interp = interpolate_to_model_timestep(\n", + " q_solar,\n", + " xarray_time_index,\n", + " 'q_Solar'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "2b0ba137-e173-442e-b2a9-0478e7adad33", + "metadata": {}, + "outputs": [], + "source": [ + "# Air Temperature\n", + "air_temp_c = pd.read_csv(\n", + " air_temp_path, \n", + " parse_dates=['Datetime'])\n", + "air_temp_c.dropna(axis=0, inplace=True)\n", + "\n", + "air_temp_c_interp = interpolate_to_model_timestep(\n", + " air_temp_c,\n", + " xarray_time_index,\n", + " 'TairC'\n", + ")\n", + "\n", + "air_temp_c_interp['air_temp_c'] = (air_temp_c_interp.tairc - 32)* (5/9)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "0964e5b0-b9b4-4299-bfe5-2514eaf4b795", + "metadata": {}, + "outputs": [], + "source": [ + "# process for clearwater-modules input\n", + "q_solar_array = q_solar_interp.q_solar.to_numpy()\n", + "air_temp_array = air_temp_c_interp.air_temp_c.to_numpy()\n", + "\n", + "# for each individual timestep\n", + "all_meteo_params = {\n", + " 'q_solar': q_solar_array,\n", + " 'air_temp_c': air_temp_array,\n", + "}\n", + "\n", + "# for initial conditions\n", + "initial_meteo_params = {\n", + " 'air_temp_c': air_temp_array[0],\n", + " 'q_solar': q_solar_array[0],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "468dbf2a-5bc5-4186-b543-56e13ab4e34f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(172801,)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.shape(air_temp_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e832b78f-9599-4c10-bdfc-d0dc0b0b69ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "172801\n", + "\n" + ] + } + ], + "source": [ + "p51_timeSteps = int(172801)\n", + "print(p51_timeSteps)\n", + "print(type(p51_timeSteps))" + ] + }, + { + "cell_type": "markdown", + "id": "782cbe25-8c4f-4a3b-a134-3507bf20f247", + "metadata": {}, + "source": [ + "#### Instantiate Clearwater Modules\n", + "We instantiate Clearwater Modules with the following:\n", + "* `initial_state_values` (required): our initial conditions of water temperature, cell volumes, and cell surface areas.\n", + "* `time_dim` (optional): the model timestep\n", + "* `meteo_parameters` (optional): intitial meteorological parameters. If not provided, all meteo parameters will fall to default values.\n", + "* `track_dynamic_variables` (optional): boolean indicating whether or not the user wants to track all intermediate information used in the calculations. We set this to `False` to save on memory.\n", + "* `use_sed_temp` (optional): boolean indicating whether to use the sediment temperature in TSM calculations. We opt to turn this off for simplicity.\n", + "* `updateable_static_variables` (optional): by default, the meteorological variables are static in TSM. If we want these to update over time, we must provide a list of variables that we want to be updateable as input when instantiating the model. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "86b811c9-f20b-4d23-8af4-85cd2a7876b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing from dicts...\n", + "Model initialized from input dicts successfully!.\n" + ] + } + ], + "source": [ + "reaction_model = EnergyBudget(\n", + " time_steps=p51_timeSteps,\n", + " initial_state_values=initial_state_values,\n", + " updateable_static_variables=['air_temp_c', 'q_solar'],\n", + " meteo_parameters= initial_meteo_params,\n", + " use_sed_temp=False,\n", + " track_dynamic_variables=False, \n", + " time_dim='seconds'\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "0db37f39", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAHFCAYAAAAExnZzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABmU0lEQVR4nO3dd1gUV9sG8HuBZSkiAgqIomIvoFE0xorYexKTGKMx1sReYknimyKaiEbfGL/XEo0majRGU9SosaGC0VhiTcSSJioWxEJVpJ7vD7MDKyzMwpbZ3ft3XXspM2dnn5mdOfvMmTNnVEIIASIiIiIqkYOlAyAiIiKyFkyciIiIiGRi4kREREQkExMnIiIiIpmYOBERERHJxMSJiIiISCYmTkREREQyMXEiIiIikomJExEREZFMTJwU7MiRI4iIiEBycnKheR06dECHDh3MHpM5/Pnnn5g2bRpCQ0NRoUIFeHt7o02bNvj++++LLJ+YmIihQ4eiYsWKcHNzQ6tWrbB//36dMqmpqZgzZw46dOgAf39/lCtXDiEhIfj444/x6NEjnbKnTp3CuHHjEBISAg8PD/j5+aFz5844cOCAQeshJy7g8XepUqkKvbp37y77sxYtWoR+/fohKCgIKpVK776xb98+dOnSBQEBAdBoNPD19UXHjh2xc+dOg9btSfv370fz5s3h7u4OlUqFrVu3lml59qKo712lUmHevHmy3p+dnY1Zs2ahRo0a0Gg0qF+/PhYvXlyo3Pnz5zF27Fi0atVK+o5iYmKKXObIkSMRHByMChUqwNXVFXXr1sX06dNx9+7dsqxqqchdv4iIiCK3o4uLS5k+f9OmTWjUqBFcXV2hUqlw9uzZMi2PbIOTpQMg/Y4cOYJZs2Zh6NChqFChgs68ZcuWWSYoM9i7dy9++uknDB48GC1atEBOTg42bdqEl156CbNmzcIHH3wglc3MzESnTp2QnJyM//u//4Ovry+WLl2K7t27Y9++fQgLCwMAXLt2DYsWLcLgwYMxZcoUlCtXDocOHUJERASioqIQFRUFlUoFAPjmm2/w66+/Yvjw4WjSpAkePHiA5cuXo1OnTli7di1ee+21EtdBblxaNWvWxNdff60z7cnvvDjLly+Hu7s7OnbsiO3bt+std+/ePTRq1AgjR46Ev78/7t+/j+XLl6NXr15Yt24dXn31VdmfqSWEQP/+/VG3bl1s27YN7u7uqFevnsHLsVcvvvgipk6dqjOtWrVqst47duxYrFu3Dh9++CFatGiBPXv2YNKkSUhLS8N//vMfqdzJkyexdetWNG3aFJ06dSp2H3nw4AHeeOMN1K5dGy4uLjh58iTmzJmDnTt34syZM3B2di7dipaC3PXT2r17Nzw9PaW/HRxK3zZw584dDB48GN27d8eyZcug0WhQt27dUi+PbIggxVqwYIEAIOLi4iwdilnduXNH5OXlFZreq1cv4ebmJh49eiRNW7p0qQAgjhw5Ik3Lzs4WDRs2FE8//bQ0LT09XaSnpxdapnYbHzp0SJp2+/btQuVycnJE48aNRa1atWStg9y4hBAiLCxMNGrUSNZy9cnNzZX+36hRIxEWFib7vVlZWaJKlSqiXbt2pfrs69evCwDi448/LtX77RkAMW7cuFK9NzY2VqhUKhEZGakz/fXXXxeurq7i3r170rSC+8d3330nAIjo6GjZn7Vs2TIBQOzfv79UsT5p5syZonr16sWWMWT9Zs6cKQCIO3fuGCU+IYQ4fPiwACA2bdpktGWSbeClOoWKiIjA9OnTAUC6/FKwef3JS3VXrlyBSqXCggUL8PHHH6NGjRpwdXVFhw4d8OeffyI7OxvvvPMOAgIC4Onpieeffx6JiYmFPnfTpk1Sc365cuXQrVs3nDlzxhyrLKlYsaLU+lPQ008/jYcPH+L+/fvStC1btqBevXpo1aqVNM3JyQmvvvoqfv31V9y4cQMA4O7uDnd39yKXCQDx8fHSNF9f30LlHB0dERoaqlOuOHLjMpaynFmr1WpUqFABTk6GN0BHRESgatWqAIC3334bKpUKNWrUAAD8/fffGDZsGOrUqQM3NzdUqVIFffr0wblz5wotJzk5GVOnTkXNmjWlS4g9e/bEpUuXpDJZWVn46KOPUL9+fWg0GlSqVAnDhg3DnTt3ZMf76NEjNG3aFLVr10ZKSoo0PSEhAf7+/ujQoQNyc3MN3g6WsHXrVgghMGzYMJ3pw4YNQ0ZGBnbv3i1NK8v+AQCVKlUCgEL7yF9//YWBAwfC19cXGo0GDRo0wNKlS8v0WVqGrJ+xDR06FG3btgUAvPzyyzqXv0+ePIkBAwZIdWyNGjXwyiuv4OrVq4WWc+PGDbzxxhsIDAyEs7MzAgIC8OKLL+L27dtSmdTUVEybNg1BQUFwdnZGlSpVMHnyZDx48EB2vOvWrYNKpcLRo0cLzZs9ezbUajVu3rxp4FYgfZg4KdTIkSMxYcIEAMDmzZtx9OhRHD16FM2aNSv2fUuXLsUvv/yCpUuXYtWqVbh06RL69OmDESNG4M6dO/jyyy8xf/587Nu3DyNHjtR5b2RkJF555RU0bNgQ3377LdatW4e0tDS0a9cOFy5cKDHmnJwcWS8hRKm2SXR0NCpVqqST2MTGxqJx48aFymqnnT9/vthlavstNWrUqNhyOTk5OHToUInlShvXP//8A29vbzg5OaFWrVp49913kZGRIeuzSiMvLw85OTm4efMmZs6ciT///LPQ5SI5Ro4cic2bNwMAJkyYgKNHj2LLli0AgJs3b8LHxwfz5s3D7t27sXTpUjg5OaFly5b4448/pGWkpaWhbdu2WLFiBYYNG4bt27dj+fLlqFu3Lm7duiXF++yzz2LevHkYOHAgfvrpJ8ybNw9RUVHo0KGD7G3l4uKCb7/9FomJiRg+fLi07EGDBkEIgW+++QaOjo7FLsPY+/mGDRvg6uoKjUaD0NBQrF69Wtb7YmNjUalSJfj7++tM1+5jsbGxspajT05ODh48eIBffvkF77//Ptq2bYs2bdpI8y9cuIAWLVogNjYWn3zyCXbs2IFevXph4sSJmDVrVpk+Gyjd+oWEhMDR0RF+fn547bXXcO3atVJ99vvvvy8lgJGRkTh69KjUPeLKlSuoV68eFi1ahD179uDjjz/GrVu30KJFC51+YDdu3ECLFi2wZcsWTJkyBbt27cKiRYvg6emJpKQkAMDDhw8RFhaGtWvXYuLEidi1axfefvttrFmzBn379pW9D7388svw9/cvlLTm5ORgxYoVeP755xEQEKD3/UII2fs1gZfqlKy4S3VhYWE6l2Pi4uIEANGkSROdZvlFixYJAKJv37467588ebIAIFJSUoQQQly7dk04OTmJCRMm6JRLS0sT/v7+on///sXGqv18OS9DLhForVy5UgAQ//d//6czXa1Wi1GjRhUqf+TIEQFAbNiwQe8yf/vtN+Hq6iqef/75Ej//3XffFQDE1q1bZcVrSFzvvvuuWLZsmThw4ID46aefxPjx44WTk5No3769zncpl5xLdd26dZO+j/Lly4vNmzcb/Dla2u9+wYIFxZbLyckRWVlZok6dOuLNN9+Ups+ePVsAEFFRUXrf+8033wgA4ocfftCZfuLECQFALFu2zKCYN23aJACIRYsWiQ8++EA4ODiIvXv3lvg+Y+/nAwcOFF9//bX4+eefxffffy969OghAIj33nuvxPd26dJF1KtXr8h5zs7O4o033ihynpxLdUePHtVZl549e4rU1FSdMt26dRNVq1aV6hCt8ePHCxcXF3H//n1pWnZ2ts7r/fffF9WrVy80veAlekPW76uvvhJz5swRO3fuFAcOHBDz5s0T3t7ews/PT1y/fl3vehYnOjpaABDfffddseVycnJEenq6cHd316mfhg8fLtRqtbhw4YLe986dO1c4ODiIEydO6Ez//vvvBQCxc+dO2fHOnDlTODs763Q10O7nBw8eLPa92nWV87K3riNFYedwG9OzZ0+dZvkGDRoAAHr16qVTTjv92rVrCA4Oxp49e5CTk4PXXntN56zCxcUFYWFhiI6OLvZzAwICcOLECVkxGtpxeNeuXRg3bhxefPFFqRWuoKIu65U078qVK+jduzcCAwOxatWqYj9/1apVmDNnDqZOnYpnn31Wmi6EKHRZp+ClDLlxffTRRzrzevbsiRo1amDatGn48ccf8fzzzwNAobM9R0fHYj+jOIsXL0ZycjJu3bqF9evX4+WXX8batWvxyiuvlGp5RcnJycH8+fOxfv16/P3338jOzpbmXbx4Ufr/rl27ULduXXTu3Fnvsnbs2IEKFSqgT58+Otvhqaeegr+/P2JiYjBmzBjZsfXv3x8xMTGYPn06cnNz8Z///AddunQp8X3G3s+fvCHghRdeQJ8+fTBv3jxMnDhRukSmT2n2fTlCQkJw4sQJPHz4EGfPnsW8efPQpUsXHDhwAG5ubnj06BH279+PMWPGwM3NTec76dmzJ5YsWYJjx46hR48eAB5fDi7Kk9NXr16NoUOHGrx+gwcP1pkXHh6O8PBwtGrVCvPnz8f//d//yV73kqSnp+PDDz/EDz/8gCtXrujUAU/u1+Hh4VJdW5QdO3YgODgYTz31lM427Natm9Q1Q7sNSzJmzBjMnTsXK1euxLvvvgsAWLJkCUJCQtC+ffti3xsaGip7vy6u5cpeMHGyMd7e3jp/a++A0Tddeyu+9pp7ixYtilxuSX0knJ2d8dRTT8mKsaRLIQXt2bMH/fr1Q5cuXfD1118Xqkh9fHxw7969Qu/T9oN6cr0B4OrVqwgPD4eTkxP2799fZBmt1atXY9SoUXjjjTewYMECnXlr164t1P9C/Nu0Xpq4Cnr11Vcxbdo0HDt2TEqcSvqRMUSdOnWk//ft2xc9evTAuHHj8PLLL5e5P4zWlClTsHTpUrz99tsICwuDl5cXHBwcMHLkSJ1La3fu3CnxLrLbt28jOTlZ7x1dpblVfvjw4fjss8/g7OyMiRMnynqPqfbzgl599VXs2LEDJ0+eLPZH08fHp8jb4x88eICsrKwS97HiuLu7o3nz5gCA9u3bo2XLlnjmmWewYsUKvPnmm7h37x5ycnKwePHiIocHAHS/kyd/lD///HPs2LED27Zt05keFBQk/b+s6/f000+jbt26OHbsWLHlDDVw4EDs378f77//Plq0aIHy5ctDpVKhZ8+ehfZrbf8/fW7fvo2///5bb2JpyH7t5+eHl19+GStWrMA777yD8+fP49ChQ1ixYkWJ7y1Xrpzs/bo0fSFtDbcAAXjcIRsAvv/+e1SvXt3g91+5ckWn0itOdHS0rDGo9uzZg+eeew5hYWH44YcfivzRDAkJKbKzsXZacHCwzvSrV6+iQ4cOEEIgJiam2Ipt9erVGDlyJIYMGYLly5cXStr69Omj9yzN0Lj0KZjEPPlZcre3HE8//TR2796NO3fuwM/PzyjLXL9+PV577TVERkbqTL97967OUAuVKlXC9evXi11WxYoV4ePjo7dDsIeHh0GxPXjwAIMHD0bdunVx+/ZtjBw5Ej/++GOJ7zPFfv4kbfJdUgIbEhKCjRs3Sh3btQzdx+Ro3rw5HBwc8OeffwIAvLy84OjoiMGDB2PcuHFFvqfgdtImYVo7duyAs7NzoekFGWP9hBBGOxEAgJSUFOzYsQMzZ87EO++8I03PzMzUuWkFkL9fu7q64ssvv9Q73xCTJk3CunXr8OOPP2L37t2oUKECBg0aVOL7Dh48iPDwcFmfERcXJ90AYq+YOCmYRqMBAJN2Etbq1q0bnJyc8M8//+CFF14w+P3GvoSxd+9ePPfcc2jbti22bt0qbYsnPf/88xg7diyOHz+Oli1bAnh8iWj9+vVo2bKlTrPytWvXpLumYmJiik0Q16xZg5EjR+LVV1/FqlWrirxk4OPjAx8fnzLHVZS1a9cCAJ555hlpWnE/MmUhhMDBgwdRoUIFvetTGiqVqtD39tNPP+HGjRuoXbu2NK1Hjx744IMPcODAAXTs2LHIZfXu3RsbN25Ebm6utD3LYvTo0bh27Rp+/fVXXLp0CS+++CI+/fRTvPnmm8W+z5SXpLXWrVsHtVqN0NDQYss9++yzeO+997B27Vq8/fbb0vQ1a9bA1dXVoAFUS3Lw4EHk5eVJ35ubmxvCw8Nx5swZNG7c2CRjO5V1/Y4dO4a//vpLdmuiHCqVCkKIQvv1qlWrCl2279GjB9atW4c//vhD777Qu3dvREZGwsfHxygnQqGhoWjdujU+/vhjxMbG4o033ijybuKi3sdLdQawYP8qKoG2w96oUaPEkSNHxIkTJ6QOmvo6hz/ZQVdfB8fVq1cLADqdEiMjI4WTk5MYNWqU2LJli4iJiRGbNm0SU6dOFR988IHpVvQJhw4dEq6urqJGjRriwIED4ujRozqvgp1RHz16JBo1aiQCAwPF119/LaKiosTzzz8vnJycRExMjFTu9u3bombNmkKj0Yj169cXWmZ8fLxU9ttvvxUODg6iWbNm4pdffilUtuA4UvrIjevnn38W3bp1E8uXLxd79+4V27ZtE2PGjBGOjo6iY8eOsjuHnzhxQnz33Xfiu+++E4GBgaJhw4bS31euXJHK9e3bV7z//vvihx9+EDExMWLDhg2ia9euAoBYunSpzjK1Y+OU1MlZ37732muvCY1GIz799FOxf/9+MX/+fFGpUiVRtWpVnX03NTVVNGrUSJQrV0589NFHYu/eveLHH38UU6ZMEQcOHBBCPO6A26NHD+Ht7S1mzZoldu3aJfbt2yfWrFkjhgwZYlDndu2NBqtXr5amjR8/XqjVanH8+HHZyymr+fPni6FDh4p169aJ6OhosWnTJum7iIiI0Cm7du1a4ejoKNauXaszfeTIkUKj0YgFCxaImJgY8Z///EeoVCoxZ84cnXIPHjyQ9oepU6dKn/Hdd9/pdEDevn276Nu3r1i1apWIiooSO3fuFLNnzxbe3t6idu3aIjk5WSp7/vx54eXlJZ5++mmxevVqER0dLbZt2yYWLlwowsPDi113OeM4GbJ+jRs3FvPnzxfbt28XUVFRYs6cOaJChQoiICBA3Lx5U6fskCFDZHVy1ld3tm/fXnh7e4uVK1eKqKgo8d5774nKlSuLChUqiCFDhkjlrl+/LipXrix8fX3FokWLxP79+8UPP/wgXn/9dXHx4kUhxOPx5Zo2bSqqVq0qPvnkExEVFSX27NkjVq5cKV566SVx7NixErfRk7QdwlUqlfjzzz8Nfr8hitovr1y5IhwdHcXw4cN1ytaqVUv2OHhKx8RJ4WbMmCECAgKEg4ODzo+YKRInIYTYunWrCA8PF+XLlxcajUZUr15dvPjii2Lfvn0mWb+iaH+w9b2e/CFPSEgQr732mvD29hYuLi7imWeeKXSHVkl3jcycOVMqq61Y9b3k3lUiJ66//vpL9OzZU1SpUkVoNBrh4uIiQkJCxJw5c2QlaHJiLpggfPzxx6JFixbCy8tLODo6Ch8fH9GtWzexY8eOQsucOnWqUKlUUiWvj759LykpSYwYMUL4+voKNzc30bZtW3Ho0KFC+6627KRJk0S1atWEWq0Wvr6+olevXuLSpUtSmezsbPHf//5XNGnSRLi4uIhy5cqJ+vXri1GjRom//vpL1nb6/fffhaurq84PnBCPE93Q0FBRo0YNkZSUJGtZZbVt2zbRtm1bUalSJeHk5CQ8PDxEu3btxDfffFOorPZ4LfhdCvF48NKZM2eKatWqCWdnZ1G3bl3xv//9r9D7i7sbsGACc/HiRfHiiy+K6tWrCxcXF+Hi4iLq168vpk+frjPgZMHlDh8+XFSpUkWo1WpRqVIl0bp1a/HRRx8Vu+5yEye56zdgwABRu3Zt4e7uLtRqtahevboYPXp0oaRJCCFeeOEF4erqWuL3rK/uvH79unjhhReEl5eX8PDwEN27dxexsbGievXqhfar+Ph4MXz4cOHv7y/UarUICAgQ/fv317nzLT09Xbz33nuiXr16wtnZWXh6eoqQkBDx5ptvioSEhBK30ZMyMzOFRqMR3bt3N/i9hipqv9Tua09ui+rVq8v6zq2BSohSDqpDRDbt6aefRvXq1fHdd99ZOhQio/H398fgwYML3exhK7Zv346+ffvip59+Qs+ePS0djk1i4kREhaSmpqJSpUo4e/ZssbdTE1mT8+fPo1WrVrh8+bLBHa+V7sKFC7h69SomTZoEd3d3nD59ukxDUpB+TJyIyCbk5eUhLy+v2DK8lZqsjdz9ukOHDvjll1/QrFkzrF27FvXr1zdThPaHj1whIpugfSZXca8rV65YOkwigwwfPrzE/RoAYmJikJ2djePHjzNpMjG2OBGRTbh582aJDzI11a3zRKZy5cqVEgfCNNVQJVQ0Jk5EREREMvFSHREREZFM7CkpU15eHm7evAkPDw/eqUBERGQlhBBIS0tDQECAUR7Bw8RJpps3byIwMNDSYRAREVEpxMfHl/jgZTmYOMmkfYhofHw8ypcvb+FoiIiISI7U1FQEBgYa/DBwfZg4yaS9PFe+fHkmTkRERFbGWN1s2DmciIiISCYmTkREREQyMXEiIiIiksmiidPPP/+MPn36ICAgACqVClu3btWZL4RAREQEAgIC4Orqig4dOuD8+fM6ZTIzMzFhwgRUrFgR7u7u6Nu3L65fv65TJikpCYMHD4anpyc8PT0xePBgJCcnm3jtiIiIyNZYNHF68OABmjRpgiVLlhQ5f/78+Vi4cCGWLFmCEydOwN/fH126dEFaWppUZvLkydiyZQs2btyIw4cPIz09Hb1790Zubq5UZuDAgTh79ix2796N3bt34+zZsxg8eLDJ14+IiIhsjFAIAGLLli3S33l5ecLf31/MmzdPmvbo0SPh6ekpli9fLoQQIjk5WajVarFx40apzI0bN4SDg4PYvXu3EEKICxcuCADi2LFjUpmjR48KAOLSpUuy40tJSREAREpKSmlXkYiIiMzM2L/fiu3jFBcXh4SEBHTt2lWaptFoEBYWhiNHjgAATp06hezsbJ0yAQEBCA4OlsocPXoUnp6eaNmypVTmmWeegaenp1SGiIiISA7FjuOUkJAAAPDz89OZ7ufnh6tXr0plnJ2d4eXlVaiM9v0JCQnw9fUttHxfX1+pTFEyMzORmZkp/Z2amlq6FSEiIiKbodgWJ60nB6wSQpQ4iNWTZYoqX9Jy5s6dK3Um9/T05ONWiIiISLmJk7+/PwAUahVKTEyUWqH8/f2RlZWFpKSkYsvcvn270PLv3LlTqDWroBkzZiAlJUV6xcfHl2l9iIiIyPopNnEKCgqCv78/oqKipGlZWVk4ePAgWrduDQAIDQ2FWq3WKXPr1i3ExsZKZVq1aoWUlBT8+uuvUpnjx48jJSVFKlMUjUYjPV6Fj1khIiIiwMJ9nNLT0/H3339Lf8fFxeHs2bPw9vZGtWrVMHnyZERGRqJOnTqoU6cOIiMj4ebmhoEDBwIAPD09MWLECEydOhU+Pj7w9vbGtGnTEBISgs6dOwMAGjRogO7du+P111/HihUrAABvvPEGevfujXr16pl/pYmIiMhqWTRxOnnyJMLDw6W/p0yZAgAYMmQI1qxZg7feegsZGRkYO3YskpKS0LJlS+zdu1fnCceffvopnJyc0L9/f2RkZKBTp05Ys2YNHB0dpTJff/01Jk6cKN1917dvX71jRxGZStKDLDzIyim2jEqlQoCni9EeRklERMalEkIISwdhDVJTU+Hp6YmUlBRetiODHbh0GyPXnkSejKOtR7A/Pns11PRBERHZAWP/fit2OAIiW/L79RTkCcBBBagdi+5aKASQlZuH3+KTzRscERHJxsSJyAxy/21qGvxMdcx6NrjIMrE3UtB78WFZrVJEZLjs3DwkpDwqsZynmxrlXdRmiIisERMnIjPQJk6ODvpvZNV2a8rj1XMioxNCoM/iw7iUkFZiWWcnB/w0oS3q+HmUWJbsDxMnIjPQJk5Ojvo7fTv8mzmxxYnI+B5l50lJk8bJAfruv8jMyUNWzuOyTJyoKEyciMxAmzg5FHO3nHYe79cgMr7cAsfVbzO7wkXtWGS5QauO4Ze/77Hll/RS7ACYRLYkR9vi5FBc4vT4X1bYRMaXm5t/XBV3HKqgPYExeUhkpdjiRFRG6Zk5+D0+GcXVs9eTMgAAjsVV2NoWJ2MGR0QAgJy8POn/xR+Hj//lCQzpw8SJqIyGrzmBX+PuyyqrLraP0+N/89jJicjotJfqHFRFP/hdi30NqSRMnIjKKP7+QwBAdR83uOrpNwEA5V3U6B5cWe/8/D5Oxo2PiAre2Vr8qPy8ZE4lYeJEVEba+nXpwGYIruJZ6uXkn+mywiYy1MOsHDzMytU7/156FgA5iRNv0qDiMXEiKiNhpF5J+X0rjLI4Irtx6moSXll5DFk5eSWWdSzhOZAqXqqjEvCuOqIy0p6YlvW5vOyUSlQ6v19PlpU0ASj2cjnAS3VUMrY4EZWRtnrV3sZcWuzjRFQ62mOmT5MALH6laZmWxc7hVBImTkRlZKwWJ22FnZOXh29PxhdbtmoFV7SuXbFsH0hkI/JPXspO+1Qk9nEifZg4EZXZ4wq2rImTs9PjGjtPAG99/3uJ5XdObIeGAeXL9qFENkCb5JT1GHy8jH9bnNjkRHowcSIqI6nFqYznu97uzpjerR5OXU0qttyvcfeRnpmDO+mZZfo8IltjlBYnXqqjEjBxIlKQceG1SyzT8/8O4cKtVDNEQ2Qd8i+Xlz110nYO/+7UdZy6pv8kRu2gwpDWNdC0mleZP5OsCxMnojKS+lcY43RXBu3nsA8G0WPaIUGMcQh6uzsDAC7eSsXFEk5QUh/l4MuhLYzwqWRNmDgRlZHUv8Lcn2vmzyNSKmHE3uGTO9VFPT8PZBYzvMFv15Ox+fQNZOboH3CTbBcTJ6IyslSLEzMnoseMNSQIAHi6qTHg6WrFlvnx7A1sPn2DQ4fYKQ6ASVRG+ZWneTIn7Y+DsUYsJ7J2xhoShEgOJk5EZWTMW6Hl4I8DkS5j9nGSQ8XBau0aEyeiMjLm4HtySFfqWGkTAbBcixNbfe0TEyeisjLirdAGfSzrbCIdxujjJO9zHuMxaJ+YOBGVkblbnLSn1ayziR6z1OVyHoP2iYkTURmZvdJ+4nOJ7J25L9WZq2WLlImJE1EZGfNWaDnYOZxIV/4phJmPQZ672CUmTkRlZP6z3X8/1zwfR6R47BxO5sTEiaiMLFV58kod0WNmH45A+7k8Bu0SEyeiMjJ7ixOvExDpMP8x+O/nmufjSGGYOBGVUf4jV3grNJElmLufofmfTElKwsSJqKy0Z7tm+jh2Did6gqWGI+DZi11i4kRURlL/CjPfCs0qm+gxs4+l9sTnkn1h4kRURlL/CjNX2zzZJXosv48TL5eT6TFxIiqj/D5OZvpAqWMqa20iwPzHgoqj99s1Jk5EZSSNHG6mz+PZLpEuS42lxoPQPjlZOgAipRJC4MezN3EjOaPYcnlm7mDBzuFEujh6P5kTEyciPX67noLJm87KKqtSARonR9MGpP0sdg4n0mG5kcPJHjFxItIjJSMbAFDBTY1uDf2LLdusegV4uqrNEZaEt0KTPbh27yGiLt4udn//LT4ZgPmHBOEhaJ+YOBHpoa2oq1RwxccvNrZwNPl4mYDsyVs//IZjl+/LKuuiNnerLzMne8TEicjK8GyX7Enyw8ctv21q+8DXw0VvOXeNI15pWc08QfEYtGtMnIj0MPswAzKZe7woIkvSJidjO9RGm9oVLRvMv3gE2jcOR0Ckj4UGtpSLlwmILEMax4mHoF1i4kRkZXipjuyJ9EgjC8dRFB6C9omJE5Ee5n4GnaGYOJE9EGYeJ02O/EFoeRDaIyZORFaGj3sgsiylnkyReTBxItIj/+G9yqK0eIhMydyjgsuhpFjI/Jg4EekhlHpb3b94mYDIMtjP0L4xcSKyMlKlbdkwiMxCeoi2As9feGerfeI4TkR6KLBPKoD8eP5MSMOhv+7oLefs6IBm1b2gduT5EVkvJR6H+Z3DLRoGWQgTJyIr4+jwOBFadTgOqw7HFVv2jfY18Z+eDcwRFpH9YKuvXWPiRKSHUi8RDGpZDYlpj5CVk6e3TNLDLNxOzcT1pIdmjIzIBLQ3aSjoQGTncPvGxImoBEqrIsPr+yK8vm+xZdYdvYL3fzzPSwlEJqDN4a7cfYA28w4UW7ZxVU8sG9RMUYkflQ0TJyI9mHMQWZ4Sb26t5u0GtaMK2bkCN5Izii17IzkDN5IzUNXLzUzRkakxcSLSQyjwEoFsfJYW2RglHYUBFVzxyzsdkZDyqNhyLy4/iqycPB6HNoaJExERKZZSxyvz9XCBr4dLsWUcrfGki0rE+5SJ9FLuw0VLIt0uzQuOZOWUeKnOUArN/aiUmDgRlcCaK2wishzWHbZJ0YlTTk4O3nvvPQQFBcHV1RU1a9bE7NmzkZeXfxu2EAIREREICAiAq6srOnTogPPnz+ssJzMzExMmTEDFihXh7u6Ovn374vr16+ZeHbIy1nyWyEdCkK3I34etLwthy69tUnTi9PHHH2P58uVYsmQJLl68iPnz52PBggVYvHixVGb+/PlYuHAhlixZghMnTsDf3x9dunRBWlqaVGby5MnYsmULNm7ciMOHDyM9PR29e/dGbm6uJVaLrIQSHy5KZK/YekNKoejO4UePHsWzzz6LXr16AQBq1KiBb775BidPngTwuLVp0aJFePfdd9GvXz8AwNq1a+Hn54cNGzZg1KhRSElJwRdffIF169ahc+fOAID169cjMDAQ+/btQ7du3SyzckQmpE32eJ5L1s6aW2tUvLvVJim6xalt27bYv38//vzzTwDAb7/9hsOHD6Nnz54AgLi4OCQkJKBr167SezQaDcLCwnDkyBEAwKlTp5Cdna1TJiAgAMHBwVKZomRmZiI1NVXnRfZFKPEhWUR2RhoWxLJhEEkU3eL09ttvIyUlBfXr14ejoyNyc3MxZ84cvPLKKwCAhIQEAICfn5/O+/z8/HD16lWpjLOzM7y8vAqV0b6/KHPnzsWsWbOMuTpkpayxwmYfJyLLy+/jRLZE0S1OmzZtwvr167FhwwacPn0aa9euxX//+1+sXbtWp9yTAxQKIUoctLCkMjNmzEBKSor0io+PL/2KkFWy5ksERLbCqgeiJZuk6Ban6dOn45133sGAAQMAACEhIbh69Srmzp2LIUOGwN/fH8DjVqXKlStL70tMTJRaofz9/ZGVlYWkpCSdVqfExES0bt1a72drNBpoNBpTrBZZGWusr/NDZvJHtsEKD0MpaKUO4kmlo+gWp4cPH8LBQTdER0dHaTiCoKAg+Pv7IyoqSpqflZWFgwcPSklRaGgo1Gq1Tplbt24hNja22MSJiHUdERE9SdEtTn369MGcOXNQrVo1NGrUCGfOnMHChQsxfPhwAI+bbidPnozIyEjUqVMHderUQWRkJNzc3DBw4EAAgKenJ0aMGIGpU6fCx8cH3t7emDZtGkJCQqS77IiKYs3DEbCPE9kaa2755WFoWxSdOC1evBjvv/8+xo4di8TERAQEBGDUqFH44IMPpDJvvfUWMjIyMHbsWCQlJaFly5bYu3cvPDw8pDKffvopnJyc0L9/f2RkZKBTp05Ys2YNHB0dLbFaZGWsscLWYoVN1o6XuUhpFJ04eXh4YNGiRVi0aJHeMiqVChEREYiIiNBbxsXFBYsXL9YZOJOoJNZcYVtjKxlRUay75ZfjONkiRfdxIlICq25xYo1NNsKaj0OyLUyciGwRf2TIRlhz7p+f7FnxSlAhTJyISmCVlwj+/ZfVNRGRcTFxItIjf+A9y8ZBZM+seSBa6QTGeleBisDEiUgPq66w2SmVbIw1n8DwMLQtTJyIiEix8h/ya32ZEx8TY5uYOBHpYc2tNezjRLbCFvZha65LqDAmTkQl4FkjkeVZ42FohSGTDEyciPTIv0RgfVR8uCjZCGvehaXj0CbazUiLiRORHqzqiJTDGlucyDYxcSIqgTVW2NYYM1HRHp/CWGPncG17tTW3mlFhTJyI9OBlLiLL42FISsPEiagE1nmeyzNdsi3W2Iqa39fQsnGQcTFxItJDeiq7NdbYRDaCOQcpDRMnIhvEu3nI1ljj6Uv+eGo8Dm0JEycifax4OAIiW6Hta8iGX1IKJ0sHQGQJQghcu/8QWTl5esvcTn1kxohMg30riCyHfZxsExMnskv/2/83Pt33p6yyPNMlspz8nIMHIimDrMSpX79+Bi94+fLl8PX1Nfh9ROZwKSEVAOCqdoSLWv8Va7WjA/o0CTBXWEaj7dDOM11SsuSHWUgooWU3N9d6d2LrHHuKSiIrcdq6dSv69+8PV1dXWQvdsGED0tPTmTiR4v2nVwMMfqa6pcMwGXZKJaW6m56Jth8fwKNs/ZfLC2LLLymF7Et1//vf/2QnQt9//32pAyIyB1tvieFvDCld/P2HeJSdBwcV4O2uKbZsg8oeqOHjbqbIjId9nGyTrMQpOjoa3t7eshe6a9cuVKlSpdRBEZFxsMImpavi5YpDb3W0dBhEsslKnMLCwgxaaNu2bUsVDJG5COn5V7aJlzVI6ewhp+c4TraJ4zgR2SDpkSsWjoOI2PJrawxKnJYtW4bOnTujf//+OHDggM68u3fvombNmkYNjshUtBUZW2aILEM6Bm223ZePa7JVshOn//3vf5g+fTrq168PjUaDnj17Yu7cudL83NxcXL161SRBEpFhVPnXCIjIwngY2hbZd9WtWLECK1euxMCBAwEAY8eOxXPPPYeMjAzMnj3bZAESmYL0AF8bPtslUjY+SoWsk+zEKS4uDq1bt5b+btWqFQ4cOIBOnTohOzsbkydPNkV8RFQK7JRKZHn5wxHwOLQlshOnihUrIj4+HjVq1JCmNWrUCAcOHEDHjh1x48YNU8RHZFI82yWyDMGHaJOVkt3HqW3btvjhhx8KTW/YsCH279+P3bt3GzUwIlOy9RNADrxHZHnScWjZMMjIZLc4vfPOOzh16lSR8xo1aoTo6GiOGE5ERAbhnWdkbWQnTo0bN0bjxo31zm/UqBEaNWpklKCITM+2B8AEx3EihbOHfVMaT80eVtaOlGkAzJCQEMTHxxsrFiIiIiJFK1PidOXKFWRnZxsrFiKzsfUBMHk3DymdPXQOz69feBzaEj5yhYiIiEgm2X2citKuXTu4uroaKxYis7H1ATC1a/XX7XQMXHms2LKtavpgQqc6pg+KqABhB01O0nhqbHCyKWVKnHbu3GmsOIjIiPzKuwAA0jJzcOSfe8WWPfLPPQxrG4RymjJVB0REdqFUNeWNGzfwyy+/IDExEXl5eTrzJk6caJTAiKj0Glf1xLejWuFWSobeMrl5AlO+/U36P5E55bf62i7tUAsTvjkDV7Wj3nLlXJwwt18IGgV4mis0KgODE6fVq1dj9OjRcHZ2ho+Pj84YHCqViokTWQVbv0ygUqnwdJB3sWWyc/OkxIl9V4mMr7qPG+LuPsCtlEcllt0dm8DEyUoYnDh98MEH+OCDDzBjxgw4OLBvORERlZ4tD4C5/NVQnL+ZguIadFf/Eoed5xKQx45QVsPgxOnhw4cYMGAAkyayavZwmaAk9rzuZHn2kCe4qB0RWr34lt+d524BsI/tYSsMzn5GjBiB7777zhSxEJGFCF6rIyKSxeAWp7lz56J3797YvXs3QkJCoFardeYvXLjQaMERmUr+AJhsdyGyBGHzjz2SR8XHI1kdgxOnyMhI7NmzB/Xq1QOAQp3Dicg6FDxeeZmAiEgegxOnhQsX4ssvv8TQoUNNEA6ReTHVJ7IQG3/skVz2vv7WyOA+ThqNBm3atDFFLERmwwYW3aSR24PIstjqaz0MTpwmTZqExYsXmyIWIiKyE7b+2COyXQZfqvv1119x4MAB7NixA40aNSrUOXzz5s1GC47IVLQDYNpzM7k9rzuRUkjPs2O7r9UwOHGqUKEC+vXrZ4pYiMhCBK8TkIUwgSdrU6pHrhDZClbaRJbBXP0x1kHWh8N/E9kpneEILBgHEYEHoRVh4kR2Kf8ZvzzdI7IE9ukha8XEiYiIyEK0Lb9MI60HEyeya+xf8Bj7m5C58bFHZK1kJ05///23KeMgMiteJiAiJZCGI+DZi9WQnTjVrVsXgYGBeO2117B69WpcuXLFhGERkTloT/aZSJK55Q+ASWRdZA9HcPDgQRw8eBAxMTEYP348Hj16hGrVqqFjx44IDw9HeHg4qlSpYspYiYyGJ3dEpAjMHK2O7Bandu3a4b333sO+ffuQnJyM6OhoDBs2DHFxcXjjjTdQrVo11KtXz+gB3rhxA6+++ip8fHzg5uaGp556CqdOnZLmCyEQERGBgIAAuLq6okOHDjh//rzOMjIzMzFhwgRUrFgR7u7u6Nu3L65fv270WImsjVRnM5EksiiezFmPUnUOV6vVaN++PaZPn44ZM2Zg7NixKFeunNH7QSUlJaFNmzZQq9XYtWsXLly4gE8++QQVKlSQysyfPx8LFy7EkiVLcOLECfj7+6NLly5IS0uTykyePBlbtmzBxo0bcfjwYaSnp6N3797Izc01arxkPdgxlciy+NgjslYGjRz+6NEjHDlyBNHR0YiJicGJEycQFBSEsLAwfPbZZwgLCzNqcB9//DECAwN1RiuvUaOG9H8hBBYtWoR3331XegzM2rVr4efnhw0bNmDUqFFISUnBF198gXXr1qFz584AgPXr1yMwMBD79u1Dt27djBozkTVRqVQ81SWyIO1YcjwKrYfsFqewsDB4e3tj0qRJuH//PiZMmICrV6/i4sWLWL58OQYOHGj0Pk7btm1D8+bN8dJLL8HX1xdNmzbFypUrpflxcXFISEhA165dpWkajQZhYWE4cuQIAODUqVPIzs7WKRMQEIDg4GCpTFEyMzORmpqq8yLboe0MzZPdx1hpk7lJncN5EJKVkZ04HTlyBBUrVkR4eDg6deqEjh07ws/Pz5Sx4fLly/jss89Qp04d7NmzB6NHj8bEiRPx1VdfAQASEhIAoFAcfn5+0ryEhAQ4OzvDy8tLb5mizJ07F56entIrMDDQmKtGRESUf2crz16shuzEKTk5GZ9//jnc3Nzw8ccfo0qVKggJCcH48ePx/fff486dO0YPLi8vD82aNUNkZCSaNm2KUaNG4fXXX8dnn32mU+7JfipCiBL7rpRUZsaMGUhJSZFe8fHxpV8RUix7P9vNH0PGomGQPeJjj8hKyU6c3N3d0b17d8ybNw/Hjx/H3bt3MX/+fLi5uWH+/PmoWrUqgoODjRpc5cqV0bBhQ51pDRo0wLVr1wAA/v7+AFCo5SgxMVFqhfL390dWVhaSkpL0limKRqNB+fLldV5kO5goEJESMG20PqV+5Iq7uzu8vb3h7e0NLy8vODk54eLFi8aMDW3atMEff/yhM+3PP/9E9erVAQBBQUHw9/dHVFSUND8rKwsHDx5E69atAQChoaFQq9U6ZW7duoXY2FipDJG94gCYZGn23uqrxWPQesi+qy4vLw8nT55ETEwMoqOj8csvv+DBgweoUqUKwsPDsXTpUoSHhxs1uDfffBOtW7dGZGQk+vfvj19//RWff/45Pv/8cwCPL9FNnjwZkZGRqFOnDurUqYPIyEi4ublh4MCBAABPT0+MGDECU6dOhY+PD7y9vTFt2jSEhIRId9mR/ckftZi1NpElMFEgayU7capQoQIePHiAypUro0OHDli4cCHCw8NRq1YtkwXXokULbNmyBTNmzMDs2bMRFBSERYsWYdCgQVKZt956CxkZGRg7diySkpLQsmVL7N27Fx4eHlKZTz/9FE5OTujfvz8yMjLQqVMnrFmzBo6OjiaLnYiIqCTsHG59ZCdOCxYsQHh4OOrWrWvKeArp3bs3evfurXe+SqVCREQEIiIi9JZxcXHB4sWLsXjxYhNESFZJGgDTsmFY2uMWN8FKm8xOGoTWsmEQGUx24jRq1ChTxkFERGR32F3A+sjqHN6vXz+DBoAcNGgQEhMTSx0UkalxAMx/SZ3DicxLcARMslKyWpx+/PFH2eM0CSGwfft2fPjhh/D19S1TcERERERKIitxEkKYvW8TEZkez/XJUvLvbLVv+Z3D2e5rLWQlTtHR0QYv2NjPrSMyJsHO4TpYaRMRySMrcQoLCzN1HEREZIfs/eRFeuyRRaMgQ5R65HAia5ZfSdl3rc0xZMhS2MpJ1oqJExERkaXYe5ObFWLiRHZJe7Zr73UWx5AhS2HncF1sgLMeTJyIiIiIZDI4cTp//rzeebt37y5TMETmZu9nu/be4kaWk39nq33vhPmdw9nkZC0MTpyaN29e6JlvmZmZGD9+PJ5//nmjBUZkSqyidPEyARGRPAYnTl9//TVmzZqFHj16ICEhAWfPnkXTpk1x4MAB/PLLL6aIkYiIbA4fewTwzlZrJPshv1r9+vXDM888gyFDhiA4OBgPHjzAsGHD8Mknn8DV1dUUMRIZZNWhyzh2+X6xZf5JTAfAywS8TEBEZBiDEycAyM3NRVZWFnJzc5Gbmwt/f39oNBpjx0ZksAeZOZiz86Lsszefcs6mDYiIimXn5y68s9UKGZw4bdy4EWPGjEG7du3w559/4uzZsxg2bBj27NmDdevWoWbNmqaIk0iWnFwhJU0fPRcMRwf9lZK/pwuaBlYwT2AKZe8tbmQa0ZcSMWPzOWRk5+otk52bZ8aIlI9tvtbD4MRpxIgR+O9//4sxY8YAALp06YJz585h1KhReOqpp5Cammr0IInkKnjJaUCLQDg5csQNOdi/goxpz/kEJKQ+klW2QeXyJo6GyLgMTpxOnz6NevXq6Uzz8vLCt99+i3Xr1hktMCIisk7aRHx4myAMbFlNbzknBxWq+7iZKSplYudw62Nw4vRk0lTQ4MGDyxQMkTHxMlTJ+IBRMgVty69POWfU9i1n4WiIjMvgxGn48OHFzv/yyy9LHQxRWfGsjYisSf7pHSsva2Fw4pSUlKTzd3Z2NmJjY5GcnIyOHTsaLTAiMgPpMgErbTI+NvqSLTI4cdqyZUuhaXl5eRg7dizvqCNFYZ1NZBnMw+Vjcml9jHLLkYODA9588018+umnxlgcUamxvjYM62wiZWCyaT2Mdq/2P//8g5ycHGMtjojMiHU2GZN2f+LgjmSLDL5UN2XKFJ2/hRC4desWfvrpJwwZMsRogRGVRsG+OmwCJyKl0979yxYn62Fw4nTmzBmdvx0cHFCpUiV88sknJd5xR0TKwkqbTIknL2SLDE6coqOjTREHkdFxHCciy2AiTraMz6Mgm8L62jDMLYmUQbD2shqyWpyaNm0q++z99OnTZQqIiCyBlTYZjzYJYF5OtkhW4vTcc8+ZOAwi4+AlAiKyJnxWnfWRlTjNnDnT1HEQkQVIz6pjpU0mwEvBZItk93H68ssvkZmZacpYiIyGFTaRBTERl0071hU3mfWQnTi9/vrrSElJkf4OCAjAlStXTBETUamxg6VhpOEILBwHEZG1kJ04PfkQ0LS0NOTl5Rk9ICIisg0cObxkbB23PhyOgGzLv/k96yJ5uJ3IFNiCaTj2M7QesgfAVKlUOkMSPPk3EVmvKd+ehZtaf3Xg6aZGRN9GqFLB1YxREREpj+zESQiBunXrSslSeno6mjZtCgcH3Uar+/fvGzdCIjIZv/IuuPcgC7E3Ukss2zLIGyPb1TRDVGTttF07eG5dMu0m+uN2KpYf/KfYsmF1K6FB5fKmD4qKJTtxWr16tSnjIDIK6ansrLFlWTv8aZy8UvzJzpojV3A87j5y83gtgcjYXNSOAIDYG6klnsB8ezIeB6Z2MENUVBzZidOQIUNMGQcRWUAlDw16hFQutsy+i4k4Hnef/VaITKBvkwBcu/8QyQ+z9ZZJycjGvou3kVJMGTIfgx/yS2QN2N5EZDlMsuXzcnfG+70bFlvmz9tp2HfxtpkiopLwrjqyKbwzxfh41ZNIGVi9KQMTJyKShUkpyaXdV9jXkGwREyeyKdJT2VlfE5GNyH+mJM9elMDgxGn27Nl4+PBhoekZGRmYPXu2UYIiIuVgDkqlxX2HbJHBidOsWbOQnp5eaPrDhw8xa9YsowRFVFZ81IPx8TmAJBf3FONiC7qyGJw4CSGKvG7922+/wdvb2yhBEZUWW7KJyFaxelMG2cMReHl5SY9ZKTiCOADk5uYiPT0do0ePNkmQRGQ52kOdSSnJxZHDyZbJTpwWLVoEIQSGDx+OWbNmwdPTU5rn7OyMGjVqoFWrViYJkkgu6bedFTYR2YzHFRpPXpTB4JHDg4KC0Lp1a6jVapMFRUTKwf5iVFrcc8gWGTxyeFhYmPT/jIwMZGfrDgFfvjwfQEiWxwqbyHLYMGJcvOSpLAZ3Dn/48CHGjx8PX19flCtXDl5eXjovIkviOCdEZKtYvymDwYnT9OnTceDAASxbtgwajQarVq3CrFmzEBAQgK+++soUMRKRBeV3DmelTTJx5HCyYQZfqtu+fTu++uordOjQAcOHD0e7du1Qu3ZtVK9eHV9//TUGDRpkijiJDML6mohsBaszZTG4xen+/fsICgoC8Lg/0/379wEAbdu2xc8//2zc6IgMxEYR42MSSqXFfce4WL0pg8GJU82aNXHlyhUAQMOGDfHtt98CeNwSVaFCBWPGRkQKwqSU5OIo82TLDE6chg0bht9++w0AMGPGDKmv05tvvonp06cbPUCi0uAt9ERkK6S+YsxHFcHgPk5vvvmm9P/w8HBcunQJJ0+eRK1atdCkSROjBkdESsAklEqHew7ZIoMTp4IePXqEatWqoVq1asaKh8go2LfC+HiyS3Lxsq5xsTpTFoMv1eXm5uLDDz9ElSpVUK5cOVy+fBkA8P777+OLL74weoAFzZ07FyqVCpMnT5amCSEQERGBgIAAuLq6okOHDjh//rzO+zIzMzFhwgRUrFgR7u7u6Nu3L65fv27SWMkyWGETka1i9aYMBidOc+bMwZo1azB//nw4OztL00NCQrBq1SqjBlfQiRMn8Pnnn6Nx48Y60+fPn4+FCxdiyZIlOHHiBPz9/dGlSxekpaVJZSZPnowtW7Zg48aNOHz4MNLT09G7d2/k5uaaLF4iW8GH/JKhpH2FTb9kgwxOnL766it8/vnnGDRoEBwdHaXpjRs3xqVLl4wanFZ6ejoGDRqElStX6oxOLoTAokWL8O6776Jfv34IDg7G2rVr8fDhQ2zYsAEAkJKSgi+++AKffPIJOnfujKZNm2L9+vU4d+4c9u3bZ5J4yXK0d/OwuiYiW8FBaJXF4MTpxo0bqF27dqHpeXl5hZ5bZyzjxo1Dr1690LlzZ53pcXFxSEhIQNeuXaVpGo0GYWFhOHLkCADg1KlTyM7O1ikTEBCA4OBgqUxRMjMzkZqaqvMiskdMQqm0uO+QLTI4cWrUqBEOHTpUaPp3332Hpk2bGiWogjZu3IjTp09j7ty5heYlJCQAAPz8/HSm+/n5SfMSEhLg7Oxc6Dl6BcsUZe7cufD09JRegYGBZV0VMiM+6sH4ODYPycV9xbg4vIqyGHxX3cyZMzF48GDcuHEDeXl52Lx5M/744w989dVX2LFjh1GDi4+Px6RJk7B37164uLjoLffkj6QQosQfzpLKzJgxA1OmTJH+Tk1NZfJkBdiSTUS2itWbMhjc4tSnTx9s2rQJO3fuhEqlwgcffICLFy9i+/bt6NKli1GDO3XqFBITExEaGgonJyc4OTnh4MGD+N///gcnJyeppenJlqPExERpnr+/P7KyspCUlKS3TFE0Gg3Kly+v8yKyR+wcToYS0kN+LRsHkSkYnDgBQLdu3XDw4EGkp6fj4cOHOHz4sE4fImPp1KkTzp07h7Nnz0qv5s2bY9CgQTh79ixq1qwJf39/REVFSe/JysrCwYMH0bp1awBAaGgo1Gq1Tplbt24hNjZWKkO2Q7qZx6JREBEZD09elKVMA2CamoeHB4KDg3Wmubu7w8fHR5o+efJkREZGok6dOqhTpw4iIyPh5uaGgQMHAgA8PT0xYsQITJ06FT4+PvD29sa0adMQEhJSqLM5ERXG/hVUWtx3yBbJTpy8vLxkdbi9f/9+mQIy1FtvvYWMjAyMHTsWSUlJaNmyJfbu3QsPDw+pzKeffgonJyf0798fGRkZ6NSpE9asWaMznALZGNbXRseTXZKL+wrZMtmJ06JFi6T/CyEwZswYzJ49G76+vqaIS6+YmBidv1UqFSIiIhAREaH3PS4uLli8eDEWL15s2uDI4jjOCRHZKt6tqAyyE6chQ4bo/D1hwgS88MILqFmzptGDIiLlYAdfMhQ7h5MtK1XncCKlY31tAmzNI7IIJqDKwsSJbAp/2omUg7/3xsVzF2Vg4kRExdL++LHOJvm4t5Dtkt3HqeAo2sDj8ZLmzJkDT09PnekLFy40TmREpZDft4LnukRkG7T1GdNRZZCdOJ05c0bn79atW+Py5cs60/hjRWR7eFyTodg5nGyZ7MQpOjralHEQGRUrbONj/woiy2B1pizs40Q2hr/uRGSjWL0pAhMnIpKFg++RXPnPjGRbCdkeJk5kU6S+FZYNg4jIaKSH/PLkRRGYOBERkWnwDIZskEGJU05ODmbNmoX4+HhTxUNkFLwTzHiks12e7JJMfGakcfGSp7IYlDg5OTlhwYIFyM3NNVU8RGXC6pqIbBXzUWUw+FJd586dERMTY4JQiEiJeLZLhsrvHE5ke2SP46TVo0cPzJgxA7GxsQgNDYW7u7vO/L59+xotOCJDsXO46fBkl8gy8juHkxIYnDiNGTMGQNGPVlGpVLyMR0REANjXkGyTwYlTXl6eKeIgMirW18bDzuFkKO4rZMsMTpyILOVhVg42nYhHSka23jJ30zPNGBERkelpzwN5t6IylCpxevDgAQ4ePIhr164hKytLZ97EiRONEhjRk7aeuYlZ2y/IKuvq7GjiaOwHG++ooJSMbFy6lVpsmeR/T26475AtMjhxOnPmDHr27ImHDx/iwYMH8Pb2xt27d+Hm5gZfX18mTmQyqY8eV8Y1K7qjVS2fYsv2CK5sjpDsCkctJiEEei8+hPj7GbLKO3CIZeNgBqooBidOb775Jvr06YPPPvsMFSpUwLFjx6BWq/Hqq69i0qRJpoiRSEez6l6Y83yIpcMgskvapKmGjxscHfT/olfy0KBN7YrmCssu8NRFGQxOnM6ePYsVK1bA0dERjo6OyMzMRM2aNTF//nwMGTIE/fr1M0WcROxwaiFSR3tufypg89g28HZ3tnQYRGZncEOqWq2WbjH18/PDtWvXAACenp7S/4mIyPbw5MUytIPQcvsrg8EtTk2bNsXJkydRt25dhIeH44MPPsDdu3exbt06hITw8gmZjraPDS/3ExGRpRjc4hQZGYnKlR93vP3www/h4+ODMWPGIDExEZ9//rnRAyQiy9K2MPNklwruAzyBMR+OS6csBrc4NW/eXPp/pUqVsHPnTqMGRFQSViJERGQpvFmUrAav71sG81QqCk9gyF7JanFq2rSp7GcOnT59ukwBEZEycdRi4j5gGQV/fYUQfAaghclKnJ577jkTh0Ekn4ptIEREZCGyEqeZM2eaOg4iUio+5Jf+pds5nCcw5sIWJmUp9UN+T506hYsXL0KlUqFhw4Zo2rSpMeMiKkR7mYB1CBHZKyFYB1qawYlTYmIiBgwYgJiYGFSoUAFCCKSkpCA8PBwbN25EpUqVTBEnEVkIWxaoSNwtyE4ZfFfdhAkTkJqaivPnz+P+/ftISkpCbGwsUlNT+YBfIhvGK3XEy7WWwRxVWQxucdq9ezf27duHBg0aSNMaNmyIpUuXomvXrkYNjqggbaXNZmoislfMXS3P4BanvLw8qNXqQtPVajXy8vKMEhQRKQcTVdISBX62uV+QvTI4cerYsSMmTZqEmzdvStNu3LiBN998E506dTJqcEQFFaiyLRiF/eJlGiLLKJikciwtyzM4cVqyZAnS0tJQo0YN1KpVC7Vr10ZQUBDS0tKwePFiU8RIREQKw9MXslcG93EKDAzE6dOnERUVhUuXLkEIgYYNG6Jz586miI+ILEz7AynYu8LusbHDMnhnq7KUehynLl26oEuXLsaMhahY7BxORPaOuavlyb5Ud/z4cezatUtn2ldffYWgoCD4+vrijTfeQGZmptEDJCLLYqJKReFo1mSvZLc4RUREoEOHDujRowcA4Ny5cxgxYgSGDh2KBg0aYMGCBQgICEBERISpYiU7p71UxOraMrb/dhOnryXrna8C8Ooz1fFiaFWzxURkFwpUemfjk+HkoL8W9CvvgoAKrmYIyn7JTpzOnj2LDz/8UPp748aNaNmyJVauXAngcd+nmTNnMnEisjHaSvhuehbupmcVWzY9M4eJkw0r2MeJJzDmUzBPemn50WLLqlTAnsntUdfPw8RR2S/ZiVNSUhL8/Pykvw8ePIju3btLf7do0QLx8fHGjY6oCLxCYF6vtKiG2pXKIT0zR2+ZvxLTMW/XJeTlsQcGkbF5uKjRv3lVHPnnXrHlElMzkZWbh6v3HjJxMiHZiZOfnx/i4uIQGBiIrKwsnD59GrNmzZLmp6WlFTkwJpGx8I4ey3BwUKFlTZ9iy3i6Pj72+RXZD57AmNf8F5uUWKbfsl+KvZxOxiG7c3j37t3xzjvv4NChQ5gxYwbc3NzQrl07af7vv/+OWrVqmSRIIiKyPA5JYR04SKZpyW5x+uijj9CvXz+EhYWhXLlyWLt2LZydnaX5X375JZ9VRyalrQo4ponyaFsfWGETka2TnThVqlQJhw4dQkpKCsqVKwdHR0ed+d999x3KlStn9ACJiEgZdDuH8wRGabRDRPD0xbQMHgDT09OzyOne3t5lDoZIDvatUCJW2ERkHwx+Vh2RxfAyEJFi8ARGeaTHI7GqNCkmTkREJAt/j4mYOJEVye8cTkqT3zncsnEQ2bP8VkAeiKbExImIiGThXZNETJzICvHhosoj9a3gmS6RxWjvdGR+a1pMnMhqsDIgUg6ev5C9YuJERGUmjR/D5Nam8eu1DvyeTIuJE1kNXgYiIioGWwHNgokTERkNW5xsG0cOJ1J44jR37ly0aNECHh4e8PX1xXPPPYc//vhDp4wQAhEREQgICICrqys6dOiA8+fP65TJzMzEhAkTULFiRbi7u6Nv3764fv26OVeFjIh9K5SHXwmR5XEATPNQdOJ08OBBjBs3DseOHUNUVBRycnLQtWtXPHjwQCozf/58LFy4EEuWLMGJEyfg7++PLl26IC0tTSozefJkbNmyBRs3bsThw4eRnp6O3r17Izc31xKrRaXEyoBIOXgCQ/bK4GfVmdPu3bt1/l69ejV8fX1x6tQptG/fHkIILFq0CO+++y769esHAFi7di38/PywYcMGjBo1CikpKfjiiy+wbt06dO7cGQCwfv16BAYGYt++fejWrZvZ14vI1vBH1E7w5EXRpIFo+UWZlKJbnJ6UkpICIP+BwnFxcUhISEDXrl2lMhqNBmFhYThy5AgA4NSpU8jOztYpExAQgODgYKlMUTIzM5GamqrzIsvKHzmcv9JERGQZVpM4CSEwZcoUtG3bFsHBwQCAhIQEAICfn59OWT8/P2leQkICnJ2d4eXlpbdMUebOnQtPT0/pFRgYaMzVIbIp+QPv8UzXlhVsyeDpi/JwAEzzsJrEafz48fj999/xzTffFJr35EjSQogSR5cuqcyMGTOQkpIiveLj40sXOBkdLwsREZGlWEXiNGHCBGzbtg3R0dGoWrWqNN3f3x8ACrUcJSYmSq1Q/v7+yMrKQlJSkt4yRdFoNChfvrzOiyyLZ1HKld+3guwFH32kXDwOTUvRiZMQAuPHj8fmzZtx4MABBAUF6cwPCgqCv78/oqKipGlZWVk4ePAgWrduDQAIDQ2FWq3WKXPr1i3ExsZKZYiIqGQ8eVE25rLmoei76saNG4cNGzbgxx9/hIeHh9Sy5OnpCVdXV6hUKkyePBmRkZGoU6cO6tSpg8jISLi5uWHgwIFS2REjRmDq1Knw8fGBt7c3pk2bhpCQEOkuO7IO2v4VrBuUiz+sRJbHvoampejE6bPPPgMAdOjQQWf66tWrMXToUADAW2+9hYyMDIwdOxZJSUlo2bIl9u7dCw8PD6n8p59+CicnJ/Tv3x8ZGRno1KkT1qxZA0dHR3OtChGR1Sv4c8wTGOVhi5N5KDpxkpM1q1QqREREICIiQm8ZFxcXLF68GIsXLzZidGQprByUi+PHEJGtU3QfJyId/E1WLCaz9qHgySy/c+XhGHfmwcSJiIyGXSuIyNYxcSKrIY0czlNdxeGZLpFy8ATGtJg4ERGRLDqdw3kCozj8SsyDiRNZHdYNysUTXSLL400apsXEiawGxyZRLp7p2gcegkRMnIjIiPjDSmR5PA5Ni4kTWQ2pMmDrhuKwxcm+8PtWJvY7Mw8mTkRkRDzVtWXsO2Md2OJkWkycyOrw1nfl4XdCZHk8Cs2DiRNZDZ5EKR/PdG3cv98vf6CVjYehaTFxIqIyY9cKIrIXTJzIamhbM/gjrVw807UP7ISsTPxazIOJExERycLE2DpwzDvTYuJEVocnVcrD74TI8ngcmgcTJ7IavBVa+Xima9sEO4dbBR6FpsXEiYjKjH0riCyPfc/Mg4kTWQ12Dlc+nunaBx6DCscD0aSYOBGREfCX1B7wcrmy8Sg0DyZOZHU4SrVysYsTkeUxwTUtJ0sHQAQA2367iY2/Xiv2hzfu7gPzBURkZ4QQOHElCffSM/WWSXqYDYAnL2TfmDiRIvxv/1/4OzFdVlnf8hoTR0OG0vZ54V111ivmjzsYtuaErLKODkyclCj/OLRsHLaOiRMpQnZuHgBgcuc6qFmpnN5yHhontK1T0VxhEdmNWymPAAAV3NSo46v/GASAbo38zRESkSIxcSJF0J4htatTEaHVvS0bDBmM7Q/WT9sv5uka3vj8teYWjoZKh0eiObBzOCkMD3xrxisE1ouXd2wHv0rTYuJEisC7QKwbB96zftojkF+l9eJ3Zx5MnEgROLiljWD+a/V4x5z1Y+uhaTFxIkVhlW2d+L3ZgH9/bXnyYr341ZkHEydShPwWJx761ownutaL353tYNcH02LiREREvFxOJBMTJ1IE7cCJrLOtEwfAtB3s42S9OACmeTBxIkXh2S6RZUhJL49BomIxcSJFkG6FZq1tlbTfG090rRe/O+vH49A8mDiRIrBpmciy2OBEJA8TJ1IE7V0gvFRnnfi9Wb/8ATD5ZVorfnXmwcSJiIyGLYfWj7+9NoAHokkxcSJF4K3QRJbFOyKtH+tP83CydABEADsz2opHObl4ecXRYstU83ZDZL8QqB153qZE/PG1fkuj/8E3v8brna92csDkznUQXs/XjFHZDiZOpAj5HVNZa1ujCm5qaJwckJmTh+Nx94stezzuPgY8HYjQ6t5mio7kYOdw61fVyw0AkJD6CAmpj4ot+/Wxa0ycSomJEykKz3atk4eLGj9NbIs/EtKLLffhjgtISH2E7Fy2MSoVO4dbr+nd6iG8ni+ycvP0lvn5zzv44nAc8nhpttSYOJFC8K46a1fb1wO1fT2KLbNo359ISAUrbQXi882sn9rRAa1q+RRbJvHfligeg6XHTgakCDyG7YOUGPP7VhxeqrMP2hZF1rmlx8SJFIEjh9sHjmysXNJ3wkPQpvHcpeyYOJGi8FKdbeNDSJWPJy+2jQ/kLjsmTqQI2oOYVbZt014mYP8K5eFXYh8ceKmuzJg4kSLwGLYPvEygXHzskX2QWpx4FJYaEydSBI4cbh94mUC52DncvvAQLD0mTqQwrLZtWf7ZLikVT15sG++qKzsmTqQIUh8nVto2Lb9/BWttpWLncNvm8O/Xy36GpcfEiRSBh7B9kPo48QtXHCaz9oFDgpQdEydSBvavsA+8TKBY7GdoHzgIbdkxcSJF4XOybBvrbOXjIWjb8o9BHoWlxcSJFCF/5HCyZSr2r1Cs/G+ER6Etyx9LzcKBWDEmTqQI7F9hHzj4nnLxO7EPHBKk7Jg4kSJILU482bVp+V8vK22l4QCY9oGXy8uOiRMpCm+Ftm18Vp3y8Qi0bRzHqeyYOJEi8I4e+6BNjNm/Qnl4DNqH/CFBeBCWFhMnUgTe4WEf+Jws5eI3Yh8c/v3V5/ddenaVOC1btgxBQUFwcXFBaGgoDh06ZOmQ7EJObh7SHmUX++LJj33gpTrLEEIgMe0RElL0v9If5QDg5XJbJw2AyWOw1JwsHYC5bNq0CZMnT8ayZcvQpk0brFixAj169MCFCxdQrVo1S4dns+6lZ6Lbop9xNz1LVnleJrBtHLXYMmZuO4+vjl6VVZbHoI1jq2+Z2U3itHDhQowYMQIjR44EACxatAh79uzBZ599hrlz51osrjtpmcjMybXY55var3H3ZSdN9f094F/excQRkSVpf5Tj7z/E+Zsphefrae0o6se8yGmGvL+EGEsqrS/BKGqyvoFdiy5bVDn561WUw3/fBQA4OqikZ5UVxVXtiA71KslbKFkl7df/MDMX564/Pgaf3I9Uqvx9TjtP+rfAdBXwxPufeA/y9/0ny6qgKvJzK5bTwEXtWKp1Mxe7SJyysrJw6tQpvPPOOzrTu3btiiNHjhT5nszMTGRmZkp/p6ammiS2qd/9hp//vGOSZStJixpeWD+yZbFlnB0dOHK4jXP891d7wZ4/sGDPHxaOxv78MKY1ngqsYOkwyIK0x+Dluw/QZ8lhC0dT2FfDn0b7uspO3u0icbp79y5yc3Ph5+enM93Pzw8JCQlFvmfu3LmYNWuWyWNzdlRB42TbXc3Ujg7o2yQAGidln0WQ6T3ftAou33mA7Nw8nen6LhoU3Q+j6NJFldW/3MJzDIlB3x1Jei9+mDM2PaVr+5ZDfX8PPUsie/FUYAW0qOGFG0kZ0p6i3Y+0+44QKDQPBebl//V4fy20nH//88RbIYqY9+RnO1jBybNdJE5aT7ZmCCH0tnDMmDEDU6ZMkf5OTU1FYGCg0WNaNaSF0ZdJpFT9mlVFv2ZVLR0Gkd3ycFHju9GtLR2GVbOLxKlixYpwdHQs1LqUmJhYqBVKS6PRQKPRmCM8IiIishK2fY3oX87OzggNDUVUVJTO9KioKLRuzcybiIiI5LGLFicAmDJlCgYPHozmzZujVatW+Pzzz3Ht2jWMHj3a0qERERGRlbCbxOnll1/GvXv3MHv2bNy6dQvBwcHYuXMnqlevbunQiIiIyEqoBB9YI0tqaio8PT2RkpKC8uXLWzocIiIiksHYv9920ceJiIiIyBiYOBERERHJxMSJiIiISCYmTkREREQyMXEiIiIikomJExEREZFMTJyIiIiIZGLiRERERCQTEyciIiIimezmkStlpR1gPTU11cKREBERkVza321jPSiFiZNMaWlpAIDAwEALR0JERESGSktLg6enZ5mXw2fVyZSXl4ebN2/Cw8MDKpXKaMtNTU1FYGAg4uPj7foZeNwO3AYAtwHAbaDF7cBtABhnGwghkJaWhoCAADg4lL2HElucZHJwcEDVqlVNtvzy5cvb7YFRELcDtwHAbQBwG2hxO3AbAGXfBsZoadJi53AiIiIimZg4EREREcnExMnCNBoNZs6cCY1GY+lQLIrbgdsA4DYAuA20uB24DQBlbgN2DiciIiKSiS1ORERERDIxcSIiIiKSiYkTERERkUxMnIiIiIhkYuJkYcuWLUNQUBBcXFwQGhqKQ4cOWTqkEs2dOxctWrSAh4cHfH198dxzz+GPP/7QKTN06FCoVCqd1zPPPKNTJjMzExMmTEDFihXh7u6Ovn374vr16zplkpKSMHjwYHh6esLT0xODBw9GcnKyTplr166hT58+cHd3R8WKFTFx4kRkZWWZZN0LioiIKLSO/v7+0nwhBCIiIhAQEABXV1d06NAB58+f11mGtW+DGjVqFNoGKpUK48aNA2Cb+8HPP/+MPn36ICAgACqVClu3btWZr7Tv/dy5cwgLC4OrqyuqVKmC2bNnl/mZXcVtg+zsbLz99tsICQmBu7s7AgIC8Nprr+HmzZs6y+jQoUOhfWPAgAFWsw1K2g6A8vZ/c+8LAIqsH1QqFRYsWCCVsbp9QZDFbNy4UajVarFy5Upx4cIFMWnSJOHu7i6uXr1q6dCK1a1bN7F69WoRGxsrzp49K3r16iWqVasm0tPTpTJDhgwR3bt3F7du3ZJe9+7d01nO6NGjRZUqVURUVJQ4ffq0CA8PF02aNBE5OTlSme7du4vg4GBx5MgRceTIEREcHCx69+4tzc/JyRHBwcEiPDxcnD59WkRFRYmAgAAxfvx4k2+HmTNnikaNGumsY2JiojR/3rx5wsPDQ/zwww/i3Llz4uWXXxaVK1cWqampNrMNEhMTddY/KipKABDR0dFCCNvcD3bu3Cneffdd8cMPPwgAYsuWLTrzlfS9p6SkCD8/PzFgwABx7tw58cMPPwgPDw/x3//+12TbIDk5WXTu3Fls2rRJXLp0SRw9elS0bNlShIaG6iwjLCxMvP766zr7RnJysk4ZJW+DkraDEMra/y2xLwghdNb91q1b4ssvvxQqlUr8888/Uhlr2xeYOFnQ008/LUaPHq0zrX79+uKdd96xUESlk5iYKACIgwcPStOGDBkinn32Wb3vSU5OFmq1WmzcuFGaduPGDeHg4CB2794thBDiwoULAoA4duyYVObo0aMCgLh06ZIQ4vFB6+DgIG7cuCGV+eabb4RGoxEpKSnGWsUizZw5UzRp0qTIeXl5ecLf31/MmzdPmvbo0SPh6ekpli9fLoSwjW3wpEmTJolatWqJvLw8IYTt7wdP/lAo7XtftmyZ8PT0FI8ePZLKzJ07VwQEBEjfkbG3QVF+/fVXAUDnpDAsLExMmjRJ73usaRsIUfR2UNL+r5R94dlnnxUdO3bUmWZt+wIv1VlIVlYWTp06ha5du+pM79q1K44cOWKhqEonJSUFAODt7a0zPSYmBr6+vqhbty5ef/11JCYmSvNOnTqF7OxsnfUPCAhAcHCwtP5Hjx6Fp6cnWrZsKZV55pln4OnpqVMmODgYAQEBUplu3bohMzMTp06dMv7KPuGvv/5CQEAAgoKCMGDAAFy+fBkAEBcXh4SEBJ3102g0CAsLk2K3lW2glZWVhfXr12P48OE6D8K2h/1AS2nf+9GjRxEWFqYzeGC3bt1w8+ZNXLlyxfgbQI+UlBSoVCpUqFBBZ/rXX3+NihUrolGjRpg2bRrS0tKkebayDZSy/1t6OwDA7du38dNPP2HEiBGF5lnTvsCH/FrI3bt3kZubCz8/P53pfn5+SEhIsFBUhhNCYMqUKWjbti2Cg4Ol6T169MBLL72E6tWrIy4uDu+//z46duyIU6dOQaPRICEhAc7OzvDy8tJZXsH1T0hIgK+vb6HP9PX11Snz5Db08vKCs7Ozybdjy5Yt8dVXX6Fu3bq4ffs2PvroI7Ru3Rrnz5+XPruo7/fq1atS7Na+DQraunUrkpOTMXToUGmaPewHBSnte09ISECNGjUKfY52XlBQUGlW0yCPHj3CO++8g4EDB+o8pHXQoEEICgqCv78/YmNjMWPGDPz222+IioqS4rP2baCk/V8J+8LatWvh4eGBfv366Uy3tn2BiZOFFTwzBx4nIk9OU7Lx48fj999/x+HDh3Wmv/zyy9L/g4OD0bx5c1SvXh0//fRToYOmoCfXv6htUZoyptCjRw/p/yEhIWjVqhVq1aqFtWvXSh1AS/P9WtM2KOiLL75Ajx49dM747GE/KIqSvveiYtH3XmPLzs7GgAEDkJeXh2XLlunMe/3116X/BwcHo06dOmjevDlOnz6NZs2a6Y3RmraB0vZ/S+4LAPDll19i0KBBcHFx0ZlubfsCL9VZSMWKFeHo6FjobDgxMbFQ1qxUEyZMwLZt2xAdHY2qVasWW7Zy5cqoXr06/vrrLwCAv78/srKykJSUpFOu4Pr7+/vj9u3bhZZ1584dnTJPbsOkpCRkZ2ebfTu6u7sjJCQEf/31l3R3XXHfry1tg6tXr2Lfvn0YOXJkseVsfT9Q2vdeVBntpSJTb5fs7Gz0798fcXFxiIqK0mltKkqzZs2gVqt19g1r3wZPsuT+b+ntcOjQIfzxxx8l1hGA8vcFJk4W4uzsjNDQUKkpUisqKgqtW7e2UFTyCCEwfvx4bN68GQcOHJDVvHnv3j3Ex8ejcuXKAIDQ0FCo1Wqd9b916xZiY2Ol9W/VqhVSUlLw66+/SmWOHz+OlJQUnTKxsbG4deuWVGbv3r3QaDQIDQ01yvrKlZmZiYsXL6Jy5cpSs3PB9cvKysLBgwel2G1pG6xevRq+vr7o1atXseVsfT9Q2vfeqlUr/Pzzzzq3ZO/duxcBAQGFLlkYkzZp+uuvv7Bv3z74+PiU+J7z588jOztb2jesfRsUxZL7v6W3wxdffIHQ0FA0adKkxLKK3xdkdyMno9MOR/DFF1+ICxcuiMmTJwt3d3dx5coVS4dWrDFjxghPT08RExOjc/vow4cPhRBCpKWlialTp4ojR46IuLg4ER0dLVq1aiWqVKlS6JbsqlWrin379onTp0+Ljh07FnkbbuPGjcXRo0fF0aNHRUhISJG3oHbq1EmcPn1a7Nu3T1StWtUst+JPnTpVxMTEiMuXL4tjx46J3r17Cw8PD+n7mzdvnvD09BSbN28W586dE6+88kqRt6Vb8zYQQojc3FxRrVo18fbbb+tMt9X9IC0tTZw5c0acOXNGABALFy4UZ86cke4YU9L3npycLPz8/MQrr7wizp07JzZv3izKly9f5lvQi9sG2dnZom/fvqJq1ari7NmzOnVEZmamEEKIv//+W8yaNUucOHFCxMXFiZ9++knUr19fNG3a1Gq2QUnbQWn7vyX2Ba2UlBTh5uYmPvvss0Lvt8Z9gYmThS1dulRUr15dODs7i2bNmunc0q9UAIp8rV69WgghxMOHD0XXrl1FpUqVhFqtFtWqVRNDhgwR165d01lORkaGGD9+vPD29haurq6id+/ehcrcu3dPDBo0SHh4eAgPDw8xaNAgkZSUpFPm6tWrolevXsLV1VV4e3uL8ePH69xuaira8XnUarUICAgQ/fr1E+fPn5fm5+XliZkzZwp/f3+h0WhE+/btxblz53SWYe3bQAgh9uzZIwCIP/74Q2e6re4H0dHRRe7/Q4YMEUIo73v//fffRbt27YRGoxH+/v4iIiKizLefF7cN4uLi9NYR2vG9rl27Jtq3by+8vb2Fs7OzqFWrlpg4cWKhMY6UvA1K2g5K3P/NvS9orVixQri6uhYam0kI69wXVEIYYfhUIiIiIjvAPk5EREREMjFxIiIiIpKJiRMRERGRTEyciIiIiGRi4kREREQkExMnIiIiIpmYOBERERHJxMSJiMhIYmJioFKpkJycbOlQiMhEmDgRERERycTEiYiIiEgmJk5EpFjff/89QkJC4OrqCh8fH3Tu3BkPHjwAAKxevRoNGjSAi4sL6tevj2XLlum89/r16xgwYAC8vb3h7u6O5s2b4/jx49L8zz77DLVq1YKzszPq1auHdevW6bxfpVJh1apVeP755+Hm5oY6depg27ZtOmV27tyJunXrwtXVFeHh4bhy5YrO/KtXr6JPnz7w8vKCu7s7GjVqhJ07dxpxCxGRuTlZOgAioqLcunULr7zyCubPn4/nn38eaWlpOHToEIQQWLlyJWbOnIklS5agadOmOHPmDF5//XW4u7tjyJAhSE9PR1hYGKpUqYJt27bB398fp0+fRl5eHgBgy5YtmDRpEhYtWoTOnTtjx44dGDZsGKpWrYrw8HAphlmzZmH+/PlYsGABFi9ejEGDBuHq1avw9vZGfHw8+vXrh9GjR2PMmDE4efIkpk6dqrMO48aNQ1ZWFn7++We4u7vjwoULKFeunFm3IxEZmUGPBCYiMpNTp04JAOLKlSuF5gUGBooNGzboTPvwww9Fq1athBCPn8bu4eFR6AnrWq1btxavv/66zrSXXnpJ9OzZU/obgHjvvfekv9PT04VKpRK7du0SQggxY8YM0aBBA50nq7/99tsCgPTU9pCQEBEREWHAWhOR0vFSHREpUpMmTdCpUyeEhITgpZdewsqVK5GUlIQ7d+4gPj4eI0aMQLly5aTXRx99hH/++QcAcPbsWTRt2hTe3t5FLvvixYto06aNzrQ2bdrg4sWLOtMaN24s/d/d3R0eHh5ITEyUlvHMM89ApVJJZVq1aqXz/okTJ+Kjjz5CmzZtMHPmTPz++++l3yBEpAhMnIhIkRwdHREVFYVdu3ahYcOGWLx4MerVq4fLly8DAFauXImzZ89Kr9jYWBw7dgwA4OrqWuLyCyY8ACCEKDRNrVYXeo/2cp8QosTPGDlyJC5fvozBgwfj3LlzaN68ORYvXlzi+4hIuZg4EZFiqVQqtGnTBrNmzcKZM2fg7OyMX375BVWqVMHly5dRu3ZtnVdQUBCAxy1FZ8+exf3794tcboMGDXD48GGdaUeOHEGDBg1kx9awYUMpUdN68m8ACAwMxOjRo7F582ZMnToVK1eulP0ZRKQ87BxORIp0/Phx7N+/H127doWvry+OHz+OO3fuoEGDBoiIiMDEiRNRvnx59OjRA5mZmTh58iSSkpIwZcoUvPLKK4iMjMRzzz2HuXPnonLlyjhz5gwCAgLQqlUrTJ8+Hf3790ezZs3QqVMnbN++HZs3b8a+fftkxzd69Gh88sknmDJlCkaNGoVTp05hzZo1OmUmT56MHj16oG7dukhKSsKBAwcMSs6ISIEs3cmKiKgoFy5cEN26dROVKlUSGo1G1K1bVyxevFia//XXX4unnnpKODs7Cy8vL9G+fXuxefNmaf6VK1fECy+8IMqXLy/c3NxE8+bNxfHjx6X5y5YtEzVr1hRqtVrUrVtXfPXVVzqfD0Bs2bJFZ5qnp6dYvXq19Pf27dtF7dq1hUajEe3atRNffvmlTufw8ePHi1q1agmNRiMqVaokBg8eLO7evWu8jUREZqcSQsaFeiIiIiJiHyciIiIiuZg4EREREcnExImIiIhIJiZORERERDIxcSIiIiKSiYkTERERkUxMnIiIiIhkYuJEREREJBMTJyIiIiKZmDgRERERycTEiYiIiEgmJk5EREREMv0/SJ1i399GnyAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reaction_model.dataset.q_solar.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "ac09bc56", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reaction_model.dataset.air_temp_c.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "ef180547", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reaction_model.dataset.surface_area.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "10c715fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reaction_model.dataset.water_temp_c.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2d2da52a-724d-46c7-9ed7-fda8bedfa6f3", + "metadata": {}, + "source": [ + "## Couple Models\n", + "Optionally, you can log output if you run for a long simulation to track progress." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "462f0a9e-7b70-4ae3-bb06-9e67ba4b80ca", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_function_logger(name):\n", + " logger = logging.getLogger('function_logger')\n", + " handler = logging.FileHandler(f'{name}.log')\n", + " formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n", + " handler.setFormatter(formatter)\n", + " logger.addHandler(handler)\n", + " logger.setLevel(logging.DEBUG) # Adjust the level based on your needs\n", + " return logger" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "32e3aed0-8dad-4767-bd0f-2bfe5308b4fe", + "metadata": {}, + "outputs": [], + "source": [ + "def run_n_timesteps(\n", + " time_steps: int,\n", + " reaction: EnergyBudget,\n", + " transport: cwr.ClearwaterRiverine,\n", + " meteo_params: dict,\n", + " concentration_update = None,\n", + " logging = True,\n", + " log_file_name='log',\n", + "):\n", + " \"\"\"Function to couple Clearwater Riverine and Modules for n timesteps.\"\"\"\n", + "\n", + " # Set up logger\n", + " if logging:\n", + " logger = setup_function_logger(f'{log_file_name}')\n", + "\n", + " for i in range(1, time_steps):\n", + " if i % 5000 == 0:\n", + " status = {\n", + " 'timesteps': i,\n", + " 'cwr': transport.mesh.nbytes * 1e-9,\n", + " 'cwm': reaction.dataset.nbytes*1e-9,\n", + " }\n", + " if logging:\n", + " logger.debug(status)\n", + "\n", + " # Top of timestep: update transport model using values with output from reaction model, if available\n", + " transport.update(concentration_update)\n", + "\n", + " # Update state values\n", + " updated_state_values = {\n", + " 'water_temp_c': transport.mesh['temperature'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'volume': transport.mesh['volume'].isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal+1\n", + " )\n", + " ), \n", + " 'surface_area': transport.mesh['wetted_surface_area'].isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal+1)\n", + " ), \n", + " 'q_solar': transport.mesh.temperature.isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal + 1)\n", + " ) * 0 + meteo_params['q_solar'][i],\n", + " 'air_temp_c': transport.mesh.temperature.isel(\n", + " time=i, nface=slice(0, transport.mesh.nreal + 1)\n", + " ) * 0 + meteo_params['air_temp_c'][i],\n", + " }\n", + "\n", + " # Bottom of timestep: update energy budget (TSM)\n", + " reaction.increment_timestep(updated_state_values)\n", + "\n", + " # Prepare data for input back into Riverine\n", + " ds = reaction.dataset.copy()\n", + " ds['water_temp_c'] = ds['water_temp_c'].where(\n", + " ~np.isinf(ds['water_temp_c']),\n", + " transport.mesh['temperature'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['water_temp_c'] = ds['water_temp_c'].fillna(\n", + " transport.mesh['temperature'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + " concentration_update = {\"temperature\": ds.water_temp_c.isel(seconds=i)}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "28b35563-bf79-4be1-9c30-7d86b41d2e7e", + "metadata": {}, + "outputs": [], + "source": [ + "TIME_STEPS = 172800 # len(transport_model.mesh.time) - 60" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "408f2fbe-ffbd-4cfb-afa2-45df1a5526f2", + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "index 172801 is out of bounds for axis 0 with size 172801", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32m:1\u001b[0m\n", + "Cell \u001b[1;32mIn[43], line 27\u001b[0m, in \u001b[0;36mrun_n_timesteps\u001b[1;34m(time_steps, reaction, transport, meteo_params, concentration_update, logging, log_file_name)\u001b[0m\n\u001b[0;32m 24\u001b[0m logger\u001b[38;5;241m.\u001b[39mdebug(status)\n\u001b[0;32m 26\u001b[0m \u001b[38;5;66;03m# Top of timestep: update transport model using values with output from reaction model, if available\u001b[39;00m\n\u001b[1;32m---> 27\u001b[0m \u001b[43mtransport\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconcentration_update\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 29\u001b[0m \u001b[38;5;66;03m# Update state values\u001b[39;00m\n\u001b[0;32m 30\u001b[0m updated_state_values \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m 31\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mwater_temp_c\u001b[39m\u001b[38;5;124m'\u001b[39m: transport\u001b[38;5;241m.\u001b[39mmesh[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtemperature\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;241m.\u001b[39misel(\n\u001b[0;32m 32\u001b[0m time\u001b[38;5;241m=\u001b[39mi,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 50\u001b[0m ) \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;241m+\u001b[39m meteo_params[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mair_temp_c\u001b[39m\u001b[38;5;124m'\u001b[39m][i],\n\u001b[0;32m 51\u001b[0m }\n", + "File \u001b[1;32mD:\\Clearwater\\ClearWater-riverine\\src\\clearwater_riverine\\transport.py:177\u001b[0m, in \u001b[0;36mClearwaterRiverine.update\u001b[1;34m(self, update_concentration)\u001b[0m\n\u001b[0;32m 173\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Update a single timestep.\"\"\"\u001b[39;00m\n\u001b[0;32m 175\u001b[0m \u001b[38;5;66;03m# Update the left hand side of the matrix\u001b[39;00m\n\u001b[0;32m 176\u001b[0m \u001b[38;5;66;03m# This is the same for all constituents\u001b[39;00m\n\u001b[1;32m--> 177\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlhs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_values\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 178\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmesh\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 179\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_step\u001b[49m\n\u001b[0;32m 180\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 182\u001b[0m \u001b[38;5;66;03m# Define compressed sparse row matrix for LHS\u001b[39;00m\n\u001b[0;32m 183\u001b[0m A \u001b[38;5;241m=\u001b[39m csr_matrix(\n\u001b[0;32m 184\u001b[0m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlhs\u001b[38;5;241m.\u001b[39mcoef, (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlhs\u001b[38;5;241m.\u001b[39mrows, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlhs\u001b[38;5;241m.\u001b[39mcols)),\n\u001b[0;32m 185\u001b[0m shape\u001b[38;5;241m=\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmesh\u001b[38;5;241m.\u001b[39mnreal \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmesh\u001b[38;5;241m.\u001b[39mnreal \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m 186\u001b[0m )\n", + "File \u001b[1;32mD:\\Clearwater\\ClearWater-riverine\\src\\clearwater_riverine\\linalg.py:66\u001b[0m, in \u001b[0;36mLHS.update_values\u001b[1;34m(self, mesh, t)\u001b[0m\n\u001b[0;32m 62\u001b[0m flow_out_indices_internal \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere((mesh[ADVECTION_COEFFICIENT][t] \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m&\u001b[39m \\\n\u001b[0;32m 63\u001b[0m (np\u001b[38;5;241m.\u001b[39misin(mesh\u001b[38;5;241m.\u001b[39mnedge, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minternal_edges)))[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m 64\u001b[0m flow_in_indices \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere((mesh[ADVECTION_COEFFICIENT][t] \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m&\u001b[39m \\\n\u001b[0;32m 65\u001b[0m (np\u001b[38;5;241m.\u001b[39misin(mesh\u001b[38;5;241m.\u001b[39mnedge, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minternal_edges)))[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m---> 66\u001b[0m empty_cells \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere(\u001b[43mmesh\u001b[49m\u001b[43m[\u001b[49m\u001b[43mVOLUME\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[43mt\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m)[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnreal_count]\n\u001b[0;32m 68\u001b[0m \u001b[38;5;66;03m# initialize arrays that will define the sparse matrix \u001b[39;00m\n\u001b[0;32m 69\u001b[0m len_val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minternal_edge_count \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnreal_count \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \\\n\u001b[0;32m 70\u001b[0m \u001b[38;5;28mlen\u001b[39m(flow_out_indices)\u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(flow_in_indices)\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(empty_cells) \u001b[38;5;241m+\u001b[39m \\\n\u001b[0;32m 71\u001b[0m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreal_edges_face1) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreal_edges_face2)\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\dataarray.py:875\u001b[0m, in \u001b[0;36mDataArray.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 872\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_coord(key)\n\u001b[0;32m 873\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 874\u001b[0m \u001b[38;5;66;03m# xarray-style array indexing\u001b[39;00m\n\u001b[1;32m--> 875\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_item_key_to_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\dataarray.py:1508\u001b[0m, in \u001b[0;36mDataArray.isel\u001b[1;34m(self, indexers, drop, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[0;32m 1503\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_from_temp_dataset(ds)\n\u001b[0;32m 1505\u001b[0m \u001b[38;5;66;03m# Much faster algorithm for when all indexers are ints, slices, one-dimensional\u001b[39;00m\n\u001b[0;32m 1506\u001b[0m \u001b[38;5;66;03m# lists, or zero or one-dimensional np.ndarray's\u001b[39;00m\n\u001b[1;32m-> 1508\u001b[0m variable \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmissing_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_dims\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1509\u001b[0m indexes, index_variables \u001b[38;5;241m=\u001b[39m isel_indexes(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mxindexes, indexers)\n\u001b[0;32m 1511\u001b[0m coords \u001b[38;5;241m=\u001b[39m {}\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\variable.py:1033\u001b[0m, in \u001b[0;36mVariable.isel\u001b[1;34m(self, indexers, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[0;32m 1030\u001b[0m indexers \u001b[38;5;241m=\u001b[39m drop_dims_from_indexers(indexers, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims, missing_dims)\n\u001b[0;32m 1032\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(indexers\u001b[38;5;241m.\u001b[39mget(dim, \u001b[38;5;28mslice\u001b[39m(\u001b[38;5;28;01mNone\u001b[39;00m)) \u001b[38;5;28;01mfor\u001b[39;00m dim \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims)\n\u001b[1;32m-> 1033\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\variable.py:800\u001b[0m, in \u001b[0;36mVariable.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 797\u001b[0m dims, indexer, new_order \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_broadcast_indexes(key)\n\u001b[0;32m 798\u001b[0m indexable \u001b[38;5;241m=\u001b[39m as_indexable(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data)\n\u001b[1;32m--> 800\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mindexing\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_indexer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 802\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_order:\n\u001b[0;32m 803\u001b[0m data \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mmoveaxis(data, \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(new_order)), new_order)\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\indexing.py:1026\u001b[0m, in \u001b[0;36mapply_indexer\u001b[1;34m(indexable, indexer)\u001b[0m\n\u001b[0;32m 1024\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m indexable\u001b[38;5;241m.\u001b[39moindex[indexer]\n\u001b[0;32m 1025\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mindexable\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindexer\u001b[49m\u001b[43m]\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\indexing.py:1515\u001b[0m, in \u001b[0;36mNumpyIndexingAdapter.__getitem__\u001b[1;34m(self, indexer)\u001b[0m\n\u001b[0;32m 1511\u001b[0m \u001b[38;5;66;03m# We want 0d slices rather than scalars. This is achieved by\u001b[39;00m\n\u001b[0;32m 1512\u001b[0m \u001b[38;5;66;03m# appending an ellipsis (see\u001b[39;00m\n\u001b[0;32m 1513\u001b[0m \u001b[38;5;66;03m# https://numpy.org/doc/stable/reference/arrays.indexing.html#detailed-notes).\u001b[39;00m\n\u001b[0;32m 1514\u001b[0m key \u001b[38;5;241m=\u001b[39m indexer\u001b[38;5;241m.\u001b[39mtuple \u001b[38;5;241m+\u001b[39m (\u001b[38;5;28mEllipsis\u001b[39m,)\n\u001b[1;32m-> 1515\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43marray\u001b[49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", + "\u001b[1;31mIndexError\u001b[0m: index 172801 is out of bounds for axis 0 with size 172801" + ] + } + ], + "source": [ + "%%time\n", + "run_n_timesteps(\n", + " TIME_STEPS,\n", + " reaction_model,\n", + " transport_model,\n", + " all_meteo_params,\n", + " logging=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "1ffec8b8-04e2-4a05-b835-f4f507bfeb7c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(time=5000).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "d0c630a5-339a-495d-a2a0-91e4735869e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(nface=217).plot()#, time=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "5377d829", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(nface=217, time=slice(21600, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "eab93216", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(nface=207, time=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "57dd8774", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(172801, 444)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.shape(transport_model.constituent_dict['temperature'].input_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "eaa7b560-a7ba-4737-a9c3-bd090bc8a7d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAHFCAYAAADhWLMfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7b0lEQVR4nO3dd3xTZfs/8M9J0qR7L7rLngICgshUpooMRVRUQFGerwMF0R+4RQUfBz7ugQo4wcUQEEFGAQVllVVWoYXSQSfdI03u3x9pQkNn2ux83q9XXtCTk5PrtD3pde77uu9bEkIIEBERETkBma0DICIiIjIXJjZERETkNJjYEBERkdNgYkNEREROg4kNEREROQ0mNkREROQ0mNgQERGR02BiQ0RERE6DiQ0RERE5DSY2ZHGrVq1Ct27d4OHhAUmSkJiYaOuQ7F5qaiokSar3sXLlymYdo6SkBE8++SQiIiLg7u6OXr16NfjagwcPYsSIEfD29oa/vz8mTZqEc+fOGe2zfPnyBmOSJAlvvPFGq8/bFM09v+nTp9cbb+fOnVv1/h988AHat28PpVIJSZJw+fLlVh3PVRw6dAgTJkxAREQEPD090blzZyxcuBBlZWVG+5n6c/vggw/QuXNnqFQqxMfH45VXXoFarW5WTGq1Gq+88gri4uKgUqnQuXNnfPDBB60+V7INha0DIOeWk5OD++67D2PGjMHHH38MlUqFjh072josh/H444/jnnvuMdrWoUOHZr120qRJ2LdvH9544w107NgR33//Pe6++25otVqjY548eRLDhg1Dr1698OOPP6KiogIvvvgiBg8ejMTERISEhAAAbrnlFuzZs6fO+7z44ovYsmULJk6c2IozNV1zzw8APDw8sG3btjrbWioxMRGzZ8/GzJkzMW3aNCgUCvj4+LT4eK4iKSkJAwcORKdOnfC///0PwcHB2LlzJxYuXIgDBw5g7dq1Rvs39+f2+uuv44UXXsD8+fMxatQo7Nu3D88//zzS09Px+eefNxnXI488gm+++Qavvvoq+vXrhz/++ANPPPEEiouL8eyzz7bupMn6BJEF7d69WwAQq1atsnUoDiUlJUUAEG+99VaLXr9hwwYBQHz//fdG20eOHCkiIiJEdXW1YdvkyZNFcHCwKCwsNGxLTU0Vbm5u4plnnmn0fUpKSoS3t7cYNGhQi+Ksz7Rp08TQoUMb3ceU85s2bZrw8vIyW3xCCPHtt98KAOKff/4x63Gd3XPPPScAiOTkZKPtDz/8sAAg8vPzDdua+3PLzc0V7u7u4uGHHzba/vrrrwtJksTx48cbff2xY8eEJEli0aJFRtsfeugh4eHhIfLy8pqMgewLu6LIYqZPn45BgwYBAKZMmQJJkjBs2DAAwP79+3HXXXchLi4OHh4eiIuLw913343z58/XOU56ejoefvhhREdHQ6lUIiIiAnfccQcuXbpk2KeoqAjz5s1DfHw8lEolIiMj8eSTT6K0tLTZ8ebm5iI6OhoDBw40asJOSkqCl5cX7rvvvhZ+J6xv9erV8Pb2xuTJk422z5gxAxkZGfjnn38AANXV1Vi/fj1uv/12+Pr6GvaLjY3F8OHDsXr16kbfZ9WqVSgpKcHMmTPrPLd//37cdtttCAwMhLu7O3r37o0ff/zRDGfX/POzhGHDhuHee+8FAPTv3x+SJGH69OkAgC1btmD8+PGIioqCu7s72rdvj1mzZiE3N7fOcU6ePIm7774bYWFhUKlUiImJwf3334/KykrDPllZWZg1axaioqKgVCoNXSzV1dXNjvfVV1+FQqFAWlpaneceeOABBAUFoaKiwsTvQsu4ubkBAPz8/Iy2+/v7QyaTQalUmnzMTZs2oaKiAjNmzDDaPmPGDAghsGbNmkZfv2bNGggh6n19eXk5Nm3aZHJMZGO2zqzIeSUnJ4uPPvpIABCLFi0Se/bsMdw9/fTTT+LFF18Uq1evFgkJCWLlypVi6NChIiQkROTk5BiOcfHiRdGmTRsRHBwslixZIv7880+xatUq8cADD4gTJ04IIYQoLS0VvXr1MtrnvffeE35+fuLGG28UWq222THv3r1bKBQKMWfOHMOxu3btKjp37ixKSkoafa1WqxVqtbpZj6boW2yCgoKEm5ub8PDwEDfccINYu3Zts85jwIABol+/fnW2Hzt2TAAQn332mRBCiJMnTwoA4qOPPqqz77x584QkSaK8vLzB9xk4cKDw9fUVpaWlRtu3bdsmlEqlGDx4sFi1apXYtGmTmD59ugAgli1b1mjszWmxae756Y8nk8lEWFiYkMlkIjIyUjz66KMtvhM/fvy4eP755w3nsmfPHkMLxCeffCIWL14s1q1bJxISEsSKFStEz549RadOnURVVZXhGImJicLb21vExcWJTz/9VGzdulV8++234s477xRFRUVCCCEyMzNFdHS0iI2NFZ999pn4888/xauvvipUKpWYPn16s+O9dOmSUKlU4rnnnjPanpeXJzw8PMTTTz/d6OvN/Xvt7+8v7rjjDnH27FlRVFQkfvvtN+Hn5ycef/xxo32b+3ObP3++AFDv9RkcHCzuvvvuRmO66667REhISJ3tJSUlAoBYsGBBk+dF9oWJDVnU9u3bBQDx008/NbpfdXW1KCkpEV5eXuK9994zbH/ggQeEm5ubSEpKavC1ixcvFjKZTOzbt89o+88//ywAiI0bN5oU83//+18BQKxevVpMmzZNeHh4iCNHjjT5Ov25NueRkpLS6LEyMjLEQw89JH788Uexa9cu8d1334kBAwYIAGLp0qVNxtKhQwcxevToeo+rTzSFEOKvv/4SAMQPP/xQZ99FixYJACIjI6Pe9zhx4oQAIGbNmlXnuc6dO4vevXvX+WN36623ijZt2giNRmPYdvUfx/vvv18MGTKkzvbaCWpzz08IIZYsWSKWLFkiNm/eLDZv3iyee+454enpKTp37iyKi4vrPbemLFu2TACo8ztXmz4hOH/+vABglJTeeOONwt/fX2RnZzf4+lmzZglvb29x/vx5o+1vv/22ANBkF0tt06ZNE6GhoaKystKw7b///a+QyWRN/i7qz7U5j+Y4ceKE6Ny5s9HrZs+eXecGpLk/t4ceekioVKp636tjx45i1KhRjcYzcuRI0alTp3qfUyqVdbq4yP6xeJhsoqSkBK+++ip++eUXpKamQqPRGJ47ceKE4f+///47hg8fji5dujR4rPXr16N79+7o1auXURP96NGjIUkSduzYgbFjxzY7tqeffho7d+7E3XffjYqKCnzxxRfo0aNHk6/r06cP9u3b16z3iIiIaPT5Nm3a1Cl6nDx5Mvr374/58+dj+vTpUCgav3wlSWr2c6bsq/fll18CQJ1uqOTkZJw8eRJvv/02ABj9TG6++WasX78ep06dQpcuXZCamor4+Ph6j6/vttDbvn27oSvTlJjnzJlj9NzIkSPRu3dv3HHHHVi6dGmd51sjOzsbL774IjZs2ICMjAxotVrDcydOnMBtt92GsrIyJCQk4MEHHzQUZtdn/fr1GD58OCIiIoy+h2PHjsW8efOQkJCArl27NiuuJ554AitWrMBPP/2EqVOnQqvV4pNPPsEtt9yCuLi4Rl87bty4Zv9eNyU1NRXjxo1DWFgYfv75Z4SEhOCff/7Ba6+9hpKSEsPvFGDaz60lv7/N3ac5ryf7wsSGbOKee+7B1q1b8cILL6Bfv37w9fWFJEm4+eabUV5ebtgvJycHUVFRjR7r0qVLSE5OrvOHUK+++obG6GsmNmzYgPDw8GbX1nh7e6NXr17N2reppKQ+bm5umDJlCubPn48zZ840muwFBQUhLy+vzvb8/HwAQGBgoGE/AA3uK0kS/P396zynVqvx9ddfo2fPnujbt6/Rc/rap3nz5mHevHn1xqf/mURERNT5o/nKK68gIyMDn332mdH2Tp06mXx+DZk4cSK8vLywd+/eRvczhVarxahRo5CRkYEXXngBPXr0gJeXF7RaLQYMGGD4vS4oKIBGo2nW7/Vvv/1mlt/r3r17Y/Dgwfjoo48wdepUrF+/HqmpqXW+x/UJDAysUxPTUvPnz0dRURESExPh5eUFABgyZAiCg4PxwAMP4P7778fQoUMbfH19Pzd9jVBZWRk8PT2N9s/Pz0efPn0ajSkoKKjeKShKS0tRVVXV5O8S2R8mNmR1hYWFWL9+PV566SXMnz/fsL2ystLwh0kvJCQEFy9ebPR4wcHB8PDwwFdffdXg86bIzMzEo48+il69euH48eOYN28e3n///SZfl5CQgOHDhzfrPVJSUpq8U66PEAIAIJM1Xvffo0cP/PDDD6iurjZKoo4ePQoA6N69OwCgXbt28PDwMGyv7ejRo2jfvj3c3d3rPLd+/XpkZ2fjhRdeqPOc/vu9YMECTJo0qd749EmKUqmskxgFBQWhuLi4zvaWnF9jhBBNfh9NcezYMRw+fBjLly/HtGnTDNuTk5ON9gsMDIRcLm/W7/U111yD119/vd7nm2r1u9rs2bMxefJkHDx4EB9++CE6duyIkSNHNvm6FStW1CmsbYj+97MhiYmJ6Nq1qyGp0evXrx8A3fewscRG/x61f2761tSjR4+if//+hu1ZWVnIzc1t8nehR48eWLlyJbKyshAeHm7YbsrvEtkXJjZkdZIkQQgBlUpltP2LL74w6pICdM3u33zzDU6dOmV0x17brbfeikWLFiEoKKjBbo3m0mg0uPvuuyFJEn7//Xd89913mDdvHoYNG9bgH2k9c3ZF1UetVmPVqlUIDg5G+/btG9134sSJWLp0KX755RdMmTLFsH3FihWIiIgw/AFQKBQYN24cfv31V7z55puGuVguXLiA7du3N9hN8+WXX8Ld3R1Tp06t81ynTp3QoUMHHD58GIsWLTL5PJujuefXkJ9//hllZWUYMGCA2WLSd1lc/Xt9dauIh4cHhg4dip9++gmvv/56g4n3rbfeio0bN6Jdu3YICAhodXwTJ05ETEwMnnrqKSQkJODdd99tVjeLObuiIiIicOzYMZSUlMDb29uwXT8/UlOtWPX93MaMGQN3d3csX77c6Oeun1BywoQJjR5z/PjxeP7557FixQr8v//3/4xe7+HhgTFjxphyimQPbFrhQ06voeLhIUOGiMDAQLF06VKxZcsW8fzzz4s2bdoIf39/MW3aNMN++lFRoaGh4n//+5/YunWr+OWXX8RDDz1kGBVVUlIievfuLaKiosQ777wjtmzZIv744w+xdOlSMXnyZLF3795mx/vcc88JmUwm/vzzT8O2cePGCX9/f3Hu3LnWfTNMMGfOHPHYY4+JH374QWzfvl18/fXXol+/fvWOKnrllVeEXC4XO3bsMNo+cuRIERAQID7//HOxbds28dBDDwkA4ttvvzXa78SJE8Lb21sMGTJEbNy4Ufz666+ie/fuIiIiot7i1vT0dCGXy8U999zTYPzbtm0TKpVKjBo1Snz//fciISFBrF69WixatEjccccdjZ57c0ZFNff8UlNTxcCBA8X7778vNm7cKH7//Xcxf/584e7uLrp161ZnJM3QoUObVQRbX/FwVVWVaNeunYiNjRXff/+92LRpk3j00UdFx44dBQDx0ksvGfbVj4pq27atIf4ffvhB3H333YZRURkZGSI2NlZ07txZfPzxx2Lr1q1iw4YN4qOPPhK33HKLSEtLazLOq+kL4728vMTly5dNfn1rrV27VkiSJAYMGCBWrVoltm7dKl5//XXh7e0tunbtaihuNvXn9tprrwlJksSzzz4rduzYId566y2hUqnEQw89ZLTfihUrhFwuFytWrDDaPnPmTKFSqcRbb70lduzYIZ599lkhSZJ4/fXXLfsNIYtgYkMW1VBic/HiRXH77beLgIAA4ePjI8aMGSOOHTsmYmNjjRIbIYRIS0sTDzzwgAgPDxdubm4iIiJC3HnnneLSpUuGfUpKSsTzzz8vOnXqJJRKpfDz8xM9evQQc+bMEVlZWc2KdfPmzUImkxn9ARJCNyw2JiZG9OvXz2hUiSV9+eWX4rrrrhOBgYFCoVCIgIAAMXr0aPHHH3/U2fell14SAMT27duNthcXF4vZs2eL8PBwoVQqxTXXXFPv6CchhNi/f7+46aabhKenp/D19RUTJkyoM4ma3uuvvy4AiG3btjV6DocPHxZ33nmnCA0NFW5ubiI8PFzceOON4tNPP230dc1NbJpzfvn5+WLixIkiLi5OeHh4CKVSKTp06CCeeeaZev+w9+nTR4SHhzf53g2NikpKShIjR44UPj4+IiAgQEyePFlcuHChTmKj33fy5MkiKChIKJVKERMTI6ZPny4qKioM++Tk5IjZs2eL+Ph44ebmJgIDA0WfPn3Ec8891+T0A/VJTU0VAMR//vMfk19rLtu2bROjRo0S4eHhwsPDQ3Ts2FE89dRTIjc317CPqT83IYR47733RMeOHQ3fy5deesloiL0QV35uV98cVFVViZdeeknExMQIpVIpOnbsKN5//32znztZhyREE52iREQuoLi4GIGBgfjf//6HRx991NbhWMQHH3yA2bNn49ixY+jWrZutwyGyCNbYEBEB2LlzJyIjI/HQQw/ZOhSzO3ToEFJSUrBw4UKMHz+eSQ05NbbYkEvQarVGc4rUpyVDsIlsSaPRNDoSSZIkyOVyxMXFISsrC4MHD8Y333xjNPqHyNkwsSGXMH36dKxYsaLRfXgpkKMZNmwYEhISGnw+NjYWqamp1guIyA4wsSGXkJqa2uSEZo3Nm0Jkj06dOoXi4uIGn1epVM2aNZvImTCxISIiIqdhvmk3iYiIiGzM6asltVotMjIy4OPjw8XMiIiIHIQQAsXFxYiIiDBp+ROnT2wyMjIQHR1t6zCIiIioBdLS0ppcbqM2p09s9GvfpKWlwdfX18bREBERUXMUFRUhOjra8He8uZw+sdF3P/n6+jKxISIicjCmlpGweJiIiIicBhMbIiIichpMbIiIiMhpMLEhIiIip8HEhoiIiJwGExsiIiJyGkxsiIiIyGkwsSEiIiKnwcSGiIiInAYTGyIiInIaTGyIiIjIaTCxISIiIqfBxIbIThSUVkGjFbYOg4jIoTn96t5E9q6gtAqPfHcQe87lISrAA5/e2wfdI/1sHRYRkUNiiw2RDWm1Av/33QHsOZcHALhYUI6ZK/ajtLLaxpERETkmJjZENvTTgTTsPZcPDzc5fv7P9YgJ9ERWUQW+3J1i69CIiBwSExsiG1FrtHh/azIAYO7IjugbF4inRnUEAHy79zzUGq0twyMickhMbIhsZMORTKRfLkeQlxL3XR8LABjbvQ2CvZXILq7E7jO5No6QiMjxMLEhsgEhBD7feQ4AMOOGOLi7yQEASoUMo7uFAwA2J12yWXxErqhao8V7f57B7Z/8jf9uOonKao2tQ6IWYGJDZANH0wuRlFkEpUKGqf1jjZ4bVZPY/HniEoTg8G8ia1nw61G8++dpHDhfgE92nMWCX47aOiRqASY2RDawal8aAGBs93AEeCmNnhvQNhDubjLkFFciObvEFuERuZw/ky7hpwMXIZOAmYPiIZdJ+PVQOv6pGbFIjoOJDZGVlVVVY11iBgBgSt/oOs+rFHJcGxMAANibkm/V2IhckVYr8PbmUwCAhwa3xfO3dsWUfrpr87OaLmNyHExsiKxs49EsFFdWIybQEwPaBtW7T/943XbeLRJZ3pYTl3AyqxjeKgX+b1g7AMCDg+IBADtOZSOrsMKW4ZGJmNgQWdmPNd1QU/pFQyaT6t3nuvhAAMC/KfmssyGysG/2nAcA3Hd9LPw9dV3D7UK80Tc2AFoBbDqWacvwyERMbIisKONyOf5NzYckAZOujWxwv17R/pBJQHZxJS4VVVoxQiLXcj6vFLuTcyFJwD3XxRg9N6pbGABg26kcW4RGLcTEhsiKNhzR3fn1iwtEGz+PBvfzUMrRIdQHgG4EFRFZxsqaFtQhHUIQHehp9NyNnUMBAHvP5nGZEwfCxIbIin47oisaHtczosl9e0TpFsJkYkNkGWqNFj/tvwgAuPu6uoX87UK8EenvgSqNFgcvFFg7PGohJjZEVpKaW4ojFwshl0kY2z28yf171KzwffTiZQtHRuSadpzKQW5JJYK9VbipS1id5yVJMtS77UtlYuMomNgQWcn6mtaage2CEOytanL/Ky02RSwgJrKAtYnpAIAJvSLgJq//z2HfON3UC/tTOfWCo2BiQ2Ql62vqa8Zd03Q3FAB0beMLmQTkllQip4QFxETmVFpZjT9P6JYtua1Xw9dkvzhdi82hC5e5MK2DYGJDZAVp+WU4mVUMuUzCyK51m7zr4+4mR2yQFwDgzCXOQExkTluSLqFCrUVckKeh27c+7UO84euuQLlag9OXiq0YIbUUExsiK9hSs6Bl39iAOksoNKZjmDcA4FQWP1CJzGndYV3X8G29IiFJ9c8nBQAymYRuEbrE53h6kVVio9ZhYkNkBfom7+a21uh1DNMN+eadIpH5FJRWYedp3dw0tzVjhGL3SF8AwLEMjlB0BExsiCyssEyNf2rWfGJiQ2R7m5OyUK0V6NrGF+1DvZvcv3tNV9UxTr3gEJjYEFnY9lPZ0GgFOoZ5G2pmmkuf2Jy5VMKRUURmou8aHtOMaRcAGLqikjKLoNHyOrR3TGyILEz/IWpqaw0AxAd7QSGTUFxZjUwuxEfUamVV1dh1JhdA86/J+GAveCrlqFBrcTaHhfz2zqaJzeLFi9GvXz/4+PggNDQUEyZMwKlTp4z2EULg5ZdfRkREBDw8PDBs2DAcP37cRhETmaaqWouEmr78EfVMANYUpUKG+GBdK88pdkcRtdrO07morNYiOtADncN9mvUauUwy7HuShfx2z6aJTUJCAh599FHs3bsXW7ZsQXV1NUaNGoXS0lLDPm+++SaWLFmCDz/8EPv27UN4eDhGjhyJ4mL+cpH9O3ihACWV1QjyUqJnlH+LjtGhZmTUuZzSJvYkoqYYWlC7hDc6Gupq+m7hZN5g2D2FLd9806ZNRl8vW7YMoaGhOHDgAIYMGQIhBP73v//hueeew6RJkwAAK1asQFhYGL7//nvMmjXLFmETNZt+5MXgDsGQyZr/IVqbvsUmJZdN4EStUa3RYutJXWKjX7m7uToYCvl5Hdo7u6qxKSzUVZwHBupmekxJSUFWVhZGjRpl2EelUmHo0KH4+++/6z1GZWUlioqKjB5EtqLvhhrSMaTFx4gP1rXYpOSyxYaoNfafL8DlMjX8Pd3QNzbApNd2qBk9dSabLTb2zm4SGyEE5s6di0GDBqF79+4AgKysLABAWJhxZh0WFmZ47mqLFy+Gn5+f4REdXXfFViJryCmuxPEMXWI9uENrEhtdiw27oohaZ2vNfFI3dg6FooG1oRqi74pKzStDZbXG7LGR+dhNYvPYY4/hyJEj+OGHH+o8d3U/qBCiwb7RBQsWoLCw0PBIS0uzSLxETdmdrGut6RbhixCfphe9bEjbmsQms7ACZVXVZomNyBXpR0MN7xRq8mvDfFXwUSmg0Qq2nto5u0hsHn/8caxbtw7bt29HVFSUYXt4uG6OgatbZ7Kzs+u04uipVCr4+voaPYhsIeGULrEZ2opuKAAI8FLC39MNAJCaW9bquIhcUXZxBU5mFUOSgBvaB5v8ekmSDIX8XLvNvtk0sRFC4LHHHsOvv/6Kbdu2IT4+3uj5+Ph4hIeHY8uWLYZtVVVVSEhIwMCBA60dLlGzabXCcHfYmvoavSsFxLxTJGqJv5J112O3CF8EmrBeW20dQvUTZrLOxp7ZdFTUo48+iu+//x5r166Fj4+PoWXGz88PHh4ekCQJTz75JBYtWoQOHTqgQ4cOWLRoETw9PXHPPffYMnRycOfzSvH0z0eQXlCOR4e3xz39Y8x6/KTMIuSVVsFbpcC1MaYVKdanbbA3Dl24zJFRRC2kv9EY1L7lNxqGFptsXof2zKaJzSeffAIAGDZsmNH2ZcuWYfr06QCAZ555BuXl5XjkkUdQUFCA/v37Y/PmzfDxad7ESkRXU2u0eHDFfiTXfDg9u/oo2vi5Y3hn0/vdG6IfDXV9uyAoFa1vGG0bUlNAzBYbIpMJIbC7JrEZ3MH0bii9diEcoegIbJrYNGftG0mS8PLLL+Pll1+2fEDkElYfSkdydgmCvJToGxeAP45fwmsbkjC0Y0iL55q52q4zrR/mXRu7ooha7kx2CbKLK6FSyNDHxGHetemvw9S8Umi1wmyfF2RedlE8TGRN3+w5DwCYNbQt3p7cEz4qBc7mlOKvs7lmOX5ZVTUOnr8MABjcgiLF+jCxIWo5fTfUdfGBcHeTt/g4UQEeUMgkVKi1yCri2m32iokNuZS0/DIcTS+ETAJuvzYKPu5umHhtJADgp/0XzfIe/6bko0qjRaS/B2KDPM1yzLiaVcEvl6lxuazKLMckchW7z1yZAbw1FHIZYgJ11zRvMuwXExtyKZuO6QrUB7QNQpC3bm6Z8b0iAADbT2Wjqlrb6vfQj74Y1D7YpLVoGuOhlCO0Zi6c83kc8k3UXFXVWvyTkg+gdYXDeoYJM5nY2C0mNuRS9N1NN9VaabtXdACCvVUorqjG3nN5rX6P3cm6Y9zQyrvDq+lbf87nM7Ehaq6DFwpQVqVBsLey2at5NyZOX2fDxMZuMbEhl6HRCuxPLQAA9I8PNGyXyyTcVDMiSl/021K5JZU4kalbRuGGdkGtOtbVYgJ1H6gX8viBStRc+tFQN7Rv+UK0tbHezf4xsSGXcSKzCCWV1fBRKdCljfGM1APb65KQvefyW/Ue+m6orm18DV1d5qLv27/AFhuiZttVq2vYHNoysbF7TGzIZej72fvGBUB+1Z1b/3hdYnM8oxCF5eoWv4ehvsbM3VBAra4o1tgQNUthmRpHL14G0LqFaGvTd0Wl5ZdBrWl9TR6ZHxMbchlHaj7g6psJONzPHXFBntAKYH9qy1ptak8C1pK1aJoSE8QWGyJT/H02F1oBtA/1Rrifu1mOGe7rDnc3Gaq1AhcLys1yTDIvJjbkMpIydLUv3SLrXxh1QFtdq42+ZcdUqXllyCisgFIuw3VxgU2/wESxNV1RWUUVqFBrzH58IlsoqazGMz8fxi3v78Kyv1KaNXFrc5m7GwoAZDLJMP0ClzixT0xsyCWUV2lwNkf3IdQtwq/effrVJCP/tjCx0c+V0Sc2AB7Klk8C1pBALyW8VQoIAVwsYKsNOYenfkzEj/sv4nhGEV75LQkr96WZ7djmWEahPlcKiHkd2iMmNuQSTmYVQSuAYG+lYT6Yq11XM1LqWHohyqqqTX6P3RasrwF0y4tEs4CYnMg/5/Lwx/FLUMgk3HJNGwDAm5tOorii5XVuehfyynAhvwwKmYT+bc07QvFKYsMWG3vExIZcwvGabqiuEX4NTpoXFeCBcF93VGsFEtMum3R8jVbg77M189dYoL5GT98dxQJicgbf/nMBADC5bzTem9ILbUO8UFCmxq8H01t97F3JuhbUa2MC4K0y77KILOS3b0xsyCUk1cwt0y2i/voaQNci0q+m1WZfSoFJxz9y8TKKK6rh465Aj8j6u7rMgR+o5CxKKquxJUk3E/jd10VDIZfh/gGxAIAf/r3Q6uPru6Es0YJqmFOKLad2iYkNuQT9pHld2zSc2ABAvzjdiKl9Jo6M0g/zHtguqM5QcnPiyChyFjtP56BCrUXbYC/DzcCE3pFwk0s4mVVsqIlridotqJaceiG9oBzVHPJtd5jYkNMTQiD5ku5DsmNY41Oq6wuID14oMOkDa8cp/SJ75pkroyGxNXeK5zn7MDk4/c3AkI4hhu5hf0+lYXTi1hOXWnzso+m6+ah83BW4xgItqOG+7lAqdEO+My5zlW97w8SGnF5OcSWKK6shk4C44MZX2+4U5gNfdwXKqjSG7qumFJapcfCCrutqeM3SDJaiv1NMKyiHVmu+YbFE1tZQTZp+eZM/T2S3+Nj6EYoD2wVBITf/nzmZTEJ0gAcA4Hw+bzLsDRMbcnrJ2brWmtggL6gUjQ/Dlskk9DVx2PfOMznQCqBjmDci/T1aF2wT2vi5QyGTUFWtxaVi3imSY8osLEdKbilkEtC/rfGcT/oFag+cL0BppemjEwFgp6G+xnItqLFB+tZTdgvbGyY25PSSa/rq24V4NWv/vibW2ei7oYZ3smxrDQAo5DJE6u8U+YFKDupwzajDTuG+8HV3M3ouOtATUQEe0GiFybVuAFBaWY1DNS2ogy05QtFQyM8WG3vDxIacnr7Fpl2od7P2188avD+1oMlZULVagYTTuibzoZ0sW1+jZ1gMk4kNOagjFwsBAD2j6q9/ub5tyxel3XsuD2qNQHSghyH5sAROvWC/mNiQ09MnNu1DmpfY9Ijyg1IhQ15pFc41sYLv8Ywi5JZUwVulQN9Y8y+jUB/DnSL79slBHU3XJTY9Gkhs9AXEe87lmXzsXYbZhkManLPKHPRdURyhaH+Y2JDTMyQ2zWyxUSnk6BXtDwDY10SdzR/HdfNwDO4QDKXCOpfTlZFR/EAlxyOEMCQ210T617vPgHa6xOZYeqHJsxDvrCkcHmKhGcD1ak+9YM71raj1mNiQUyuqUCO7uBJA87uigNrz2TQ8UZ8QAhuPZQIAxnQPb0WUptF/oKbxTpEc0MWCclwuU8NNLqFjeP3XZKS/B2ICPaHRCuxv5Bqse+wynMsphVwm4fp2lk1sogI8IElAWZUGOSWVFn0vMg0TG3Jq+taaUB9VnSLFxujns2msePFMdgnO5ZRCqZDhRgsP865NX2NznokNOaBjNa01ncJ9Gh2leH0LuqP0sw33ivaHn0fzr/eWUCnkiPDTFfKz3s2+MLEhp2ZqN5Ren9gAyCRdM/OlovqHVW84omutGdIhGD4mJE2tpU9sLpepUVje+sUCiazpTM012Sms8VnAr6/pjvr7bG6zj73LQqt5NySGBcR2iYkNObWzLUxsfNzd0KVm+YV/6qmz0WoFVh/SLdR3c482rYzSNF4qBYK9dSuU806RHI0+sekQ1vg1qU9sjmcUobCs6QRerdFi1xn9DODWSWyuFPLzOrQnTGzIqelHNbVr5oio2gbWfLBurikQrm3vuTxcyC+Dj0qBsd2tm9gAHBlFjuvMpWIAugktGxPm6462IV4QAvgnpenuqH2p+SiqqEaglxK9ogPMEmtTDCOjOJeNXWFiQ05NP3lWXHDzJuerbVzPCADAnycuoeSqGVC/q1l9eFyvCHgoG5/N2BI4hwY5omqNFudydNdkh9DG120DTKuz+TNJN5/UjZ1DLboQbW1ssbFPTGzIaWm1wvCHP64FE3X1iPRD22AvVKi1WH84w7D9XE4JNh7V1dfc2z/WPMGayDDUlIkNOZAL+WWo0mjh7iZr1vIj+u6oPWcbT2yEENhyQteyOqJmSQZr4GSZ9omJDTmtrKIKVFZroZBJLVrDSZIk3HVdNADgs53nDKt9v7npFITQLdbXNaLxAkhLYVcUOaIztWreZM1oVdFP1Hcyqxh5jQypPpNdgrT8cigVMgzpaJ36GuDKdZhXWlWnVZdsh4kNOa3Umm6o6EDPFq/wO7V/LAI83ZCSW4o3fj+JL3adw6bjWZDLJMwb3cmc4ZokJlDft887RXIchvqaZnRDAUCwt8pQi1NfEb+efoTioPbB8FQqWhll8/m4uyHQSwmAa0bZEyY25LT03VCtWS/GS6XAy7d1AwB8sTsFr204AQB44qYOhlFTtqA/p8yiClRWa2wWB5EpDC02TRQO1zawZqK9Haey631eCIG1iboRirfV1MVZE4d82x8mNuS0UmtGRMUFmV44XNv4XpF4dUJ3BHi6wcddgXmjOuLxG9ubI8QWC/JSwksphxBAWn65TWMhaq4zl2qGejezxQYARnXV1cxsSbpk6A6uLTHtMlLzyuDhJsfIrtarr9G7sso3Ext7Yb02OyIr03dFtaRw+Gr3DYjFfQNiIYSw6MJ6zSVJEmKCvHAiswgX8ktNnqeHyNq0WoFzuabPK3VdfCACPN1QUKbGvyn5GNjeuIbmpwMXAQCjuoXBS2X9P2n6EYoXWO9mN9hiQ07L0BXVgqHeDbGHpEaPQ77JkVwqrkCFWlfMHx3Q/GJ+hVyGUV11a7GtqzU6EQAul1Xh14O6xGZKv2jzBWuCmCAuSmtvmNiQU9JqhaHFJr6VXVH2ik3g5EhScltezH97nygAwJrEdFwuqzJs/2bPeVSotejSxtcw5421xfE6tDtMbMgpZRdXokKthVwmIdKEu0NHYpjLhpODkQNIzW35nFL94gLQtY0vKtRafLErBQCQXVSBTxPOAgD+M7StzVpT9ddhZmE5qqrr1gCR9TGxIaekb62JCvCAWwuHetu72EB9Ezj79sn+pdTU17RkFnBJkjD7Jl3B/mc7z2LNoXQ8+v1BlFZp0DPKD+Ousf5oKL0QbxU8lXJoBXCxgDcZ9sA5P/HJ5ZlrRJQ903dFpRWUQ6sVNo6GqHEpNS028S2seRvdLRxjuoVDrRF4clUi9qUWwFulwJIpvZo12Z+lSJJ0Zcg3W0/tAhMbckqprVhKwVG08XOHQiahqlqLrKIKW4dD1KgroxRblthIkoT/3dULU/vHINhbib6xAVj58IAWLXBrblxawb5wuDc5JX33TKwTt9go5DJEBnjgfF4ZzueVIaIFy0YQWYNGKwx/9FvaYgMA7m5yvD6xB16f2MNcoZmFvvU0ld3CdoEtNuSUUs3wIeoIYjiHBjmAjMvlqNJooZTLnDIBj+WQb7vCxIacjhCiVouN83ZFARzyTY7hyrptHpDbsB7GUvQ3UGyxsQ9MbMjp5JRUoqxKA5kERAU4eWKjXwyTRYtkx/TF/M7agqof6ZWWX1bvsg9kXUxsyOno105q4+cBpcK5f8U5lw05ghTDHDbOmdi08XWHUiGDWiOQcZmF/Lbm3J/65JL0c0lEOenEfLWxK4ocgWEW8BDnTGxkMsmwxEkKu6NsjokNOZ2LBboWG2fvhgKuFA8XlqtRWKa2cTRE9TN0RTlpiw1wpTuKE2baHhMbcjppNd0y0YHO32LjqVQgxEcFADjPkVFkh6o1WkNXaUtmHXYU+voh/ZpYZDtMbMjppNV0RUW7QIsNwFW+yb6lXy5HtVZApZAh3Nfd1uFYjL5+KJWJjc0xsSGnoy8ejg50jcSGBcRkz/TXY0ygp02XPrC0OMMkfbwObY2JDTkVjVYg47K+xsb5u6IALoZJ9i3NRYr5OeTbfjCxIaeSVVSBaq2Am1xCmBM3e9fGkVFkz/SjFJ29BTXc1x0qhQzVWoH0mpsrsg2bJjY7d+7EuHHjEBERAUmSsGbNGqPnL126hOnTpyMiIgKenp4YM2YMzpw5Y5tgySHoC4cj/Z1zhtP6sCuK7Jm+K8rZW2xkMslQZ8MCYtuyaWJTWlqKnj174sMPP6zznBACEyZMwLlz57B27VocOnQIsbGxGDFiBEpL+UtD9bsyIsq57w5r0xcPZxVVoEKtsXE0RMYuulAxv2ExTCY2NmXT1b3Hjh2LsWPH1vvcmTNnsHfvXhw7dgzdunUDAHz88ccIDQ3FDz/8gJkzZ1ozVHIQV+awce67w9oCvZTwUSlQXFmNC/ll6BjmY+uQiAzSXGheqStrRrH11JbstsamsrISAODufqVOQi6XQ6lUYvfu3Y2+rqioyOhBruNKoaLzf4jqSZKEtjUzup7LKbFxNERXVKg1yCnWfZa7wrxScVwM0y7YbWLTuXNnxMbGYsGCBSgoKEBVVRXeeOMNZGVlITMzs8HXLV68GH5+foZHdHS0FaMmW7voYkO99dqGeAMAzubwA5Xsh74F1VulgJ+Hm42jsTzOZWMf7DaxcXNzwy+//ILTp08jMDAQnp6e2LFjB8aOHQu5XN7g6xYsWIDCwkLDIy0tzYpRk61dmZzP+e8Oa2sbrG+x4Qcq2Y/a67ZJkvMX88cF626o0grKoeaQb5uxaY1NU/r06YPExEQUFhaiqqoKISEh6N+/P/r27dvga1QqFVQqlRWjJHtRVa1FVpFuZV1X6ooCriwueC6XXVFkP1ypvgYAwnzc4e4mQ4Vai/SCcqdeQsKe2W2LTW1+fn4ICQnBmTNnsH//fowfP97WIZEdyrhcDiEADzc5gr2Vtg7HqtoG67qizuWUQghh42iIdC660LptwFVDvllnYzM2bbEpKSlBcnKy4euUlBQkJiYiMDAQMTEx+OmnnxASEoKYmBgcPXoUTzzxBCZMmIBRo0bZMGqyV2ku1uxdm340RmG5GgVlagR6uVZiR/bpoou12AC6OpuTWcW6OptOto7GNdk0sdm/fz+GDx9u+Hru3LkAgGnTpmH58uXIzMzE3LlzcenSJbRp0wb3338/XnjhBVuFS3bO1daIqs1DKUekvwfSL5fjXE4JAr0CbR0SkUvWvMVxlW+bs2liM2zYsEabzWfPno3Zs2dbMSJyZBddZE2ahrQN8apJbErRN46JDdmeK7bYtKupd0vOZr2brdh18TC1zPm8UhzPKEJVtRZRAR7oEeUHlaLhkWTOQl+o6AoznNanbbAXdp3JxVkWEJMdKK2sRn5pFQAgykVqbACgfah+6gVeh7bCxMaJHEsvxMLfkvBvar7Rdh+VAvf0j8HMwW0R4uO8I8bSXKxQ8Wr6uWw45Jvsgb61xs/DDb7uzj+HjV67msTmUlEliirULnXu9sIhRkVR0349eBETPvoL/6bmQy6T0CvaHwPbBSHIS4niymp8tvMcRr6bgHWHM2wdqsVcdMFZh2vj7MNkT1z1RsPX3Q2hNTeQZ9kdZRNssXECvx/NxNwfDwMARncLwyu3dUe4n24pCq1WYMfpbLz9x2kkZRZh9g+HkJRRhGdGd4LMiVa/Lq/SILdE1+ztsl1RNS02F/LLUK3RQiHnfQvZjuFGw9/1rsf2od7ILq7E2ZxS9I4JsHU4LoeffA4uNbfUkNTcOyAGn0ztY0hqAN28Cjd2DsPax27Ao8PbAQA+TTiL59cec6r5TvQfoj7uCvh5umbTbxtf3eRgao0wdAMQ2Yqh5s3FWmwAoF3NTQYLiG2DiY0DE0Lg+TXHUK7WYEDbQLw8rluDrTBuchmeHt0Zb91xDSQJ+P6fC3jj95NWjthyrgwrdb27Q73ak4NxBmKyNf3NhitOv6AvIGZiYxtMbBzYlqRL2J2cC6VChjcmXdOsrofJfaOxeGIPAMBnO89h5b8XLB2mVejnsHHVod567VhATHbCla9JjoyyLSY2DkoIgQ+26WZtnjko3qQ1Se66LgZPjewIAHhx7XEculBgkRityZXvDmvjHBpkLy66cCuqPrG5kF+GymqNjaNxPUxsHNSuM7k4ml4IDzc5Zg5ua/LrHx3eHqO7haFKo8XslYdQUlltgSitxzDrsAveHdbWIcwHAHD6UrGNIyFXVliuRlGF7jMl0gWvyVAfFbxVCmi0AufzymwdjsthYuOgvvvnPABgSr/oFq0LJJNJeHtyT0T6eyAtvxyvrU8yd4hWlebiQ731OoXrEpszl0qcqjicHIt+qHewtxKeStcbfCtJkmE+G7aeWh8TGweUU1yJrSeyAQB3XxfT4uP4uLvhnTt7QpKAlfvSsP1UtrlCtLqLBa67TlRtcUFeUMgkFFdWI7OwwtbhkIvSX4+RLnyj0b6m3o1z2VgfExsHtDYxHdVagZ7R/oY79JYa0DYID94QDwB4ce0xlFc5Xn9wUYUaheVqAK5ZqFibUiEzrPR9it1RZCMXXXDxy6u1C62pd2MBsdUxsXFAG49mAgDuuDbSLMebM7IjIvzckZZfjo+2J5vlmNZ0saa+JtBLCS+V6zV7X62joTuKiQ3Zhisufnk1fYvNmUtMbKyNiY2DyS6uwKG0ywCAkV3DzXJML5UCL47rBgD4bOdZpOQ61lBhV1/V+2odQ3WJzaksfqCSbbjqcgq16VvTk3NKUK3R2jga18LExsFsPZENIYBrovyMZhhurdHdwjCsUwjUGoG3/nCsifuu3B267odobZ3Ca+4Us9liQ7bBFhvdMHdPpRxV1Vqk5jnWzaKjY2LjYP5MugQAGNklzKzHlSQJC8Z2gUwCNh7NwkEHmtuGsw4b0w/5PnOpBFotR0aRdQkhal2TrnuzIZNJ6FhzLZ7M4k2GNTGxcSBqjRZ7zuUBAG7sEmr243cK98EdfaIAAIs3nnCY4cJssTEWG+gJpUKGcrWGa0aR1RWUqVFWMwghwt+1r8kubWoSm0wmNtbExMaBHLlYiLIqDQI83dAl3Nci7zFnZEe4u8mwL7UAf55wjOHfbPY2ppDLDEsrcGQUWZu+vibMVwV3N7mNo7GtTmyxsQkmNg5kb01rTf/4oAYXu2ytNn4emFEz/PvdLacdotXmynIKrn13WFunMF1iwxmIydp4o3FF5za6G9CTWUU2jsS1MLFxIPrEZkDbQIu+z8OD28JLKUdSZhG21NT02KvCMjWK9VO3+/ODVE8/5PtEJj9QybpYX3NF55rr8GJBOYor1DaOxnUwsXEQao0W+1N1Bb3Xtwu26HsFeCkxbWAcAOC9rWfsutVG/yEa7K2Eh9K1m71r6xbhBwBIymBiQ9Z1kcubGPh7KhHuqxu9ytZT62Fi4yBOXypGuVoDH3cFOtSsQWJJMwe3hadSjuMZRXZda8Op2+vXLULXBJ6SV4pSB1/glByLYUFadg0DuDKfDetsrIeJjYM4nFYIQDd/jaXqa2oLNGq1sd9aG07dXr9gbxXCfFUQgv37ZF1ssTHWmSOjrI6JjYM4cvEyAOCaKH+rvedDg9vCw02OY+lF2J2ca7X3NQULFRum7446zu4oshIhxJUFaXlNArhSZ8MbDOthYuMgDl/Utdj0tGJiE+ilxJR+0QCAT3actdr7moLLKTRM3x11PJ0fqGQdOcWVqKzWQiYBbfzNNzO6I+tSMzLqRGYxJ8y0EiY2DqC8SmMoPOsZ7WfV9545OB5ymYS/z+YZWo3syZX+fN4dXs2Q2GQW2jgSchVpNa01bfw84CbnnxdAtximu5sMJZXVSOHSClbB3zwHcDyjEBqtQIiPylBhby1RAZ64rWcEAODTBPtqtdE1e7PFpiH6rqjTWSVQcxE+sgJej3Up5DJDq82xdN5kWAMTGwdwoqaavnuELyTJ8oXDV5s1tC0A4PdjWXa18vflMjVKa6Zuj3TxqdvrExXgAV93Bao0Wpy5xJW+yfJY81a/ayJ1NxlHLzKxsQYmNg7gVE3RWScLLaPQlM7hvrixcyiEAD7fec4mMdRHP4dNqA+nbq+PJEnoqu+OyuAHKlmefjkFDvU21r0msTnCFhurYGLjAE5n6e62O4Vbfv6ahvxnaDsAwC8HLiK7qMJmcdTGxS+b1r2mO+ooP1DJCthiUz/9aNbj6YUsILYCJjZ2TghhWMiwU5htWmwAoF9cAPrEBqBKo8Wyv1NtFkdtnC+jaT2j/QEAiWmXbRoHuQYup1C/diFecHeTobRKg3N21J3vrJjY2Lns4koUlqshl0loG+JlszgkScKsIbpam2/3nreLdU84w2nTetUkNkkZRahQa2wbDDk1jVYg43JNiw1HKRpRyGXoygJiq2lRYrNr1y7ce++9uP7665Geng4A+Oabb7B7926zBkfAqZrC4bggT5vXkYzoEoa2IV4orqjGyn/TbBoLwBab5ogK8ECwtwrVWsE6G7KoS0UVUGsEFDLJ6qM3HYG+O+oIC4gtzuTE5pdffsHo0aPh4eGBQ4cOobKyEgBQXFyMRYsWmT1AV6efv0a/3ogtyWRXWm2+3J2CqmrbDiFOY41NkyRJMrTaHLpw2aaxkHPTFw5H+HtAboVlXxyNoYDYDucDczYmJzavvfYaPv30UyxduhRubm6G7QMHDsTBgwfNGhxdabHpEGr7xAYAJvSORKiPCllFFVh3OMNmcWi1AhdqPkhjA23XRecIesf4A2CdDVmWYSkFdg3XS38dHk0vtPlNobMzObE5deoUhgwZUme7r68vLl++bI6YqBZ9oVl7K6zo3RwqhRwPDIoHAHy+86zNKvyziipQVa2FQiYhglO3N6o3W2zICq4UDrNruD5tg70Q4OmGymotu4UtzOTEpk2bNkhOTq6zfffu3Wjbtq1ZgqIrUmsSm/hg+2mVuKd/DLxVCpy+VIIdp7NtEsP5vCsznCo4dXujekT5QZKA9MvlyC62j6H65Hy4vEnjJElCn9gAAMCB8wU2jsa5mfwXYdasWXjiiSfwzz//QJIkZGRk4LvvvsO8efPwyCOPWCJGl1VUoUZeaRUAIM6OEhtfdzdM7R8DAPg0wTYT9l3I1yV8MUH2832xVz7ubuhQ0+LHVhuylDQup9Cka5nYWIXJic0zzzyDCRMmYPjw4SgpKcGQIUMwc+ZMzJo1C4899pglYnRZ+taaYG8VvFUKG0djbMYN8XCTS/g3JR8HL1j/Ik3N09fX8O6wOfrGBQIA/k3Jt3Ek5Kwu5nOUYlP6xuquw/3nCyAEJ+qzFJMSG41Gg4SEBDz11FPIzc3Fv//+i7179yInJwevvvqqpWJ0WSmGbij7+6AI93PHhF6RAIDPbLA45gV9YhNkf98be9Q/XveB+k9Kno0jIWdUVa1FZs2M5Cwebtg1UX5wk0vIKa40FFuT+ZmU2MjlcowePRqFhYXw9PRE3759cd1118Hb2z4KW51Naq7uj3ecnXa3PFwz9Htz0iWczbHuIovna7qiYu30e2NvBrQNAqCbqK/IDiZXJOeScbkcQgDubjKEeKtsHY7dcneTo1vNMifsjrIck7uievTogXPn7GchRGeWmqf7421P9TW1dQjzwYguusUxv9hlvd8JIQTO57LFxhRhvu6IC/KEVgD7U9kdReaVVmuyTEniHDaN0RcQ7+N1aDEmJzavv/465s2bh/Xr1yMzMxNFRUVGDzIf/VDvtnaa2ADALMPimOlWG3FTUKZGcWU1ACCGNTbN1j9e12rzzzl+oJJ5GeawYeFwk/TdwnvOslvYUkxObMaMGYPDhw/jtttuQ1RUFAICAhAQEAB/f38EBARYIkaXpS8ettcWGwDoGxuAa2P8UaXRYvlfqVZ5z/M1LVnhvu42X2bCkfRvq/tA3csCYjIz/azDHOrdtP5tgyCTdDeumYWss7EEk4fabN++3RJx0FUul1WhsFxXC2HP3S2SJOE/Q9vh4W8O4Ju95/F/w9rBx92t6Re2gn7G4Rg7/r7Yo/41dTbH0gtRXKG2+M+JXAeXN2k+Pw839Ij0w+GLhfgrOQ939ImydUhOx+TEZujQoZaIg66ib9oN9lbBU2lfQ72vNqJLGNqFeOFsTilW/J2Kx27sYNH30xdVc6i3aSL9PRAX5InUvDLsOZuHUd3CbR0SOQlDiw2HejfLwPbBOHyxEH+fzWViYwEm/8XcuXNno8/Xt9wCmU6/cnWkA9wByWQSZt/UAU+sTMTnO8/hvuvj4OdhudaAlFzdCCx77qKzV0M7hiB1z3kknM5hYkNmo/+8YldU89zQLhif7DiLv5PzIIRgwbWZmZzYDBs2rM622j8UjUbTqoBI56KDNe3eek0EPtyWjDPZJfhydwrmjuxosfdKrhlabi/rZzmSoZ1CsKImseEHKplDWVU1ckt0M6SzxaZ5+sYFQKmQIauoAudyS9EuhJ9l5mRy8XBBQYHRIzs7G5s2bUK/fv2wefNmS8ToktIv1yQ2/o6R2MhlEubUJDNf7U7B5bIqi7yPVitwNltXPMwPA9MNaBsEpVyGiwXlhlF3RK2hvwnzcVfAz5N1W83h7iZHnxjdYJtdp3NsHI3zMTmx8fPzM3oEBwdj5MiRePPNN/HMM89YIkaX5GgtNgAwpls4Oof7oKSyGp/vtMy8NllFFShXa6CQSXZdVG2vPJUKXFcz3DThFD9QqfVYX9MyQzuFAAC28To0O7MtixwSEoJTp06Z63AuL70msXGEGhs9mUwydEEt/zsVeSWVZn8P/QzHsUGecOOq3i0ytKPuAzWBd4pkBoY5bLiUgklGdAkFAOw9m4eSmnm5yDxM/stw5MgRo8fhw4exadMm/N///R969uxp0rF27tyJcePGISIiApIkYc2aNUbPl5SU4LHHHkNUVBQ8PDzQpUsXfPLJJ6aG7JD0XVGR/o51FzSyaxh6RPqhrEqDT3aYfw2ps9m6xIbdUC03vLMusdlzNg/FXF6BWimNi1+2SLsQb8QGeaJKo8XuM7m2DsepmJzY9OrVC71790avXr0M/7/55ptRVVWFL7/80qRjlZaWomfPnvjwww/rfX7OnDnYtGkTvv32W5w4cQJz5szB448/jrVr15oatkMprlAb5rBxpBYbQFdI/tQoXavN13vOGybTMxd94XA7Fg63WPtQH7QL8UKVRottJ7NtHQ45uNQ8/Zp2TGxMIUkSbuysa7XZeuKSjaNxLiYnNikpKTh37hxSUlKQkpKC8+fPo6ysDH///Tc6d+5s0rHGjh2L1157DZMmTar3+T179mDatGkYNmwY4uLi8PDDD6Nnz57Yv3+/qWE7FH1rjb+nG7xV9j2HTX2GdgzB4A7BqNJo8cbvJ816bBYOm8fY7m0AAJuOZdk4EnJ0+jXtuCCt6UZ0CQMAbD+VDa1W2Dga52FyYpOQkIDw8HDExsYiNjYW0dHRcHd3R1VVFb7++muzBjdo0CCsW7cO6enpEEJg+/btOH36NEaPHt3gayorKx1+/SpDfY2DjIi6miRJeP6WrpBJwO/HsvDPOfOtiWJosQnhh2hrjOmum8Nmx6kclFdxigZqGY1W4EJNi00855UyWb+4QPioFMgtqcKBC1zt21xMTmxmzJiBwsLCOtuLi4sxY8YMswSl9/7776Nr166IioqCUqnEmDFj8PHHH2PQoEENvmbx4sVGo7aio6PNGpM1OOKIqKt1CvfBXdfFAABe23DCLHcjuSWVyCmuhCTpVhanlusW4YuoAA+UqzVIOM3uKGqZrKIKVGm0cJNLaOPnbutwHI5SIcPIrrpWm/WHM2wcjfMwObFpaFKvixcvws/PzyxB6b3//vvYu3cv1q1bhwMHDuCdd97BI488gj///LPB1yxYsACFhYWGR1pamlljsgZHLRy+2tyRHeGjUuBoeiFW7mv9z+FEpq71LTbQ0yG76OyJJEkYW9Nqs/5Ipo2jIUelX6g3OtATCo5SbJFxvSIAABuOZqJao7VxNM6h2X8devfuDUmSIEkSbrrpJigUV16q0WiQkpKCMWPGmC2w8vJyPPvss1i9ejVuueUWAMA111yDxMREvP322xgxYkS9r1OpVFCpVGaLwxYyahKbCH/HvgMK9lbhyZEd8er6JCz+/QRGdAlFqG/Lz0mf2HSN8DVXiC5tfK9ILN2Vgs1Jl1BYrrboMhjknPT1NXGsr2mxQe2D4e/phtySKvyTko8b2gfbOiSH1+zEZsKECQCAxMREjB49Gt7eV4o3lUol4uLicPvtt5stMLVaDbVaDZnM+C5ALpdDq3XurPZSUQUAINwJmnanD4zD2sR0HLlYiFfWJ+Gje65t8bGSMnSJTZdwJjbm0C3CF53DfXAyqxjrj2Rgav9YW4dEDkbfYsPJMlvOTS7D2O5t8MO/F/Db4QwmNmbQ7MTmpZdeAgDExcVhypQpcHdv/R/dkpISJCcnG75OSUlBYmIiAgMDERMTg6FDh+Lpp5+Gh4cHYmNjkZCQgK+//hpLlixp9Xvbsyx9YtOK1g17IZdJWDSxB8Z/9Bc2HMnE7ddewo2dw1p0rBOZxQDYYmMukiThjj5ReG3DCfx84CITGzJZKguHzWJcT11is+FoJl4a1w0eSrmtQ3JoJneKTps2zSxJDQDs378fvXv3Ru/evQEAc+fORe/evfHiiy8CAFauXIl+/fph6tSp6Nq1K9544w28/vrr+M9//mOW97dHQghcKtLN2BvmBIkNAHSP9MODg+IBAPN/OYqCUtPXkapQawwjorq0YWJjLuN7RUIuk3DowmUkZxfbOhxyMOc51NssBsQHITrQA8UV1dh4lDVvrWVyYqPRaPD222/juuuuQ3h4OAIDA40ephg2bBiEEHUey5cvBwCEh4dj2bJlSE9PR3l5OU6ePIm5c+c69YrEBWVqVFXrutpCfR27Vqi2OSM6on2oN7KLKzH/1yMQwrRRUkfTC6HRCoT4qDj6woxCfFQYXrNmzXf/XLBxNORItFqB8/oWGyY2rSKTSbirn24U6Q//8jpsLZMTm1deeQVLlizBnXfeicLCQsydOxeTJk2CTCbDyy+/bIEQXUtWoa4bKtBLCZXCeZojPZRy/G9KL7jJJfxx/BJWmThK6sB53RwP18b4O3Viawv3XR8HAPhp/0UusUDNllVUgcpqLRQyyeEHOtiDyX2iIJdJ2H++AKcvsfW0NUxObL777jssXboU8+bNg0KhwN13340vvvgCL774Ivbu3WuJGF3KpWJdYuMs3VC1dY/0w7xRnQAAL/923FAM3BwHaxKbPrEBFonNlQ3pEIx2IV4oqazGT/sv2jocchDncnTdUDFBHOptDqG+7oaFMb/de97G0Tg2k38bs7Ky0KNHDwCAt7e3YbK+W2+9FRs2bDBvdC7oUqG+cNh5uqFqe2hwWwzuEIwKtRYPf7O/WfU2QggcvKBvsWFiY26SJGHGDboaqBV7UqHh1O7UDGdqarI6cN02s7m/pvX0x/1pyG9BLSLpmJzYREVFITNTV9zUvn17bN68GQCwb98+h58/xh5kOdFQ7/rIZBI+uLs3YgI9cbGgHI/9cLDJSalOZhUjt6QKHm5ydI807ySQpDPp2kj4ebjhfF4Z1h/hDKjUtDPZumL+9kxszGZguyB0j/RFhVqLb/aw1aalTE5sJk6ciK1btwIAnnjiCbzwwgvo0KED7r//fjzwwANmD9DV6OewccauKD1/TyU+v78PPNzk+Cs5D8+vOdZoMXHC6RwAwPXtguDu5jx1R/bEU6kwjFx7f+sZttpQk5JrEpsOoVzexFwkScKsIe0A6FpPuY5by5g8L/0bb7xh+P8dd9yB6Oho/PXXX2jfvj1uu+02swbnirIKnWcOm8Z0DvfF/+7qhf/79gBW7ktDsLcK80Z3qnffbSd1axkNqxm9Q5Yx44Y4fLk7BWdzSvHb4QxM6B1p65DIjiWzxcYixnYPR3SgB9Lyy/HN3lQ8XJPoUPOZ1GKjVqsxY8YMnDt3zrCtf//+mDt3LpMaM8nSz2HjpF1RtY3uFo7XJujqtT7cnoyPtifX2ediQRn+TcmHJAEjurRsYj9qHh93Nzw0WNdqs2TLaVRW826R6pdXUon80ipIEtAuhImNOSnkMjx+YwcAwEfbz6KwnCMVTWVSYuPm5obVq1dbKhZCra4oH+dPbADgnv4xeLqmpeatP07h3S2njbql9MPCr28bhAh/x13t3FFMvyEeoT4qXMgvw5e7U2wdDtkpfX1NVIAHZ8m1gNuvjUKHUG8UlqvxacJZW4fjcFpUY7NmzRoLhEKV1RpDJbyzFg/X59Hh7fH/xnQGALy39QyeXX0UVdVaZBdXYPlfqQCAewdwun9r8FYpMH+s7mfx4bZkQ9coUW1nWF9jUXKZhGdqPhO/2p2CCzUTIVLzmFxj0759e7z66qv4+++/0adPH3h5Gc84OXv2bLMF52qya7qhlAoZAjxda6Xl/xvWDu5uMixcn4Qf/k3DoQuXUaXRoriyGt0ifDGmW7itQ3QZE3pF4tu953HwwmU8v+Yolt7fl5MikpFTWbo5qDqEsRvKUkZ0CcXAdkH4+2wenl97DCtm9ON12EwmJzZffPEF/P39ceDAARw4cMDoOUmSmNi0wpURUSqX/AWecUM84oK9MPuHQziZpZsjI8hLiffu6g2ZzPW+H7Yik0lYNKkHbvvgL/x5Ihs/HbiIO/tG2zossiPH0nWJTbcITr9gKZIk4bUJ3THmf7uw83QO1h3OwPheLOhvDpMTm5QU9rtbSnaxrsUm1EXqa+ozvFMoEp4ejvVHMqDWCIzr2calvx+20jncF3NGdsR/N53Ewt+SMCA+CDFBnrYOi+yARitwsqbFpnsEF6S1pLYh3nh0eHu8++dpvLj2OPrFBbLWsBlaPA92VVUVTp06herqanPG49JyS3SJTYi3a090GOilxP3Xx+HBQfFMamzo4SFt0Tc2ACWV1Xj4m/0oq+K1TsC5nBJUqLXwUsoRx8UvLe7/hrXDNVF+KCxX44mVh5qc0JRakNiUlZXhwQcfhKenJ7p164YLF3Qrkc6ePdtojhsyXU5Ni02wj9LGkRDpChg/uKc3gr2VOJlVjHk/HebEfYRjGbpldLpG+LKL2AqUChk+uLs3vFUK7EstwOLfT9o6JLtncmKzYMECHD58GDt27IC7+5W76REjRmDVqlVmDc7VXGmxYSsF2Yc2fh74eGofKGQSNh7NwgtrG58lmpwf62usLzbIC2/ecQ0A4MvdKVjxd6ptA7JzJic2a9aswYcffohBgwYZFbh27doVZ89yvH1rsMWG7NF18YF4d0ovSBLw/T8XsHB9ErRsuXFZ+gVpr4liYmNNN/doY5jz65XfjmPNoXQbR2S/TE5scnJyEBoaWmd7aWmpS47kMaecEt0cNq5eY0P2Z1zPCCyaqJsletlfqZj7YyKqqtnX72rKqzQ4elHXFdUvLtDG0bieR4a1wz39Y6AVwJwfE/FjzQSmZMzkxKZfv37YsGGD4Wt9MrN06VJcf/315ovMBeUaWmyY2JD9ufu6GCy5sycUMglrEjNw1+d7kH653NZhkRUlpl1GtVYg3NcdUQEcnWNtkiThtfHdMbV/DIQAnvnlCN7ZfIotqFcxebj34sWLMWbMGCQlJaG6uhrvvfcejh8/jj179iAhIcESMboEIQRyOCqK7Nyka6MQ6KXE4z8cwsELl3Hze7uwaGIP3NwjnC22LmBfaj4AoG9cAH/eNiKT6ea38XF3w6cJZ/HBtmQczyjCf2+/BiG8KQbQghabgQMH4q+//kJZWRnatWuHzZs3IywsDHv27EGfPn0sEaNLKK6sNjTt85eT7NmwTqHYOHswetYMQX30+4OYtmwfUnJLbR0aWdjO0zkAgP5tg2wciWuTJAnzx3bGu1N6QqmQYdvJbIx6NwFrE9NZ3A9AEk7+XSgqKoKfnx8KCwvh62u/k0mdzSnBTe8kwFulwLFXRts6HKImVVVr8eG2M/g04RyqNFrIZRIm9o7EI8PaoS1XfHY6BaVV6PPaFmgF8Nf8GxHJieLsQlJGEZ766TBOZOpGq10b449nb+6Cvk5QA9XSv98md0UBgEajwerVq3HixAlIkoQuXbpg/PjxUChadDjClfoattaQo1AqZJg7qhMmXhuFhb8dx/ZTOfj5wEX8cvAihnQIwZR+0RjRJQxKRYvnASU7sv1UNrQC6Bzuw6TGjnSN8MXaR2/AJzvO4tOEszh44TLu+HQProsLxAOD4jCiSxgUcte6Bk3ORI4dO4bx48cjKysLnTrphp6dPn0aISEhWLduHXr06GH2IF2Bvr4m2JtDvcmxxAd7YdmM63DoQgE+2p6MP09kI+F0DhJO58BHpcDgjsEY3ikUwzqFMnF3YL8e1A0vHs0Fae2OUiHDEyM64K7rovG/P0/jp/0X8W9qPv5NzUewtxI392iDW6+JQO8Yf7i5QJJjclfUgAEDEBoaihUrViAgIAAAUFBQgOnTpyM7Oxt79uyxSKAt5ShdUcv/SsHLvyXh5h7h+Hgqa5XIcaXmluLH/Wn4+cBFw/pnem1DvNAzyh/XRPnhmig/dAzzgY+7a61k74hSc0sx/J0dEALY9cxwRAdy3TB7dqmoAt/sOY/v/72A/NIqw3ZvlQL94wNxfbsg9Ij0Q9cIX7u+/lr699vkxMbDwwP79+9Ht27djLYfO3YM/fr1Q3m5fQ3/dJTE5q0/TuKj7Wdx//WxWDi+u63DIWo1jVbgyMXL2H4yG9tP5eBoemG9+wV5KREb5Im4IC9EB3oi1FeFUB93hPioEOKjQpCXEiqFjKNwbOiJlYewNjEDwzuFYNmM62wdDjWTWqPFX8m5WHc4A9tPZqOgTF1nn/hgL7QL8UJskBdigzwRE+iJNn4eCPZWIsBTadNlM6xWY9OpUydcunSpTmKTnZ2N9u3bm3o4qpFbzMn5yLnIZRJ6xwSgd0wA5o7qhLySShxJL8SRtEIcTb+MIxcLkV1cibzSKuSVVuHghcuNHstLKYe3SgEvlQKeKgW8VXJ4KRWGbV76bSoFVAo5FHIJSrkMCrkEhUwGpUL375XtMihkEpQK3b9uchncavaXSxJkMglymf7/gFzSfe1KCZYQAj/uT8PaxAwAwNyRnWwcEZnCTS7DsJpuYK1WICmzCLuTc3HgfAGOpxcio7ACKbmlDY5olMskBHkpEeytgp+HG7zdFfBRKeDtrrvu9P+6u8nRtY0vukfax2zUJic2ixYtwuzZs/Hyyy9jwIABAIC9e/di4cKF+O9//4uioiLDvvbcQmJvDDU2rEEgJxXkrcLwTqEY3unKzOUlldU4n1eK83llSMktxcWCMuQUVyGnuAI5xZXIKamEWiOg0QoUVVSjqMI+VhiXSYBMknQP2ZX/SxIgQTfXiARc2SZd9TWuTG4qkwESdNuBK89J+i+u2nZlvyuvQe3XANAKASF0/+oetf6vNd4uhO77q99HCNR8LVCtFYaFT/8ztB16cBkFhyWTSege6WeUfOSWVOJEZhFSc3XX4Pn8MlzIK0N2cQUKytTQaAWyiyvrdCnX5/+GtXPcxObWW28FANx5552GC1PfmzVu3DjD15IkQaPRmCtOp5fLyfnIBXmrFOgW4dfggopCCJRUVqO0UlPzbzVKq3Rfl1ZWX9lWWY0S/bYq3ZxQ1Rot1BoBtUaLaq3uX7VG1Gyv+b+21j619m2KPgkABODkH3NKhQz/GdIWT47oaOtQyMyCvVUY3CEEgzuE1HlOrdEiv7TKcINRXFGNkopqlFSqUVJRjeJK3delVdUor9KgvR1N8WByYrN9+3ZLxOHycricAlEdkiTBx93NqgWOoqYlQ99qodEKaISAVttwy4e+dUSjFRA1x9BtAwR0+9b+Vwhc2Q+A7t5Q1Lw/DNuMn9e9FrWfh6gVt34fXYuSXNJ1m8kk3d26UStTTcuRrKZ7TVbTqiSrtU3/vJ+HG7xUnMrD1bjJZQjzdUeYr7utQzGZyb+tQ4cOtUQcLk0IcaXFhokNkU1JkgS5pKsvICLH06I0vKKiAkeOHEF2dja0WuMVfm+77TazBOZKCsvVUGt0t1tBXpzHhoiIqKVMTmw2bdqE+++/H7m5uXWeY11Ny+hba3zcddXlRERE1DImT0H42GOPYfLkycjMzIRWqzV6MKlpmdwS3VDvYBYOExERtYrJiU12djbmzp2LsLAwS8TjkvQzQwayG4qIiKhVTE5s7rjjDuzYscMCobiuPCY2REREZmFyjc2HH36IyZMnY9euXejRowfc3IyHYc6ePdtswbmK/JquKBYOExERtY7Jic3333+PP/74Ax4eHtixY4fR9OKSJDGxaYH8Ul3xMFtsiIiIWsfkxOb555/HwoULMX/+fMhkzr/8uTXk1yxMxsSGiIiodUzOTKqqqjBlyhQmNWakb7EJ8mZiQ0RE1BomZyfTpk3DqlWrLBGLy8or0RcPc7g3ERFRa5jcFaXRaPDmm2/ijz/+wDXXXFOneHjJkiVmC85VGIZ7e7LFhoiIqDVMTmyOHj2K3r17AwCOHTtm9FztQmJqHiEECspqEht2RREREbUKV/e2saKKaq4TRUREZCYtrgBOTk7GH3/8gfLycgC6lgcynb4bylMp5zpRRERErWRyYpOXl4ebbroJHTt2xM0334zMzEwAwMyZM/HUU0+ZPUBnx+UUiIiIzMfkxGbOnDlwc3PDhQsX4Onpadg+ZcoUbNq0yazBuQJ9YsNuKCIiotYzucZm8+bN+OOPPxAVFWW0vUOHDjh//rzZAnMVnHWYiIjIfExusSktLTVqqdHLzc2FSsV5WEylXwAzgIkNERFRq5mc2AwZMgRff/214WtJkqDVavHWW29h+PDhZg3OFXABTCIiIvMxuSvqrbfewrBhw7B//35UVVXhmWeewfHjx5Gfn4+//vrLEjE6tSvFw2ztIiIiai2TW2y8vb2RmJiI6667DiNHjkRpaSkmTZqEQ4cO1ZmFmJqWx+JhIiIiszE5sYmPj4dCocArr7yC9evXY+PGjXjttdegVCoRHx9v0rF27tyJcePGISIiApIkYc2aNUbPS5JU7+Ott94yNWy7ZZh1mIkNERFRq5mc2DQ0EV9JSQnc3d1NOlZpaSl69uyJDz/8sN7nMzMzjR5fffUVJEnC7bffbmrYdsuwACaXUyAiImq1ZtfYzJ07F4CuFeXFF180Ghml0Wjwzz//oFevXia9+dixYzF27NgGnw8PDzf6eu3atRg+fDjatm1r0vvYM85jQ0REZD7NTmwOHToEQNdic/ToUSiVV/4QK5VK9OzZE/PmzTN/hDUuXbqEDRs2YMWKFY3uV1lZicrKSsPXRUVFFouptcqrNChXawCwK4qIiMgcmp3Y6Be/nDFjBt577z34+vpaLKj6rFixAj4+Ppg0aVKj+y1evBivvPKKlaJqnbyayfnc5BK8VSYPUCMiIqKrmFxjs2zZMqsnNQDw1VdfYerUqU3W8SxYsACFhYWGR1pampUiNF3tdaIkSbJxNERERI7PIZoJdu3ahVOnTmHVqlVN7qtSqRxmBuQ8zmFDRERkVia32NjCl19+iT59+qBnz562DsWsClg4TEREZFY2bbEpKSlBcnKy4euUlBQkJiYiMDAQMTExAHTFvz/99BPeeecdW4VpMbW7ooiIiKj1bJrY7N+/32h9Kf2Q8mnTpmH58uUAgJUrV0IIgbvvvtsWIVpUHhMbIiIis7JpYjNs2LAGJ/zTe/jhh/Hwww9bKSLr4gKYRERE5uUQNTbOSt9iE8DEhoiIyCyY2NhQfs08NmyxISIiMg8mNjbE4mEiIiLzYmJjQ4Z1orgAJhERkVkwsbERtUaLoopqAJygj4iIyFyY2NiIfnI+mQT4e7jZOBoiIiLnwMTGRgwjojyVkMm4ThQREZE5MLGxkXwO9SYiIjI7JjY2whFRRERE5sfExkYKymoSG08mNkRERObCxMZGDC02HOpNRERkNkxsbMSQ2LDFhoiIyGyY2NgIi4eJiIjMj4mNjehrbLhOFBERkfkwsbGRvBK22BAREZkbExsb4agoIiIi82NiYwNCCBSUqgEAAV5cToGIiMhcmNjYQGmVBlUaLQAgiAtgEhERmQ0TGxvIr6mvcXeTwUMpt3E0REREzoOJjQ3ks76GiIjIIpjY2EABZx0mIiKyCCY2NpCnn5yPLTZERERmxcTGBgq4sjcREZFFMLGxAX2NDVtsiIiIzIuJjQ3oW2y4nAIREZF5MbGxgTwugElERGQRTGxsgDU2RERElsHExgYM89gwsSEiIjIrJjY2kM8WGyIiIotgYmNl1RotCstrFsDkqCgiIiKzYmJjZYXlagih+7+/J1f2JiIiMicmNlZWUFNf4+fhBjc5v/1ERETmxL+sVpZXwvoaIiIiS2FiY2UFhlmH2Q1FRERkbkxsrCy/VFc4HOilsnEkREREzoeJjZXll1YCAAK92GJDRERkbkxsrEzfYsPlFIiIiMyPiY2V6WtsAjmHDRERkdkxsbEyzjpMRERkOUxsrIyJDRERkeUwsbEyfWLDGhsiIiLzY2JjZfoamyAmNkRERGbHxMaKKtQalFVpALDFhoiIyBKY2FiRvhtKIZPgo1LYOBoiIiLnw8TGimrX10iSZONoiIiInA8TGytifQ0REZFlMbGxIkOLDSfnIyIisggmNlaUV8I5bIiIiCyJiY0V6Vtsgr2Z2BAREVkCExsryjOs7K2ycSRERETOiYmNFeXWdEUFscWGiIjIImya2OzcuRPjxo1DREQEJEnCmjVr6uxz4sQJ3HbbbfDz84OPjw8GDBiACxcuWD9YM8gr0bXYsCuKiIjIMmya2JSWlqJnz5748MMP633+7NmzGDRoEDp37owdO3bg8OHDeOGFF+Du7m7lSM0jr1TfYsOuKCIiIkuw6fS3Y8eOxdixYxt8/rnnnsPNN9+MN99807Ctbdu21gjNIvSjojiPDRERkWXYbY2NVqvFhg0b0LFjR4wePRqhoaHo379/vd1VtVVWVqKoqMjoYQ8q1BqUVFYDYIsNERGRpdhtYpOdnY2SkhK88cYbGDNmDDZv3oyJEydi0qRJSEhIaPB1ixcvhp+fn+ERHR1txagbpu+GcpNL8HXnOlFERESWYLeJjVarBQCMHz8ec+bMQa9evTB//nzceuut+PTTTxt83YIFC1BYWGh4pKWlWSvkRukLh4O8VFwnioiIyELstukgODgYCoUCXbt2NdrepUsX7N69u8HXqVQqqFT219WTx6HeREREFme3LTZKpRL9+vXDqVOnjLafPn0asbGxNoqq5TgiioiIyPJs2mJTUlKC5ORkw9cpKSlITExEYGAgYmJi8PTTT2PKlCkYMmQIhg8fjk2bNuG3337Djh07bBd0CxnmsOGIKCIiIouxaWKzf/9+DB8+3PD13LlzAQDTpk3D8uXLMXHiRHz66adYvHgxZs+ejU6dOuGXX37BoEGDbBVyi11psWFiQ0REZCk2TWyGDRsGIUSj+zzwwAN44IEHrBSR5eTqi4fZFUVERGQxdltj42w4OR8REZHlMbGxEv3K3sFssSEiIrIYJjZWwuHeRERElsfExgqEELUSG7bYEBERWQoTGysorqxGlUY3kzJrbIiIiCyHiY0V6FtrvJRyuLvJbRwNERGR82JiYwV5HOpNRERkFUxsrCCXhcNERERWwcTGCnJKONSbiIjIGpjYWEFOUQUAINSHiQ0REZElMbGxAn2LTaiPu40jISIicm5MbKwgu6gmsfFliw0REZElMbGxguxiXWITwhobIiIii2JiYwU5xWyxISIisgYmNham1QrkssaGiIjIKpjYWFh+WRWqtQKSxHlsiIiILI2JjYXpC4cDPZVwk/PbTUREZEn8S2th+qHeIZzDhoiIyOKY2FhYtn5yPl/W1xAREVkaExsL0w/15qzDRERElsfExsL0Q73ZFUVERGR5TGwsLIctNkRERFbDxMbCsov1C2CyxoaIiMjSmNhYWFZN8XAYZx0mIiKyOCY2FqTVCmQV6hKbNv4eNo6GiIjI+TGxsaC80iqoNbpZh1ljQ0REZHlMbCwos7AcgC6p4azDRERElse/thaUcbmmG8qP3VBERETWwMTGgvQtNhH+HBFFRERkDUxsLCizkC02RERE1sTExoIyLutabNr4scWGiIjIGpjYWFAWW2yIiIisiomNBRm6olhjQ0REZBVMbCykWqPFpZpZhyPYYkNERGQVTGwsJLOwAtVaAaVCxsn5iIiIrISJjYWczysDAEQHeEAmk2wcDRERkWtgYmMh5/NLAQCxQV42joSIiMh1MLGxkAs1LTYxgZ42joSIiMh1MLGxkPNMbIiIiKyOiY2FnM/XJTaxQUxsiIiIrIWJjQUIIZDGxIaIiMjqmNhYwKWiSpRUVkMmAVEBTGyIiIishYmNBZzJLgYAxAV5wd1NbuNoiIiIXAcTGws4fakEANAhzNvGkRAREbkWJjYWcOaSrsWmY5iPjSMhIiJyLUxsLOBUTWLTgYkNERGRVTGxMbOqai2SMooAAN0jfG0cDRERkWthYmNmJzKLUFmthZ+HG+KDuZwCERGRNTGxMbODFwoAAL1j/CFJXPySiIjImpjYmNmOUzkAgP7xQTaOhIiIyPUwsTGjkspq7DmXBwAY0SXUxtEQERG5HpsmNjt37sS4ceMQEREBSZKwZs0ao+enT58OSZKMHgMGDLBNsM2w+lA6qqq1aBfihfahnMOGiIjI2mya2JSWlqJnz5748MMPG9xnzJgxyMzMNDw2btxoxQibr6SyGp9sTwYA3DsglvU1RERENqCw5ZuPHTsWY8eObXQflUqF8PBwK0XUfGVV1cgvrUJJZTUuFVXig61nkFFYgagAD9zVL8bW4REREbkkmyY2zbFjxw6EhobC398fQ4cOxeuvv47Q0IbrVyorK1FZWWn4uqioyCJxfZZwDu9tPWO0zUspxwd394aHkutDERER2YJdJzZjx47F5MmTERsbi5SUFLzwwgu48cYbceDAAahUqnpfs3jxYrzyyisWj83HXQGlQgZfdwV8PdzQLzYQjwxvh9ggzl1DRERkK5IQQtg6CACQJAmrV6/GhAkTGtwnMzMTsbGxWLlyJSZNmlTvPvW12ERHR6OwsBC+vuabCVgIwToaIiIiCykqKoKfn5/Jf7/tusXmam3atEFsbCzOnDnT4D4qlarB1hxzYlJDRERkfxxqHpu8vDykpaWhTZs2tg6FiIiI7JBNW2xKSkqQnJxs+DolJQWJiYkIDAxEYGAgXn75Zdx+++1o06YNUlNT8eyzzyI4OBgTJ060YdRERERkr2ya2Ozfvx/Dhw83fD137lwAwLRp0/DJJ5/g6NGj+Prrr3H58mW0adMGw4cPx6pVq+Dj42OrkImIiMiO2U3xsKW0tPiIiIiIbKelf78dqsaGiIiIqDFMbIiIiMhpMLEhIiIip8HEhoiIiJwGExsiIiJyGkxsiIiIyGkwsSEiIiKnwcSGiIiInAYTGyIiInIaDrW6d0voJ1YuKiqycSRERETUXPq/26YukOD0iU1xcTEAIDo62saREBERkamKi4vh5+fX7P2dfq0orVaLjIwM+Pj4QJKkVh+vqKgI0dHRSEtLc9q1p5z9HJ39/ACeozNw9vMDeI7OwJLnJ4RAcXExIiIiIJM1v3LG6VtsZDIZoqKizH5cX19fp/wlrc3Zz9HZzw/gOToDZz8/gOfoDCx1fqa01OixeJiIiIicBhMbIiIichpMbEykUqnw0ksvQaVS2ToUi3H2c3T28wN4js7A2c8P4Dk6A3s8P6cvHiYiIiLXwRYbIiIichpMbIiIiMhpMLEhIiIip8HEhoiIiJyGUyY206dPhyRJ+M9//lPnuUceeQSSJGH69OkWjeGJJ55Anz59oFKp0KtXrzrPnzp1CsOHD0dYWBjc3d3Rtm1bPP/881Cr1a16348//hjx8fFwd3dHnz59sGvXLqPnT5w4gdtuuw1+fn7w8fHBgAEDcOHChUaPefToUQwdOhQeHh6IjIzEwoUL66zdkZCQgD59+hjO5dNPP23VeTRk586dGDduHCIiIiBJEtasWWN4Tq1W4//9v/+HHj16wMvLCxEREbj//vuRkZHR5HEd5RwBoKSkBI899hiioqLg4eGBLl264JNPPmnyuNY+R0e4DmtLTk6Gj48P/P39zfLevBYd+1p0lusQcIxrMTU1FZIk1Xls2rTJ9DcTTmjatGkiOjpa+Pn5ibKyMsP28vJy4e/vL2JiYsS0adMsGsPjjz8uPvzwQ3HfffeJnj171nn+7Nmz4quvvhKJiYkiNTVVrF27VoSGhooFCxa0+D1Xrlwp3NzcxNKlS0VSUpJ44oknhJeXlzh//rwQQojk5GQRGBgonn76aXHw4EFx9uxZsX79enHp0qUGj1lYWCjCwsLEXXfdJY4ePSp++eUX4ePjI95++23DPufOnROenp7iiSeeEElJSWLp0qXCzc1N/Pzzzy0+l4Zs3LhRPPfcc+KXX34RAMTq1asNz12+fFmMGDFCrFq1Spw8eVLs2bNH9O/fX/Tp06fRYzrSOQohxMyZM0W7du3E9u3bRUpKivjss8+EXC4Xa9assatzdITrUK+qqkr07dtXjB07Vvj5+bX6fXktOv616CzXoRCOcS2mpKQIAOLPP/8UmZmZhkdlZaXJ7+W0ic348eNFjx49xLfffmvY/t1334kePXqI8ePHG36Iv//+u7jhhhuEn5+fCAwMFLfccotITk42vGb48OHi0UcfNTp+bm6uUCqVYuvWrU3G8tJLLzX6gVrbnDlzxKBBg5q1b32uu+468Z///MdoW+fOncX8+fOFEEJMmTJF3HvvvSYd8+OPPxZ+fn6ioqLCsG3x4sUiIiJCaLVaIYQQzzzzjOjcubPR62bNmiUGDBjQktNotvo+bK7277//CgCGPyj1cbRz7Natm1i4cKHRtmuvvVY8//zzDR7HFufoSNfhM888I+69916xbNkysyQ2vBbrcuRr0ZGvQyEc41rUJzaHDh1q0TnW5pRdUXozZszAsmXLDF9/9dVXeOCBB4z2KS0txdy5c7Fv3z5s3boVMpkMEydOhFarBQDMnDkT33//PSorKw2v+e677xAREYHhw4ebLdbk5GRs2rQJQ4cObdHrq6qqcODAAYwaNcpo+6hRo/D3339Dq9Viw4YN6NixI0aPHo3Q0FD079+/TvPq9OnTMWzYMMPXe/bswdChQ40mXxo9ejQyMjKQmppq2Ofq9x09ejT279/f6q611iosLIQkSUbdC45+joMGDcK6deuQnp4OIQS2b9+O06dPY/To0YZ97Okc7f063LZtG3766Sd89NFHrTqOHq/F+jnbteho1yFg/9ciANx2220IDQ3FDTfcgJ9//rlFx3DqxOa+++7D7t27kZqaivPnz+Ovv/7Cvffea7TP7bffjkmTJqFDhw7o1asXvvzySxw9ehRJSUmG5yVJwtq1aw2vWbZsmaHPsrUGDhwId3d3dOjQAYMHD8bChQtbdJzc3FxoNBqEhYUZbQ8LC0NWVhays7NRUlKCN954A2PGjMHmzZsxceJETJo0CQkJCYb927Rpg5iYGMPXWVlZ9R5T/1xj+1RXVyM3N7dF52MOFRUVmD9/Pu655x6jxdkc/Rzff/99dO3aFVFRUVAqlRgzZgw+/vhjDBo0yLCPPZ2jPV+HeXl5mD59OpYvX262Bfx4LdbljNeio12HgH1fi97e3liyZAl+/vlnbNy4ETfddBOmTJmCb7/91uRjOfXq3sHBwbjllluwYsUKCCFwyy23IDg42Gifs2fP4oUXXsDevXuRm5tryEovXLiA7t27Q6VS4d5778VXX32FO++8E4mJiTh8+LDh7mrs2LGGosDY2FgcP37cpBhXrVqF4uJiHD58GE8//TTefvttPPPMMy0+56t/sYQQkCTJcF7jx4/HnDlzAAC9evXC33//jU8//dTQUrR48eJmHfPq7c3Zx5rUajXuuusuaLVafPzxx0bPOfo5vv/++9i7dy/WrVuH2NhY7Ny5E4888gjatGmDESNGALCvc7Tn6/Chhx7CPffcgyFDhrT4/BrCa1HHWa9FR7sOAfu+FoODgw3XAwD07dsXBQUFePPNN+skX01x6sQGAB544AE89thjAFBvU/O4ceMQHR2NpUuXIiIiAlqtFt27d0dVVZVhn5kzZ6JXr164ePEivvrqK9x0002IjY0FAHzxxRcoLy8HALi5uZkcX3R0NACga9eu0Gg0ePjhh/HUU09BLpebdJzg4GDI5XJD1q+XnZ2NsLAwBAcHQ6FQoGvXrkbPd+nSBbt3727wuOHh4fUeE7hyp9HQPgqFAkFBQSadhzmo1WrceeedSElJwbZt25q8E3ekcywvL8ezzz6L1atX45ZbbgEAXHPNNUhMTMTbb79t+EC9mq3P0V6vw23btmHdunV4++23Aej+gGi1WigUCnz++ed1mumbg9fiFc56LTrqdQjY77VYnwEDBuCLL74w+XVO3RUFAGPGjEFVVRWqqqqM+j4BXTP0iRMn8Pzzz+Omm25Cly5dUFBQUOcYPXr0QN++fbF06VJ8//33Rh92kZGRaN++Pdq3b2/4wbaUEAJqtbrO0L/mUCqV6NOnD7Zs2WK0fcuWLRg4cCCUSiX69euHU6dOGT1/+vTpRuO+/vrrsXPnTqNf6s2bNyMiIgJxcXGGfa5+382bN6Nv376t/sU2lf6D9MyZM/jzzz+b9UHgSOeoVquhVqshkxlfunK53HBnVR9bn6O9Xod79uxBYmKi4bFw4UL4+PggMTEREydObNG58lrUceZr0VGvQ8B+r8X6HDp0CG3atDH9ha0uP7ZD+gpwvcLCQlFYWGj4Wl8BrtFoRFBQkLj33nvFmTNnxNatW0W/fv3qrYD//PPPhVKpFP7+/qK8vLzJGM6cOSMOHTokZs2aJTp27CgOHTokDh06ZBi69u2334pVq1aJpKQkcfbsWfHjjz+KyMhIMXXq1Baft36I6ZdffimSkpLEk08+Kby8vERqaqoQQohff/1VuLm5ic8//1ycOXNGfPDBB0Iul4tdu3YZjjF//nxx3333Gb6+fPmyCAsLE3fffbc4evSo+PXXX4Wvr2+9wxPnzJkjkpKSxJdffmmxIabFxcWG7yUAsWTJEnHo0CFx/vx5oVarxW233SaioqJEYmJig0MGHfkchRBi6NCholu3bmL79u3i3LlzYtmyZcLd3V18/PHHdnWOjnAdXs1co6J4LTr+tegs16EQjnEtLl++XHz33XciKSlJnDx5Urz11lvCzc1NLFmyxOTzdYnE5mq1h7Zt2bJFdOnSRahUKnHNNdeIHTt21PtDLC4uFp6enuKRRx5pVgxDhw4VAOo8UlJShBC6D75rr71WeHt7Cy8vL9G1a1exaNGiZv2CNOajjz4SsbGxQqlUimuvvVYkJCQYPf/ll1+K9u3bC3d3d9GzZ886cy5MmzZNDB061GjbkSNHxODBg4VKpRLh4eHi5ZdfNgxN1NuxY4fo3bu3UCqVIi4uTnzyySetOo+GbN++vd7v67Rp0wzDBet7bN++3SnOUQghMjMzxfTp00VERIRwd3cXnTp1Eu+8845RvPZwjo5wHV7NXImNELwWHf1adJbrUB+HvV+Ly5cvF126dBGenp7Cx8dH9OnTR3zzzTctOFshJCFa0O/hgtLS0hAXF4d9+/bh2muvtXU4RC6J1yGRfbDna5GJTRPUajUyMzMxf/58w/A4IrIuXodE9sERrkWnLx5urb/++guxsbE4cOCAxdZcIaLG8Toksg+OcC2yxYaIiIicBltsiIiIyGkwsSEiIiKnwcSGiIiInAYTGyIiInIaTGyIyC7t2LEDkiTh8uXLtg6FyMjixYvRr18/+Pj4IDQ0FBMmTKizRIYQAi+//DIiIiLg4eGBYcOGGS0ImZ+fj8cffxydOnWCp6cnYmJiMHv2bBQWFhr2SU1NxYMPPoj4+Hh4eHigXbt2eOmll4yWZKiP/toJCAhARUWF0XP//vsvJEmyyoKhv/76K0aPHo3g4GBIkoTExMQ6+wwbNswQj/5x1113tep9mdgQkV0YNmwYnnzyScPXAwcORGZmJvz8/GwXFFE9EhIS8Oijj2Lv3r3YsmULqqurMWrUKJSWlhr2efPNN7FkyRJ8+OGH2LdvH8LDwzFy5EgUFxcDADIyMpCRkYG3334bR48exfLly7Fp0yY8+OCDhmOcPHkSWq0Wn332GY4fP453330Xn376KZ599tlmxenj44PVq1cbbfvqq68QExNjhu9C00pLS3HDDTfgjTfeaHS/hx56CJmZmYbHZ5991ro3btF8xUREZjZ06FDxxBNP2DoMIpNlZ2cLAIZlM7RarQgPDxdvvPGGYZ+Kigrh5+cnPv300waP8+OPPwqlUinUanWD+7z55psiPj6+0Xj0y0E8//zzYsSIEYbtZWVlws/PT7zwwgui9p//3Nxccdddd4nIyEjh4eEhunfvLr7//nvD8ytWrBCBgYGioqLC6H0mTZpktBZWQ/RLbBw6dKjOc5a47tliQ0Q2N336dCQkJOC9994zNEcvX77cqCtq+fLl8Pf3x/r16w3N93fccQdKS0uxYsUKxMXFISAgAI8//jg0Go3h2FVVVXjmmWcQGRkJLy8v9O/fHzt27LDNiZJT0ncfBQYGAgBSUlKQlZWFUaNGGfZRqVQYOnQo/v7770aP4+vrC4VC0eg++vdpyn333Yddu3bhwoULAIBffvkFcXFxdZZAqKioQJ8+fbB+/XocO3YMDz/8MO677z78888/AIDJkydDo9Fg3bp1htfk5uZi/fr1mDFjRrNiacx3332H4OBgdOvWDfPmzTO0arVUw989IiIree+993D69Gl0794dCxcuBACjegS9srIyvP/++1i5ciWKi4sxadIkTJo0Cf7+/ti4cSPOnTuH22+/HYMGDcKUKVMAADNmzEBqaipWrlyJiIgIrF69GmPGjMHRo0fRoUMHq54nOR8hBObOnYtBgwahe/fuAICsrCwAQFhYmNG+YWFhOH/+fL3HycvLw6uvvopZs2Y1+F5nz57FBx98gHfeeadZsYWGhmLs2LFYvnw5XnzxRXz11Vd44IEH6uwXGRmJefPmGb5+/PHHsWnTJvz000/o378/PDw8cM8992DZsmWYPHkyAF0yEhUVhWHDhjUrloZMnToV8fHxCA8Px7Fjx7BgwQIcPnwYW7ZsaflBzdr+Q0TUQlc3Seub0wsKCoQQupW3AYjk5GTDPrNmzRKenp6iuLjYsG306NFi1qxZQgghkpOThSRJIj093ei9brrpJrFgwQLLnQy5jEceeUTExsaKtLQ0w7a//vpLABAZGRlG+86cOVOMHj26zjEKCwtF//79xZgxY0RVVVW975Oeni7at28vHnzwQaPtXbt2FV5eXsLLy0uMGTNGCGF87axbt07Ex8eLs2fPCnd3d5GbmytWr15t1BVVXV0tXnvtNdGjRw8RGBgovLy8hEKhEJMnTzbsc/DgQSGXy8XFixeFEEL07NlTLFy4UAghxLfffmuIwcvLS+zcudMoxsa6oq62f/9+AUAcOHCgyX0bwhYbInIYnp6eaNeuneHrsLAwxMXFwdvb22hbdnY2AODgwYMQQqBjx45Gx6msrERQUJB1gian9fjjj2PdunXYuXMnoqKiDNvDw8MB6Fpu2rRpY9ienZ1dpxWnuLgYY8aMgbe3N1avXg03N7c675ORkYHhw4fj+uuvx+eff2703MaNG6FWqwEAHh4edV578803Y9asWXjwwQcxbty4en/v33nnHbz77rv43//+hx49esDLywtPPvmk0eir3r17o2fPnvj6668xevRoHD16FL/99hsA4LbbbkP//v0N+0ZGRjb8TWvCtddeCzc3N5w5c6bFq4YzsSEih3H1h74kSfVu02q1AACtVgu5XI4DBw5ALpcb7Vc7GSIyhRACjz/+OFavXo0dO3YgPj7e6Hl918qWLVvQu3dvALpar4SEBPz3v/817FdUVITRo0dDpVJh3bp1cHd3r/Ne6enpGD58OPr06YNly5ZBJjMujY2NjW00Vrlcjvvuuw9vvvkmfv/993r32bVrF8aPH497770XgO66OXPmDLp06WK038yZM/Huu+8iPT0dI0aMQHR0NADd6CsfH59G42iu48ePQ61WGyWEpmJiQ0R2QalUGhX9mkPv3r2h0WiQnZ2NwYMHm/XY5LoeffRRfP/991i7di18fHwMNTV+fn7w8PCAJEl48sknsWjRInTo0AEdOnTAokWL4OnpiXvuuQeArqVm1KhRKCsrw7fffouioiIUFRUBAEJCQiCXy5GRkYFhw4YhJiYGb7/9NnJycgwx6FuFmuPVV1/F008/3WArZfv27fHLL7/g77//RkBAAJYsWYKsrKw6ic3UqVMxb948LF26FF9//XWT75ufn48LFy4gIyMDAAxz/YSHhyM8PBxnz57Fd999h5tvvhnBwcFISkrCU089hd69e+OGG25o9vldjYkNEdmFuLg4/PPPP0hNTYW3t7eh1aU1OnbsiKlTp+L+++/HO++8g969eyM3Nxfbtm1Djx49cPPNN5shcnI1n3zyCQDUKZxdtmwZpk+fDgB45plnUF5ejkceeQQFBQXo378/Nm/ebGjZOHDggGHUUfv27Y2Ok5KSgri4OGzevBnJyclITk426uoCdK1GzaVUKhEcHNzg8y+88AJSUlIwevRoeHp64uGHH8aECROMJgsEAF9fX9x+++3YsGEDJkyY0OT7rlu3zmjUlH7ivZdeegkvv/wylEoltm7divfeew8lJSWIjo7GLbfcgpdeeqlOC6spJGHKd4eIyEJOnz6NadOm4fDhwygvL8eyZcswY8YMFBQUwN/fH8uXL8eTTz5pNBPxyy+/jDVr1hjNaDp9+nRcvnwZa9asAQCo1Wq89tpr+Prrr5Geno6goCBcf/31eOWVV9CjRw/rniSRgxs5ciS6dOmC999/39ahNIiJDRERETUqPz8fmzdvxtSpU5GUlIROnTrZOqQGsSuKiIiIGnXttdeioKAA//3vf+06qQHYYkNEREROhEsqEBERkdNgYkNEREROg4kNEREROQ0mNkREROQ0mNgQERGR02BiQ0RERE6DiQ0RERE5DSY2RERE5DSY2BAREZHTYGJDRERETuP/A9X12cl2PgDWAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.temperature.isel(nface=165, time=slice(1000, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "af441d7e-19d2-41a3-b7ff-6e0126993469", + "metadata": {}, + "source": [ + "## Plot Results" + ] + }, + { + "cell_type": "markdown", + "id": "793d31d6-9ef8-4692-bd58-981e3dee7fb1", + "metadata": {}, + "source": [ + "### Built-In Functions\n", + "Use the built-in plotting function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "440784b0-77a7-46fa-a73a-20b40ab2fd42", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.plot(\n", + " crs='EPSG:26916',\n", + " clim=(5, 26)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b6aadcb2-4186-4aac-a036-0f2c1e9978f6", + "metadata": {}, + "source": [ + "### Build Panel Apps\n", + "\n", + "#### Interactive Timeseries Plotting\n", + "This is an exmaple of an interactive map that allows you to click on a single cell and see the timeseries for that cell:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6dc19e97-9725-4f80-864b-2d034623314a", + "metadata": {}, + "outputs": [], + "source": [ + "from clearwater_riverine.variables import (\n", + " NUMBER_OF_REAL_CELLS,\n", + " CONCENTRATION,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cae6e61-9877-447d-bece-7b7dacfd3851", + "metadata": {}, + "outputs": [], + "source": [ + "# create inputs for panel app\n", + "ds = transport_model.mesh\n", + "gdf = transport_model.gdf\n", + "time_index = 60\n", + "mn_val = 4\n", + "mval = 25\n", + "date_value = ds.time.isel(time=time_index).values" + ] + }, + { + "cell_type": "markdown", + "id": "374633ff-30cf-48a3-b5c3-6bc73d690f88", + "metadata": {}, + "source": [ + "Start by creating a base map of a plan view of Sumwere Creek using the `geoviews` library. Including the `hover` and `tap` tools allows users to hover over the plot to see values and turns on the ability to use the tap stream that allows users to click on a cell and receive feedback from that tap. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95fb690b", + "metadata": {}, + "outputs": [], + "source": [ + "ras_sub_df = gdf[(gdf.datetime == date_value) & (gdf.concentration != 0)]\n", + "units = ds[CONCENTRATION].Units\n", + "ras_map = gv.Polygons(\n", + " ras_sub_df,\n", + " vdims=['concentration', 'cell']).opts(\n", + " height = 800,\n", + " width = 800,\n", + " color='concentration',\n", + " cmap='RdYlBu_r',\n", + " line_width = 0.1,\n", + " tools = ['hover', 'tap'],\n", + " clabel = f\"Concentration ({units})\",\n", + " xaxis=None,\n", + " yaxis=None,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "10c064e1-58d7-44b5-90a5-e914f50a1e88", + "metadata": {}, + "source": [ + "The cell below defines the tap stream and initializes an empty list of plots to display. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5b8a690", + "metadata": {}, + "outputs": [], + "source": [ + "tap_stream = hv.streams.Tap(source=ras_map, x=None, y=None)\n", + "plots = []" + ] + }, + { + "cell_type": "markdown", + "id": "086f5ae1-61c9-43ec-8dd7-3d97233ca903", + "metadata": {}, + "source": [ + "The `tap_plot` function identifies which cell has been clicked and generates a timeseries plot for that cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b2c8431-06e6-44ca-8f5a-6f2ffae4f51b", + "metadata": {}, + "outputs": [], + "source": [ + "def tap_plot(x, y):\n", + " # filter data\n", + " clicked_data = ras_sub_df.cx[x:x, y:y]\n", + " if x != None and y != None:\n", + " # identify cell number and pull concentration timeseries for that cell\n", + " cell = clicked_data['cell'].iloc[0]\n", + " cs = ds.concentration.isel(nface=cell, time=slice(0, TIME_STEPS))\n", + "\n", + " # Create timeseries plot\n", + " curve = hv.Curve(\n", + " cs,\n", + " ).opts(\n", + " title=f'Time series',\n", + " height=800,\n", + " width=800,\n", + " line_width=5,\n", + " fontsize= {'title': 18, 'labels': 16, 'xticks': 12, 'yticks': 12},\n", + " ylabel= 'Water Temperature (C)'\n", + " )\n", + "\n", + " # Append to list of plots (allows multiple lines to appear at the same time)\n", + " plots.append(curve)\n", + " # Return an overlay of all the plots\n", + " return hv.Overlay(plots).opts(legend_position='right')\n", + " else:\n", + " # Create an empty timeseries plot telling users to click on a cell to generate a timeseries\n", + " xs = np.linspace(-5,5,100)\n", + " empty_curve = hv.Curve((xs,-(xs-2)**2)).opts(\n", + " title=f'Time series',\n", + " line_color='white',\n", + " height=800, \n", + " width=800,\n", + " xaxis=None,\n", + " yaxis=None,\n", + " )* hv.Text(0, -20, \"Please click a cell on the map to display a timeseries.\")\n", + " return empty_curve\n", + "\n", + "# Create Dynamic Map that references the tap stream.\n", + "tap_dmap = hv.DynamicMap(tap_plot, streams=[tap_stream])" + ] + }, + { + "cell_type": "markdown", + "id": "6d3d9114-6daa-486f-beaf-629e7f06911c", + "metadata": {}, + "source": [ + "The following function and button allows users to clear all timeseries plots if they wish to start fresh:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf70743d", + "metadata": {}, + "outputs": [], + "source": [ + "def reset_tap_stream(event):\n", + " global plots\n", + " tap_stream.event(x=None, y=None)\n", + " plots = []\n", + " \n", + "button = pn.widgets.Button(name='Reset', button_type='primary')\n", + "button.on_click(reset_tap_stream)" + ] + }, + { + "cell_type": "markdown", + "id": "1bea5541-de92-4f29-86ab-e0d8df1f7167", + "metadata": {}, + "source": [ + "Now display the plot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c1661ac-e670-4752-ae8f-8889bf81288a", + "metadata": {}, + "outputs": [], + "source": [ + "layout = pn.Row(\n", + " ras_map,\n", + " tap_dmap.opts(\n", + " hv.opts.Curve(framewise=True, yaxis='right'),\n", + " ),\n", + " button\n", + " )\n", + "layout.servable()" + ] + }, + { + "cell_type": "markdown", + "id": "38a9609e-9090-413b-bbd3-b9fd0017f1cf", + "metadata": {}, + "source": [ + "#### Dynamic Map Visualization\n", + "Make a plot with a scrubber bar that shows a map over time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8fbb429e-0939-4513-9f35-a893f22f109c", + "metadata": {}, + "outputs": [], + "source": [ + "ds = transport_model.mesh\n", + "gdf = transport_model.gdf\n", + "import hvplot.pandas " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d7bb0cb-32fd-4f96-916d-a084e60e4e6a", + "metadata": {}, + "outputs": [], + "source": [ + "# eliminate cells without any temperature\n", + "gdf_sub = gdf[gdf.concentration != 0]\n", + "gdf_subset = gdf_sub[(gdf_sub['datetime'] > '2022-05-13 08:00:00')]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7937eec0-e050-43ff-8a3c-57bbb72abfc0", + "metadata": {}, + "outputs": [], + "source": [ + "plot_to_save = gdf_subset.hvplot(\n", + " geo=True,\n", + " groupby=\"datetime\",\n", + " # z = 'concentration',\n", + " c = 'concentration', # minute_gdf_subset.concentration,\n", + " clim=(4, 25),\n", + " cmap='RdYlBu_r',\n", + " clabel='Water Temperature (C)',\n", + " line_width = 0.1,\n", + " height=700,\n", + " width=800,\n", + " widget_location='bottom',\n", + " line_color='white',\n", + " \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b62985fb-0876-4bf8-b79e-a5a30a8731f7", + "metadata": {}, + "outputs": [], + "source": [ + "plot_to_save" + ] + }, + { + "cell_type": "raw", + "id": "09061d44-666a-40fc-8388-8acc597b72d0", + "metadata": {}, + "source": [ + "plot_to_save.save(filename='data_temp/output.html', embed=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 19425eabf3a2bb2fd136a97ce4d23dc88ead4fed Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Wed, 19 Jun 2024 16:00:24 -0500 Subject: [PATCH 20/41] fix transport differences. --- .../data/diffusion_coefficient_cv.csv | 41 + .../diffusion_coefficient_differences.csv | 41 + .../multiple_constituents_mass_bal_fix.ipynb | 849 ++++++++++++++++++ src/clearwater_riverine/postproc_util.py | 48 +- src/clearwater_riverine/transport.py | 10 +- 5 files changed, 965 insertions(+), 24 deletions(-) create mode 100644 examples/dev_sandbox/data/diffusion_coefficient_cv.csv create mode 100644 examples/dev_sandbox/data/diffusion_coefficient_differences.csv create mode 100644 examples/dev_sandbox/multiple_constituents_mass_bal_fix.ipynb diff --git a/examples/dev_sandbox/data/diffusion_coefficient_cv.csv b/examples/dev_sandbox/data/diffusion_coefficient_cv.csv new file mode 100644 index 0000000..a5c830c --- /dev/null +++ b/examples/dev_sandbox/data/diffusion_coefficient_cv.csv @@ -0,0 +1,41 @@ +,0.0,0.001,0.01,0.1 +Vol_start,0.0,0.0,0.0,0.0 +Mass_start,0.0,0.0,0.0,0.0 +Vol_end,0.0,0.0,0.0,0.0 +Mass_end,-2.0961972422383542e-07,-2.088112535843494e-07,-2.0231457938803223e-07,-1.8298047208465243e-07 +US_Flow_vol,-0.0,-0.0,-0.0,-0.0 +US_Flow_mass,-0.0,-1.9893818911062342e-08,-1.9905176797972897e-07,-2.001597413602265e-06 +US_Flow_in_vol,-0.0,-0.0,-0.0,-0.0 +US_Flow_in_mass,-0.0,-1.9893818911062342e-08,-1.9905176797972897e-07,-2.001597413602265e-06 +US_Flow_out_vol,,,, +US_Flow_out_mass,,,, +DS_Stage_vol,0.0,0.0,0.0,0.0 +DS_Stage_mass,-0.000197640316704926,-0.00019763322197439173,-0.0001975681525397757,-0.00019680960059493792 +DS_Stage_in_vol,,,, +DS_Stage_in_mass,,inf,inf,inf +DS_Stage_out_vol,0.0,0.0,0.0,0.0 +DS_Stage_out_mass,-0.000197640316704926,-0.0001976332221109606,-0.00019756817862477986,-0.0001968137165046367 +PwrPlnt_Flow_vol,-0.0,-0.0,-0.0,-0.0 +PwrPlnt_Flow_mass,-0.0,-3.0276420092383476e-08,-3.0284386462453933e-07,-3.0369720805790324e-06 +PwrPlnt_Flow_in_vol,-0.0,-0.0,-0.0,-0.0 +PwrPlnt_Flow_in_mass,-0.0,-3.0276420092383476e-08,-3.0284386462453933e-07,-3.0369720805790324e-06 +PwrPlnt_Flow_out_vol,,,, +PwrPlnt_Flow_out_mass,,,, +CoriolisColdSpringCreek_vol,-0.0,-0.0,-0.0,-0.0 +CoriolisColdSpringCreek_mass,-0.0,-8.110066371570102e-08,-8.10597728490835e-07,-8.066427521322806e-06 +CoriolisColdSpringCreek_in_vol,-0.0,-0.0,-0.0,-0.0 +CoriolisColdSpringCreek_in_mass,-0.0,-8.110066371570102e-08,-8.10597728490835e-07,-8.066427521322806e-06 +CoriolisColdSpringCreek_out_vol,,,, +CoriolisColdSpringCreek_out_mass,,,, +bcTotalVolInOutAll,-0.0,-0.0,-0.0,-0.0 +bcTotalVolInAll,-0.0,-0.0,-0.0,-0.0 +bcTotalVolOutAll,0.0,0.0,0.0,0.0 +bcTotalMassInOutAll,0.001502367205097536,0.00150201524053505,0.0014988383636570341,0.0014662535655106898 +bcTotalMassInAll,-0.0,-3.464908356652066e-08,-3.465063811739662e-07,-3.468016498448916e-06 +bcTotalMassOutAll,-0.000197640316704926,-0.0001976332221109606,-0.00019756817862477986,-0.0001968137165046367 +vol_end_calc,0.0,0.0,0.0,0.0 +error_vol,-0.0,-0.0,-0.0,-0.0 +prct_error_vol,0.0,0.0,0.0,0.0 +mass_end_calc,0.0009312506119426283,0.0009310324447628957,0.0009290632400796364,0.000908865372932729 +error_mass,-222.53046856168783,-222.47815419212978,-222.00614933405544,-217.176159680256 +prct_error_mass,-222.53046856168783,-222.47814644881683,-222.00607206102842,-217.1754030443587 diff --git a/examples/dev_sandbox/data/diffusion_coefficient_differences.csv b/examples/dev_sandbox/data/diffusion_coefficient_differences.csv new file mode 100644 index 0000000..10f1e10 --- /dev/null +++ b/examples/dev_sandbox/data/diffusion_coefficient_differences.csv @@ -0,0 +1,41 @@ +,0.0,0.001,0.01,0.1 +Vol_start,0.0,0.0,0.0,0.0 +Mass_start,0.0,0.0,0.0,0.0 +Vol_end,0.0,0.0,0.0,0.0 +Mass_end,-30.250933796167374,-30.134260654449463,-29.196703553199768,-26.406532913446426 +US_Flow_vol,0.0,0.0,0.0,0.0 +US_Flow_mass,0.0,10.204635500907898,102.10461586713791,1026.7295644283295 +US_Flow_in_vol,0.0,0.0,0.0,0.0 +US_Flow_in_mass,0.0,10.204635500907898,102.10461586713791,1026.7295644283295 +US_Flow_out_vol,0.0,0.0,0.0,0.0 +US_Flow_out_mass,0.0,0.0,0.0,0.0 +DS_Stage_vol,0.0,0.0,0.0,0.0 +DS_Stage_mass,-134391.3736948967,-134386.54942321777,-134342.30353832245,-133826.5037279129 +DS_Stage_in_vol,0.0,0.0,0.0,0.0 +DS_Stage_in_mass,0.0,9.283453138039548e-05,0.017737281406800455,2.798734537592982 +DS_Stage_out_vol,0.0,0.0,0.0,0.0 +DS_Stage_out_mass,-134391.3736948967,-134386.5495160818,-134342.32127559185,-133829.3024623394 +PwrPlnt_Flow_vol,0.0,0.0,0.0,0.0 +PwrPlnt_Flow_mass,0.0,2.588407337665558,25.890884026885033,259.6383850425482 +PwrPlnt_Flow_in_vol,0.0,0.0,0.0,0.0 +PwrPlnt_Flow_in_mass,0.0,2.588407337665558,25.890884026885033,259.6383850425482 +PwrPlnt_Flow_out_vol,0.0,0.0,0.0,0.0 +PwrPlnt_Flow_out_mass,0.0,0.0,0.0,0.0 +CoriolisColdSpringCreek_vol,0.0,0.0,0.0,0.0 +CoriolisColdSpringCreek_mass,0.0,13.866999626159668,138.60007899999619,1379.2383723855019 +CoriolisColdSpringCreek_in_vol,0.0,0.0,0.0,0.0 +CoriolisColdSpringCreek_in_mass,0.0,13.866999626159668,138.60007899999619,1379.2383723855019 +CoriolisColdSpringCreek_out_vol,0.0,0.0,0.0,0.0 +CoriolisColdSpringCreek_out_mass,0.0,0.0,0.0,0.0 +bcTotalVolInOutAll,0.0,0.0,0.0,0.0 +bcTotalVolInAll,0.0,0.0,0.0,0.0 +bcTotalVolOutAll,0.0,0.0,0.0,0.0 +bcTotalMassInOutAll,-134391.3736948967,-134359.88938075304,-134075.70795942843,-131160.89740605652 +bcTotalMassInAll,0.0,26.660135507583618,266.6133162975311,2668.405056476593 +bcTotalMassOutAll,-134391.3736948967,-134386.5495160818,-134342.32127559185,-133829.3024623394 +vol_end_calc,0.0,0.0,0.0,0.0 +error_vol,0.0,0.0,0.0,0.0 +prct_error_vol,0.0,0.0,0.0,0.0 +mass_end_calc,134391.3736948967,134359.88938057423,134075.70795929432,131160.8974058628 +error_mass,134421.62462869287,134390.02364122868,134104.90466284752,131187.30393877625 +prct_error_mass,-0.017470226674512496,-0.017466119016006882,-0.017429057814387163,-0.017049815891893434 diff --git a/examples/dev_sandbox/multiple_constituents_mass_bal_fix.ipynb b/examples/dev_sandbox/multiple_constituents_mass_bal_fix.ipynb new file mode 100644 index 0000000..7e7f4f3 --- /dev/null +++ b/examples/dev_sandbox/multiple_constituents_mass_bal_fix.ipynb @@ -0,0 +1,849 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3278aa96-42ab-4b29-8d31-10b1fada56f0", + "metadata": {}, + "source": [ + "# Constituents\n", + "\n", + "## Set up" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "87602459-30f0-4419-bb36-b92b77ef32e4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1005" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# import modules\n", + "from pathlib import Path\n", + "import pandas as pd\n", + "import clearwater_riverine as cwr\n", + "from clearwater_riverine.postproc_util import _mass_bal_global, _mass_bal_global_100_Ans" + ] + }, + { + "cell_type": "markdown", + "id": "4f37b89c-66a5-4ca4-9811-f52e29f1bfee", + "metadata": {}, + "source": [ + "## Model Set Up" + ] + }, + { + "cell_type": "markdown", + "id": "49adc7b0-a67c-4303-945b-edf17e0c4558", + "metadata": {}, + "source": [ + "We now set up the model with the `config_filepath` parameter. If a config is provided, the model will use all information from the config by default (i.e., it will override any of the other optional input parameters in the Python interface). \n", + "\n", + "Users can still set up without a config, but would require the following parameters instead:\n", + "* `flow_field_file_path`\n", + "* `diffusion_coefficient`\n", + "* `constituent_dict`: a dictionary containing constituent names, initial conditions, boundary conditions, and optionally units.\n", + "\n", + "Here we show how to use the `config_filepath`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9adc08e3-4b22-4f72-a377-10c03d58dddc", + "metadata": {}, + "outputs": [], + "source": [ + "# point to config\n", + "config_filepath = \"./demo_config_single.yml\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "37960472-ef4e-4316-8562-0379f51d38fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "0.0\n", + "0.01\n", + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "0.01\n", + "0.001\n", + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "0.001\n", + "0.1\n", + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "0.1\n" + ] + } + ], + "source": [ + "results_df = pd.DataFrame()\n", + "answer_df = pd.DataFrame()\n", + "diffusion_coefficient_list = [0.0, 0.01, 0.001, 0.1]\n", + "\n", + "for diffusion_coefficient in diffusion_coefficient_list:\n", + " print(diffusion_coefficient)\n", + " transport_model = cwr.ClearwaterRiverine(\n", + " diffusion_coefficient_input=diffusion_coefficient,\n", + " config_filepath=config_filepath,\n", + " verbose=True,\n", + " )\n", + "\n", + " print(transport_model.mesh.attrs['diffusion_coefficient'])\n", + "\n", + " for t in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()\n", + "\n", + " \n", + " mass_bal = _mass_bal_global(transport_model, 'conservative_tracer')\n", + " results_df[diffusion_coefficient] = mass_bal.transpose()\n", + " mass_bal_answer = _mass_bal_global_100_Ans(transport_model, 'conservative_tracer')\n", + " answer_df[diffusion_coefficient] = mass_bal_answer.transpose()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "28ed0115", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0.00.010.0010.1answer
Vol_start5.485971e+055.485971e+055.485971e+055.485971e+055.485971e+05
Mass_start5.485971e+075.485971e+075.485971e+075.485971e+075.485971e+07
Vol_end1.443134e+061.443134e+061.443134e+061.443134e+061.443134e+06
Mass_end1.443134e+081.443134e+081.443134e+081.443134e+081.443134e+08
US_Flow_vol-5.129551e+06-5.129551e+06-5.129551e+06-5.129551e+06-5.129551e+06
US_Flow_mass-5.129551e+08-5.129552e+08-5.129551e+08-5.129561e+08-5.129551e+08
US_Flow_in_vol-5.129551e+06-5.129551e+06-5.129551e+06-5.129551e+06-5.129551e+06
US_Flow_in_mass-5.129551e+08-5.129552e+08-5.129551e+08-5.129561e+08-5.129551e+08
US_Flow_out_vol0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
US_Flow_out_mass0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
DS_Stage_vol6.799796e+066.799796e+066.799796e+066.799796e+066.799796e+06
DS_Stage_mass6.801139e+086.801139e+086.801139e+086.801134e+086.799796e+08
DS_Stage_in_vol0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
DS_Stage_in_mass0.000000e+00-1.773728e-02-9.283453e-05-2.798735e+000.000000e+00
DS_Stage_out_vol6.799796e+066.799796e+066.799796e+066.799796e+066.799796e+06
DS_Stage_out_mass6.801139e+086.801139e+086.801139e+086.801134e+086.799796e+08
PwrPlnt_Flow_vol-8.549252e+05-8.549252e+05-8.549252e+05-8.549252e+05-8.549252e+05
PwrPlnt_Flow_mass-8.549252e+07-8.549254e+07-8.549252e+07-8.549278e+07-8.549252e+07
PwrPlnt_Flow_in_vol-8.549252e+05-8.549252e+05-8.549252e+05-8.549252e+05-8.549252e+05
PwrPlnt_Flow_in_mass-8.549252e+07-8.549254e+07-8.549252e+07-8.549278e+07-8.549252e+07
PwrPlnt_Flow_out_vol0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
PwrPlnt_Flow_out_mass0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
CoriolisColdSpringCreek_vol-1.709850e+06-1.709850e+06-1.709850e+06-1.709850e+06-1.709850e+06
CoriolisColdSpringCreek_mass-1.709850e+08-1.709852e+08-1.709850e+08-1.709864e+08-1.709850e+08
CoriolisColdSpringCreek_in_vol-1.709850e+06-1.709850e+06-1.709850e+06-1.709850e+06-1.709850e+06
CoriolisColdSpringCreek_in_mass-1.709850e+08-1.709852e+08-1.709850e+08-1.709864e+08-1.709850e+08
CoriolisColdSpringCreek_out_vol0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
CoriolisColdSpringCreek_out_mass0.000000e+000.000000e+000.000000e+000.000000e+000.000000e+00
bcTotalVolInOutAll-8.945308e+05-8.945308e+05-8.945308e+05-8.945308e+05-8.945308e+05
bcTotalVolInAll-7.694326e+06-7.694326e+06-7.694326e+06-7.694326e+06-7.694326e+06
bcTotalVolOutAll6.799796e+066.799796e+066.799796e+066.799796e+066.799796e+06
bcTotalMassInOutAll-8.931869e+07-8.931900e+07-8.931872e+07-8.932192e+07-8.945308e+07
bcTotalMassInAll-7.694326e+08-7.694329e+08-7.694327e+08-7.694353e+08-7.694326e+08
bcTotalMassOutAll6.801139e+086.801139e+086.801139e+086.801134e+086.799796e+08
vol_end_calc1.443128e+061.443128e+061.443128e+061.443128e+061.443128e+06
error_vol-6.075613e+00-6.075613e+00-6.075613e+00-6.075613e+00-6.075613e+00
prct_error_vol7.896225e-057.896225e-057.896225e-057.896225e-057.896225e-05
mass_end_calc1.441784e+081.441787e+081.441784e+081.441816e+081.443128e+08
error_mass-1.350257e+05-1.347090e+05-1.349941e+05-1.317914e+05-6.040594e+02
prct_error_mass1.754873e-021.750756e-021.754463e-021.712832e-027.850712e-05
\n", + "
" + ], + "text/plain": [ + " 0.0 0.01 0.001 \\\n", + "Vol_start 5.485971e+05 5.485971e+05 5.485971e+05 \n", + "Mass_start 5.485971e+07 5.485971e+07 5.485971e+07 \n", + "Vol_end 1.443134e+06 1.443134e+06 1.443134e+06 \n", + "Mass_end 1.443134e+08 1.443134e+08 1.443134e+08 \n", + "US_Flow_vol -5.129551e+06 -5.129551e+06 -5.129551e+06 \n", + "US_Flow_mass -5.129551e+08 -5.129552e+08 -5.129551e+08 \n", + "US_Flow_in_vol -5.129551e+06 -5.129551e+06 -5.129551e+06 \n", + "US_Flow_in_mass -5.129551e+08 -5.129552e+08 -5.129551e+08 \n", + "US_Flow_out_vol 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "US_Flow_out_mass 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "DS_Stage_vol 6.799796e+06 6.799796e+06 6.799796e+06 \n", + "DS_Stage_mass 6.801139e+08 6.801139e+08 6.801139e+08 \n", + "DS_Stage_in_vol 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "DS_Stage_in_mass 0.000000e+00 -1.773728e-02 -9.283453e-05 \n", + "DS_Stage_out_vol 6.799796e+06 6.799796e+06 6.799796e+06 \n", + "DS_Stage_out_mass 6.801139e+08 6.801139e+08 6.801139e+08 \n", + "PwrPlnt_Flow_vol -8.549252e+05 -8.549252e+05 -8.549252e+05 \n", + "PwrPlnt_Flow_mass -8.549252e+07 -8.549254e+07 -8.549252e+07 \n", + "PwrPlnt_Flow_in_vol -8.549252e+05 -8.549252e+05 -8.549252e+05 \n", + "PwrPlnt_Flow_in_mass -8.549252e+07 -8.549254e+07 -8.549252e+07 \n", + "PwrPlnt_Flow_out_vol 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "PwrPlnt_Flow_out_mass 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "CoriolisColdSpringCreek_vol -1.709850e+06 -1.709850e+06 -1.709850e+06 \n", + "CoriolisColdSpringCreek_mass -1.709850e+08 -1.709852e+08 -1.709850e+08 \n", + "CoriolisColdSpringCreek_in_vol -1.709850e+06 -1.709850e+06 -1.709850e+06 \n", + "CoriolisColdSpringCreek_in_mass -1.709850e+08 -1.709852e+08 -1.709850e+08 \n", + "CoriolisColdSpringCreek_out_vol 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "CoriolisColdSpringCreek_out_mass 0.000000e+00 0.000000e+00 0.000000e+00 \n", + "bcTotalVolInOutAll -8.945308e+05 -8.945308e+05 -8.945308e+05 \n", + "bcTotalVolInAll -7.694326e+06 -7.694326e+06 -7.694326e+06 \n", + "bcTotalVolOutAll 6.799796e+06 6.799796e+06 6.799796e+06 \n", + "bcTotalMassInOutAll -8.931869e+07 -8.931900e+07 -8.931872e+07 \n", + "bcTotalMassInAll -7.694326e+08 -7.694329e+08 -7.694327e+08 \n", + "bcTotalMassOutAll 6.801139e+08 6.801139e+08 6.801139e+08 \n", + "vol_end_calc 1.443128e+06 1.443128e+06 1.443128e+06 \n", + "error_vol -6.075613e+00 -6.075613e+00 -6.075613e+00 \n", + "prct_error_vol 7.896225e-05 7.896225e-05 7.896225e-05 \n", + "mass_end_calc 1.441784e+08 1.441787e+08 1.441784e+08 \n", + "error_mass -1.350257e+05 -1.347090e+05 -1.349941e+05 \n", + "prct_error_mass 1.754873e-02 1.750756e-02 1.754463e-02 \n", + "\n", + " 0.1 answer \n", + "Vol_start 5.485971e+05 5.485971e+05 \n", + "Mass_start 5.485971e+07 5.485971e+07 \n", + "Vol_end 1.443134e+06 1.443134e+06 \n", + "Mass_end 1.443134e+08 1.443134e+08 \n", + "US_Flow_vol -5.129551e+06 -5.129551e+06 \n", + "US_Flow_mass -5.129561e+08 -5.129551e+08 \n", + "US_Flow_in_vol -5.129551e+06 -5.129551e+06 \n", + "US_Flow_in_mass -5.129561e+08 -5.129551e+08 \n", + "US_Flow_out_vol 0.000000e+00 0.000000e+00 \n", + "US_Flow_out_mass 0.000000e+00 0.000000e+00 \n", + "DS_Stage_vol 6.799796e+06 6.799796e+06 \n", + "DS_Stage_mass 6.801134e+08 6.799796e+08 \n", + "DS_Stage_in_vol 0.000000e+00 0.000000e+00 \n", + "DS_Stage_in_mass -2.798735e+00 0.000000e+00 \n", + "DS_Stage_out_vol 6.799796e+06 6.799796e+06 \n", + "DS_Stage_out_mass 6.801134e+08 6.799796e+08 \n", + "PwrPlnt_Flow_vol -8.549252e+05 -8.549252e+05 \n", + "PwrPlnt_Flow_mass -8.549278e+07 -8.549252e+07 \n", + "PwrPlnt_Flow_in_vol -8.549252e+05 -8.549252e+05 \n", + "PwrPlnt_Flow_in_mass -8.549278e+07 -8.549252e+07 \n", + "PwrPlnt_Flow_out_vol 0.000000e+00 0.000000e+00 \n", + "PwrPlnt_Flow_out_mass 0.000000e+00 0.000000e+00 \n", + "CoriolisColdSpringCreek_vol -1.709850e+06 -1.709850e+06 \n", + "CoriolisColdSpringCreek_mass -1.709864e+08 -1.709850e+08 \n", + "CoriolisColdSpringCreek_in_vol -1.709850e+06 -1.709850e+06 \n", + "CoriolisColdSpringCreek_in_mass -1.709864e+08 -1.709850e+08 \n", + "CoriolisColdSpringCreek_out_vol 0.000000e+00 0.000000e+00 \n", + "CoriolisColdSpringCreek_out_mass 0.000000e+00 0.000000e+00 \n", + "bcTotalVolInOutAll -8.945308e+05 -8.945308e+05 \n", + "bcTotalVolInAll -7.694326e+06 -7.694326e+06 \n", + "bcTotalVolOutAll 6.799796e+06 6.799796e+06 \n", + "bcTotalMassInOutAll -8.932192e+07 -8.945308e+07 \n", + "bcTotalMassInAll -7.694353e+08 -7.694326e+08 \n", + "bcTotalMassOutAll 6.801134e+08 6.799796e+08 \n", + "vol_end_calc 1.443128e+06 1.443128e+06 \n", + "error_vol -6.075613e+00 -6.075613e+00 \n", + "prct_error_vol 7.896225e-05 7.896225e-05 \n", + "mass_end_calc 1.441816e+08 1.443128e+08 \n", + "error_mass -1.317914e+05 -6.040594e+02 \n", + "prct_error_mass 1.712832e-02 7.850712e-05 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_df['answer'] = answer_df[0.0]\n", + "results_df" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1deb1915", + "metadata": {}, + "outputs": [], + "source": [ + "difference_df = pd.DataFrame()\n", + "cv_df = pd.DataFrame()\n", + "\n", + "for dc in diffusion_coefficient_list:\n", + " abs_diff = results_df['answer'] - results_df[dc]\n", + " cv = (results_df['answer'] - results_df[dc]) / results_df['answer']\n", + " difference_df[dc] = abs_diff\n", + " cv_df[dc] = cv" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fc9f3952", + "metadata": {}, + "outputs": [], + "source": [ + "difference_df = difference_df[[0.0, 0.001, 0.01, 0.1]]\n", + "difference_df.to_csv('data/diffusion_coefficient_differences.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "910cf122", + "metadata": {}, + "outputs": [], + "source": [ + "cv_df = cv_df[[0.0, 0.001, 0.01, 0.1]]\n", + "cv_df.to_csv('data/diffusion_coefficient_cv.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb408a3d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/clearwater_riverine/postproc_util.py b/src/clearwater_riverine/postproc_util.py index 7104db9..8c80450 100644 --- a/src/clearwater_riverine/postproc_util.py +++ b/src/clearwater_riverine/postproc_util.py @@ -2,15 +2,11 @@ import numpy as np import pandas as pd +import xarray as xr import clearwater_riverine as cwr from clearwater_riverine import variables -#import pytest - - - -#def _run_simulation(ras_hdf, diff_coef, intl_cnd, bndry) -> crw.ClearwaterRiverine: def _run_simulation(ras_hdf, diff_coef, intl_cnd, bndry): """Returns a Clearwater Riverine Simulation object that has water quality results""" fpath = ras_hdf @@ -21,8 +17,10 @@ def _run_simulation(ras_hdf, diff_coef, intl_cnd, bndry): return simulation -def _mass_bal_global(simulation:cwr.ClearwaterRiverine, - constituent_name: str) -> pd.DataFrame: +def _mass_bal_global( + simulation:cwr.ClearwaterRiverine, + constituent_name: str +) -> pd.DataFrame: """Returns entire domain and overall simulation period mass balance values""" #Find Mass at the start of simulation @@ -69,7 +67,7 @@ def _mass_bal_global(simulation:cwr.ClearwaterRiverine, bcTotalMassInAll = [0] bcTotalMassOutAll = [0] - for index, row in bcLineIDs_sorted.iterrows(): + for _, row in bcLineIDs_sorted.iterrows(): #Total Flow/Mass from boundary condition bc_name = row['Name'] bc_id = row['BC Line ID'] @@ -157,8 +155,10 @@ def _mass_bal_global(simulation:cwr.ClearwaterRiverine, -def _mass_bal_global_100_Ans(simulation:cwr.ClearwaterRiverine, - constituent_name: str) -> pd.DataFrame: +def _mass_bal_global_100_Ans( + simulation:cwr.ClearwaterRiverine, + constituent_name: str +) -> pd.DataFrame: """Returns entire domain and overall simulation period mass balance values assuming intial conditions are 100 mg/L everywhere and any boundary conditions inputs are also 100mg/L @@ -167,9 +167,12 @@ def _mass_bal_global_100_Ans(simulation:cwr.ClearwaterRiverine, #Find Mass at the start of simulation nreal_index = simulation.mesh.attrs[variables.NUMBER_OF_REAL_CELLS] + 1 vol_start = simulation.mesh.volume[0][0:nreal_index] - conc_start = simulation.mesh[constituent_name].data[0][0:nreal_index] - conc_start_100 = vol_start.copy(deep=True) - conc_start_100 = conc_start_100.where(conc_start_100==100, other=100) + conc_start = simulation.mesh[constituent_name][0][0:nreal_index] + conc_start_100 = xr.full_like( + conc_start, + fill_value=100, + dtype=np.float64 + ) mass_start = vol_start * conc_start_100 vol_start_sum = vol_start.sum() mass_start_sum = mass_start.sum() @@ -181,9 +184,12 @@ def _mass_bal_global_100_Ans(simulation:cwr.ClearwaterRiverine, #Find Mass at the end of simulation t_max_index = len(simulation.mesh.time) - 1 vol_end = simulation.mesh.volume[t_max_index][0:nreal_index] - conc_end = simulation.mesh[constituent_name].data[t_max_index][0:nreal_index] - conc_end_100 = vol_end.copy(deep=True) - conc_end_100 = conc_end_100.where(conc_end_100==100, other=100) + conc_end = simulation.mesh[constituent_name][t_max_index][0:nreal_index] + conc_end_100 = xr.full_like( + conc_end, + fill_value=100, + dtype=np.float64 + ) mass_end = vol_end * conc_end_100 vol_end_sum = vol_end.sum() mass_end_sum = mass_end.sum() @@ -213,7 +219,7 @@ def _mass_bal_global_100_Ans(simulation:cwr.ClearwaterRiverine, bcTotalMassInAll = [0] bcTotalMassOutAll = [0] - for index, row in bcLineIDs_sorted.iterrows(): + for _, row in bcLineIDs_sorted.iterrows(): #Total Mass from boundary condition bc_name = row['Name'] bc_id = row['BC Line ID'] @@ -229,9 +235,11 @@ def _mass_bal_global_100_Ans(simulation:cwr.ClearwaterRiverine, bc_name_vol = bc_name + '_vol' df[bc_name_vol] = bc_totalVol_xda_val_np bcTotalVolInOutAll = bcTotalVolInOutAll + bc_totalVol_xda_val_np - - bc_edgeConc100_xda = bc_edgeFlow_xda.copy(deep=True) - bc_edgeConc100_xda = bc_edgeConc100_xda.where(bc_edgeConc100_xda==100, other=100) + bc_edgeConc100_xda = xr.full_like( + bc_edgeFlow_xda, + fill_value=100, + dtype=np.float64 + ) bc_edgeMass_xda = bc_edgeFlow_xda * simulation.mesh[variables.CHANGE_IN_TIME] * bc_edgeConc100_xda bc_totalMass_xda = bc_edgeMass_xda.sum() bc_totalMass_xda_val = bc_totalMass_xda.values diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 206b76f..5cbe965 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -83,7 +83,7 @@ class ClearwaterRiverine: def __init__( self, flow_field_file_path: Optional[str | Path] = None, - diffusion_coefficient_input: Optional[float] = 0.0, + diffusion_coefficient_input: Optional[float] = None, constituent_dict: Optional[Dict[str, Dict[str, Any]]] = None, config_filepath: Optional[str] = None, verbose: Optional[bool] = False, @@ -99,8 +99,10 @@ def __init__( if config_filepath: model_config = parse_config(config_filepath=config_filepath) - diffusion_coefficient_input = model_config['diffusion_coefficient'] - flow_field_file_path = model_config['flow_field_filepath'] + if diffusion_coefficient_input is None: + diffusion_coefficient_input = model_config['diffusion_coefficient'] + if not flow_field_file_path: + flow_field_file_path = model_config['flow_field_filepath'] self.constituents = model_config['constituents'].keys() else: if flow_field_file_path: @@ -333,7 +335,7 @@ def finalize( constituent.set_value_range(self.mesh) if save == True: - self.mesh.cwr.save_clearwater_exarray(output_filepath) + self.mesh.cwr.save_clearwater_xarray(output_filepath) def _timer(self, t): From b7e13c36995aa1bb7bd8b60a715f872178aeff14 Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Thu, 20 Jun 2024 15:54:10 -0400 Subject: [PATCH 21/41] made changes to the ClearwaterRiverine.update() method Initial testing looked promising. Running plan48 to verify. --- ...e_modules_updated_(scaled)_crs_30sec.ipynb | 1555 +++++++++++++++++ .../80_debug_constituents_linking_to_TSM | 34 + src/clearwater_riverine/transport.py | 4 +- 3 files changed, 1591 insertions(+), 2 deletions(-) create mode 100644 examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb create mode 100644 examples/dev_sandbox/80_debug_constituents_linking_to_TSM diff --git a/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb b/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb new file mode 100644 index 0000000..c1ec119 --- /dev/null +++ b/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb @@ -0,0 +1,1555 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9466a47a-b847-4d63-b323-ca996a0650b3", + "metadata": {}, + "source": [ + "# ClearWater-Riverine Demo 2: Coupling Transport to Water Quality Reactions with ClearWater-Modules\n", + "\n", + "**Objective**: Demonstrate a more complex scenario of coupled transport and reaction models in Sumwere Creek, using the [ClearWater-modules](https://github.com/EcohydrologyTeam/ClearWater-modules) to simulate heat exchange with the atmosphere.\n", + "\n", + "This second notebook builds on the introduction to using [ClearWater-riverine](https://github.com/EcohydrologyTeam/ClearWater-riverine) provided in demo notebook 1.\n", + "\n", + "## Background \n", + "This notebook couples Clearwater-riverine (transport) with Clearwater-modules (reactions) - specifically, the Temperature Simulation Model (TSM). The Temperature Simulation Module (TSM) is an essential component of ClearWater (Corps Library for Environmental Analysis and Restoration of Watersheds). TSM plays a crucial role in simulating and predicting water temperature within aquatic ecosystems. TSM utilizes a comprehensive energy balance approach to account for various factors contributing to heat inputs and outputs in the water environment. It considers both external forcing functions and heat exchanges occurring at the water surface and the sediment-water interface. The primary contributors to heat exchange at the water surface include shortwave solar radiation, longwave atmospheric radiation, heat conduction from the atmosphere to the water, and direct heat inputs. Conversely, the primary factors that remove heat from the system are longwave radiation emitted by the water, evaporation, and heat conduction from the water to the atmosphere. \n", + "The core principle behind TSM is the application of the laws of conservation of energy to compute water temperature. This means that the change in heat content of the water is directly related to changes in temperature, which, in turn, are influenced by various heat flux components. The specific heat of water is employed to establish this relationship. Each term of the heat flux equation can be calculated based on the input provided by the user, allowing for flexibility in modeling different environmental conditions\n", + "\n", + "## Example Case Study\n", + "\n", + "This example shows how to run Clearwater Riverine coupled with Clearwater Modules in a fictional location, \"Sumwere Creek\" (shown below). The flow field for Sumwere Creek comes from a HEC-RAS 2D model, which has a domain of 200x200 meters and a base mesh of 10x10 meters. \n", + "\n", + "![image.png](../docs/imgs/SumwereCreek_coarse.png)\n", + "\n", + "The upstream boundary for Sumwere Creek is at the top left of the model domain, flowing into the domain at a constant 3 cms. At the first bend in the creek, there is an additional boundary representing a spring-fed tributary to the creek (1 cms). Further downstream, there is a meander in the stream forming a slow-flowing oxbow lake. There is another boundary flowing into that oxbow lake, representing a powerplant discharge (0.5 cms). \n", + "\n", + "The downstream boundary is a constant stage set at 20.75 The upstream inflows have a water temperature of 15 degrees C; the spring-fed creek has constant inflows of 5 C, and the powerplant is steady at 20 C with periodic higher temperature (25 C) discharges in a downstream meander. \n", + "\n", + "We simulate this scenario over the course of two full days, using meteorological parameters from Arizona (extreme temperature swings between night and day) to help show off the impacts of TSM.\n", + "\n", + "### Data Availability\n", + "All data required run this notebook is available at this [Google Drive](https://drive.google.com/drive/folders/1I_di8WrK95QwBga-W8iuJaJJMZsnIYSS?usp=drive_link). Please download the entire folder and place it in the `data_temp` folder of this repository to run the rest of the notebook." + ] + }, + { + "cell_type": "markdown", + "id": "f34af218-4b58-447d-907c-3fc89f057499", + "metadata": {}, + "source": [ + "## Model Set-Up\n", + "### General Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c280997b-7e02-4079-b8fe-707a0729ed86", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1009" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import logging\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "import holoviews as hv\n", + "import geoviews as gv\n", + "# from holoviews import opts\n", + "import panel as pn\n", + "hv.extension(\"bokeh\")" + ] + }, + { + "cell_type": "markdown", + "id": "baed1b6e-f756-4ca1-b959-4628ab2df47a", + "metadata": {}, + "source": [ + "### Import ClearWater-riverine\n", + "These steps require first completing **[Installation](https://github.com/EcohydrologyTeam/ClearWater-riverine?tab=readme-ov-file#installation)** of a [conda](https://conda.io/docs/) virtual environment customized for the ClearWater-riverine library." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "41338e34-2b59-4cd4-b6b3-a52f6edf7768", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('d:/Clearwater/ClearWater-riverine/examples')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Find project directory (i.e. the parent to `/examples` directory for this notebook)\n", + "project_path = Path.cwd().parent\n", + "project_path" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e2bcf299-c36b-432a-8e28-d1366d0b9c87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('d:/Clearwater/ClearWater-riverine/examples/src')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your source directory should be: \n", + "src_path = project_path / 'src'\n", + "src_path" + ] + }, + { + "cell_type": "markdown", + "id": "5cd020f2-ace9-4f32-a818-9a8716d21e53", + "metadata": {}, + "source": [ + "Next, we'll need to import Clearwater Riverine. While the package is still under development, the easiest way to do this is to use the [`conda develop`](https://docs.conda.io/projects/conda-build/en/latest/resources/commands/conda-develop.html) command in the console or terminal like this, replacing the `'/path/to/module/src'` with your specific path to the source directory. In other words:\n", + "- Copy from the output of `src_path` from the cell above, and \n", + "- Paste it after `!conda develop` in the cell below (replacing the previous user's path). \n", + "\n", + "NOTE: If your path has any blank spaces, you must enclose the path with quotes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9874c4fb-a442-46d9-a442-0df0f3cd01b3", + "metadata": {}, + "outputs": [], + "source": [ + "!conda develop '/Users/aaufdenkampe/Documents/Python/ClearWater-riverine/src'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d0676e2a-bdc9-4774-ab6c-c81927353da4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1011" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import clearwater_riverine as cwr" + ] + }, + { + "cell_type": "markdown", + "id": "66bddd72-10d7-42f1-ad02-b8cc1e9a4cbf", + "metadata": {}, + "source": [ + "### Import ClearWater-Modules" + ] + }, + { + "cell_type": "markdown", + "id": "e56f2ee1-c9f6-4517-8f77-57d34c387b74", + "metadata": {}, + "source": [ + "We will also need to install Clearwater Modules' `Energy Budget` module. While this package is also still under development, the best way to install is with `conda develop`. You will need to clone the [ClearWater Modules](https://github.com/EcohydrologyTeam/ClearWater-modules) repository. Then, use conda develop pointing to the path of your `clearwater-modules` folder like below.\n", + "\n", + "NOTE: You will need to find this path yourself. Remember that if your path has any blank spaces, you must enclose the path with quotes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d081f53f-f7ef-4edb-81f2-e9cbcfcfabe6", + "metadata": {}, + "outputs": [], + "source": [ + "!conda develop '/Users/aaufdenkampe/Documents/Python/ClearWater-modules/src'" + ] + }, + { + "cell_type": "markdown", + "id": "cd44e256", + "metadata": {}, + "source": [ + "You now need to restart the Python kernel for this notebook, if the path didn't already exist." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ec258d25-c3b2-4b7e-a511-40f65c6058bc", + "metadata": {}, + "outputs": [], + "source": [ + "from clearwater_modules.tsm.model import EnergyBudget" + ] + }, + { + "cell_type": "markdown", + "id": "fb9b46da-dde2-42ca-a156-4320b9b55ba3", + "metadata": {}, + "source": [ + "## Instantiate Models\n", + "### Clearwater-Riverine\n", + "\n", + "Ensure that you have followed the instructions in the Data Availability Section, and that you have all files downloaded in `examples/data_temp/sumwere_creek_coarse_p38`. For a more detailed explanation of all the steps in this process, please see [01_getting_started_riverine.ipynb](./01_getting_started_riverine.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ae2ef0cd-b448-405a-bfb7-ea69f4bd638f", + "metadata": {}, + "outputs": [], + "source": [ + "network_path = Path(r'W:\\2ERDC12 - Clearwater\\Clearwater_testing_TSM\\plan_48_simulation')\n", + "wetted_surface_area_path = network_path / \"wetted_surface_area.zarr\"\n", + "q_solar_path = network_path / 'cwr_boundary_conditions_q_solar_p28.csv'\n", + "air_temp_path = network_path / 'cwr_boundary_conditions_TairC_p28.csv'\n", + "config_file = network_path / 'demo_config.yml'" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c1f71478", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#flow_field_fpath.exists()\n", + "config_file.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f01b0796-d11e-4970-8ea3-85677f39df36", + "metadata": {}, + "outputs": [], + "source": [ + "start_index = 0*60*60 # start at 8:00 am on the first day of the simulation \n", + "end_index = start_index + 48*60*60 # end 48 hours later" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5695e2db-0cb8-4272-a7a9-7c0137415bd8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "CPU times: total: 438 ms\n", + "Wall time: 812 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_file,\n", + " verbose=True,\n", + " datetime_range= (start_index, end_index)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db156a72-7733-47c2-9d38-543ca559e498", + "metadata": {}, + "outputs": [], + "source": [ + "#%%time\n", + "#transport_model.initialize(\n", + "# initial_condition_path=initial_condition_path,\n", + "# boundary_condition_path=boundary_condition_path,\n", + "# units='degC',\n", + "#)" + ] + }, + { + "cell_type": "markdown", + "id": "dcfb43d5-07c5-4c4a-842c-438734b71767", + "metadata": {}, + "source": [ + "The Clearwater Riverine currently has the cell surface area, not the *wetted* cell surface area, as required for TSM. Ultimately, we will work on incorporating this calculation into Clearwater Riverine; however, for the sake of this example, we have the wetted surface areas saved in a zarr. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c0132f5a-2c31-4484-9680-44cb37407fd4", + "metadata": {}, + "outputs": [], + "source": [ + "wetted_sa = xr.open_zarr(wetted_surface_area_path)\n", + "wetted_sa = wetted_sa.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6365f6de-a977-4975-a4fb-ad1f2b2275d3", + "metadata": {}, + "outputs": [], + "source": [ + "wetted_sa_subset = wetted_sa.isel(time=slice(start_index, end_index+1))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a2846c4d-d26f-4ed4-b86e-6624aba1e696", + "metadata": {}, + "outputs": [], + "source": [ + "#transport_model.mesh['wetted_surface_area'] = wetted_sa_subset['wetted_surface_area']\n", + "\n", + "transport_model.mesh['wetted_surface_area'] = xr.DataArray(\n", + " wetted_sa_subset['wetted_surface_area'].values,\n", + " dims=('time', 'nface')\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "ef31e680-4792-4e1d-85b0-ab682dd36a53", + "metadata": {}, + "source": [ + "### Clearwater-Modules\n", + "\n", + "#### Initial State Values\n", + "The initial state values are `water_temp_c`, `volume`, and `surface_area` come from Clearwater-riverine mesh at the first timestep." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "befc95d9-663d-42f7-9f96-ec96821dcf40", + "metadata": {}, + "outputs": [], + "source": [ + "# Provide xr.data array values for initial state values\n", + "initial_state_values = {\n", + " 'water_temp_c': transport_model.mesh['temperature'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'volume': transport_model.mesh['volume'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'surface_area': transport_model.mesh['wetted_surface_area'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal + 1)\n", + " ),\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "738c906c-2143-404a-982c-cba751248fc1", + "metadata": {}, + "source": [ + "#### Meteorological Parameters\n", + "The meteorological parameters that we'll be adjusting for this model are `q_solar` and `air_temp_c`. In this example, `q_solar` and `air_temp_c` are pulled from meteorological stations in Arizona. \n", + "We will need to interpolate these datasets to our model timestep, using the following function:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "3d319864-884e-40db-9a85-93f56c87ba53", + "metadata": {}, + "outputs": [], + "source": [ + "def interpolate_to_model_timestep(meteo_df, model_dates, col_name):\n", + " merged_df = pd.merge_asof(\n", + " pd.DataFrame({'time': model_dates}),\n", + " meteo_df,\n", + " left_on='time',\n", + " right_on='Datetime')\n", + " merged_df[col_name.lower()] = merged_df[col_name].interpolate(method='linear')\n", + " merged_df.drop(\n", + " columns=['Datetime', col_name],\n", + " inplace=True)\n", + " merged_df.rename(\n", + " columns={'time': 'Datetime'},\n", + " inplace=True,\n", + " )\n", + " return merged_df" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "abc09be6-f808-49bc-b6e9-dc2f792928d6", + "metadata": {}, + "outputs": [], + "source": [ + "xarray_time_index = pd.DatetimeIndex(\n", + " transport_model.mesh.time.values\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "48f7491a-25ee-48cb-8609-4c174ff53073", + "metadata": {}, + "source": [ + "Create timeseries of Q solar and Air Temperature aligned with the timestep of the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0145082a-c55b-43be-abd0-75647b5863bb", + "metadata": {}, + "outputs": [], + "source": [ + "# Q Solar\n", + "q_solar = pd.read_csv(\n", + " q_solar_path, \n", + " parse_dates=['Datetime'])\n", + "q_solar.dropna(axis=0, inplace=True)\n", + "\n", + "q_solar_interp = interpolate_to_model_timestep(\n", + " q_solar,\n", + " xarray_time_index,\n", + " 'q_Solar'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "2b0ba137-e173-442e-b2a9-0478e7adad33", + "metadata": {}, + "outputs": [], + "source": [ + "# Air Temperature\n", + "air_temp_c = pd.read_csv(\n", + " air_temp_path, \n", + " parse_dates=['Datetime'])\n", + "air_temp_c.dropna(axis=0, inplace=True)\n", + "\n", + "air_temp_c_interp = interpolate_to_model_timestep(\n", + " air_temp_c,\n", + " xarray_time_index,\n", + " 'TairC'\n", + ")\n", + "\n", + "air_temp_c_interp['air_temp_c'] = (air_temp_c_interp.tairc - 32)* (5/9)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0964e5b0-b9b4-4299-bfe5-2514eaf4b795", + "metadata": {}, + "outputs": [], + "source": [ + "# process for clearwater-modules input\n", + "q_solar_array = q_solar_interp.q_solar.to_numpy()\n", + "air_temp_array = air_temp_c_interp.air_temp_c.to_numpy()\n", + "\n", + "# for each individual timestep\n", + "all_meteo_params = {\n", + " 'q_solar': q_solar_array,\n", + " 'air_temp_c': air_temp_array,\n", + "}\n", + "\n", + "# for initial conditions\n", + "initial_meteo_params = {\n", + " 'air_temp_c': air_temp_array[0],\n", + " 'q_solar': q_solar_array[0],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "468dbf2a-5bc5-4186-b543-56e13ab4e34f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5761,)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.shape(air_temp_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "e832b78f-9599-4c10-bdfc-d0dc0b0b69ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5761\n", + "\n" + ] + } + ], + "source": [ + "p48_timeSteps = int(5761)\n", + "print(p48_timeSteps)\n", + "print(type(p48_timeSteps))" + ] + }, + { + "cell_type": "markdown", + "id": "782cbe25-8c4f-4a3b-a134-3507bf20f247", + "metadata": {}, + "source": [ + "#### Instantiate Clearwater Modules\n", + "We instantiate Clearwater Modules with the following:\n", + "* `initial_state_values` (required): our initial conditions of water temperature, cell volumes, and cell surface areas.\n", + "* `time_dim` (optional): the model timestep\n", + "* `meteo_parameters` (optional): intitial meteorological parameters. If not provided, all meteo parameters will fall to default values.\n", + "* `track_dynamic_variables` (optional): boolean indicating whether or not the user wants to track all intermediate information used in the calculations. We set this to `False` to save on memory.\n", + "* `use_sed_temp` (optional): boolean indicating whether to use the sediment temperature in TSM calculations. We opt to turn this off for simplicity.\n", + "* `updateable_static_variables` (optional): by default, the meteorological variables are static in TSM. If we want these to update over time, we must provide a list of variables that we want to be updateable as input when instantiating the model. " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "86b811c9-f20b-4d23-8af4-85cd2a7876b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing from dicts...\n", + "Model initialized from input dicts successfully!.\n" + ] + } + ], + "source": [ + "reaction_model = EnergyBudget(\n", + " time_steps=p48_timeSteps,\n", + " initial_state_values=initial_state_values,\n", + " updateable_static_variables=['air_temp_c', 'q_solar'],\n", + " meteo_parameters= initial_meteo_params,\n", + " use_sed_temp=False,\n", + " track_dynamic_variables=False, \n", + " time_dim='seconds'\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "0db37f39", + "metadata": {}, + "outputs": [], + "source": [ + "#this cell can be executed after the model has run\n", + "#reaction_model.dataset.q_solar.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac09bc56", + "metadata": {}, + "outputs": [], + "source": [ + "#this cell can be executed after the model has run\n", + "#reaction_model.dataset.air_temp_c.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef180547", + "metadata": {}, + "outputs": [], + "source": [ + "#this cell can be executed after the model has run\n", + "#reaction_model.dataset.surface_area.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10c715fd", + "metadata": {}, + "outputs": [], + "source": [ + "#this cell can be executed after the model has run\n", + "#reaction_model.dataset.water_temp_c.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "2d2da52a-724d-46c7-9ed7-fda8bedfa6f3", + "metadata": {}, + "source": [ + "## Couple Models\n", + "Optionally, you can log output if you run for a long simulation to track progress." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "462f0a9e-7b70-4ae3-bb06-9e67ba4b80ca", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_function_logger(name):\n", + " logger = logging.getLogger('function_logger')\n", + " handler = logging.FileHandler(f'{name}.log')\n", + " formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n", + " handler.setFormatter(formatter)\n", + " logger.addHandler(handler)\n", + " logger.setLevel(logging.DEBUG) # Adjust the level based on your needs\n", + " return logger" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32e3aed0-8dad-4767-bd0f-2bfe5308b4fe", + "metadata": {}, + "outputs": [], + "source": [ + "def run_n_timesteps(\n", + " time_steps: int,\n", + " reaction: EnergyBudget,\n", + " transport: cwr.ClearwaterRiverine,\n", + " meteo_params: dict,\n", + " concentration_update = None,\n", + " logging = True,\n", + " log_file_name='log',\n", + "):\n", + " \"\"\"Function to couple Clearwater Riverine and Modules for n timesteps.\"\"\"\n", + "\n", + " # Set up logger\n", + " if logging:\n", + " logger = setup_function_logger(f'{log_file_name}')\n", + "\n", + " for i in range(1, time_steps):\n", + " if i % 5000 == 0:\n", + " status = {\n", + " 'timesteps': i,\n", + " 'cwr': transport.mesh.nbytes * 1e-9,\n", + " 'cwm': reaction.dataset.nbytes*1e-9,\n", + " }\n", + " if logging:\n", + " logger.debug(status)\n", + "\n", + " # Top of timestep: update transport model using values with output from reaction model, if available\n", + " transport.update(concentration_update)\n", + "\n", + " # Update state values\n", + " updated_state_values = {\n", + " 'water_temp_c': transport.mesh['temperature'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'volume': transport.mesh['volume'].isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal+1\n", + " )\n", + " ), \n", + " 'surface_area': transport.mesh['wetted_surface_area'].isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal+1)\n", + " ), \n", + " 'q_solar': transport.mesh.temperature.isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal + 1)\n", + " ) * 0 + meteo_params['q_solar'][i],\n", + " 'air_temp_c': transport.mesh.temperature.isel(\n", + " time=i, nface=slice(0, transport.mesh.nreal + 1)\n", + " ) * 0 + meteo_params['air_temp_c'][i],\n", + " }\n", + "\n", + " # Bottom of timestep: update energy budget (TSM)\n", + " reaction.increment_timestep(updated_state_values)\n", + "\n", + " # Prepare data for input back into Riverine\n", + " ds = reaction.dataset.copy()\n", + " ds['water_temp_c'] = ds['water_temp_c'].where(\n", + " ~np.isinf(ds['water_temp_c']),\n", + " transport.mesh['temperature'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['water_temp_c'] = ds['water_temp_c'].fillna(\n", + " transport.mesh['temperature'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + " concentration_update = {\"temperature\": ds.water_temp_c.isel(seconds=i)}\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28b35563-bf79-4be1-9c30-7d86b41d2e7e", + "metadata": {}, + "outputs": [], + "source": [ + "TIME_STEPS = 172800 # len(transport_model.mesh.time) - 60" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "408f2fbe-ffbd-4cfb-afa2-45df1a5526f2", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "run_n_timesteps(\n", + " TIME_STEPS,\n", + " reaction_model,\n", + " transport_model,\n", + " all_meteo_params,\n", + " logging=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ffec8b8-04e2-4a05-b835-f4f507bfeb7c", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(time=5000).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0c630a5-339a-495d-a2a0-91e4735869e5", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=217).plot()#, time=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5377d829", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=217, time=slice(21600, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eab93216", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=207, time=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57dd8774", + "metadata": {}, + "outputs": [], + "source": [ + "np.shape(transport_model.constituent_dict['temperature'].input_array)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eaa7b560-a7ba-4737-a9c3-bd090bc8a7d6", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=165, time=slice(1000, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "af441d7e-19d2-41a3-b7ff-6e0126993469", + "metadata": {}, + "source": [ + "## Plot Results" + ] + }, + { + "cell_type": "markdown", + "id": "793d31d6-9ef8-4692-bd58-981e3dee7fb1", + "metadata": {}, + "source": [ + "### Built-In Functions\n", + "Use the built-in plotting function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "440784b0-77a7-46fa-a73a-20b40ab2fd42", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.plot(\n", + " crs='EPSG:26916',\n", + " clim=(5, 26)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b6aadcb2-4186-4aac-a036-0f2c1e9978f6", + "metadata": {}, + "source": [ + "### Build Panel Apps\n", + "\n", + "#### Interactive Timeseries Plotting\n", + "This is an exmaple of an interactive map that allows you to click on a single cell and see the timeseries for that cell:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6dc19e97-9725-4f80-864b-2d034623314a", + "metadata": {}, + "outputs": [], + "source": [ + "from clearwater_riverine.variables import (\n", + " NUMBER_OF_REAL_CELLS,\n", + " CONCENTRATION,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cae6e61-9877-447d-bece-7b7dacfd3851", + "metadata": {}, + "outputs": [], + "source": [ + "# create inputs for panel app\n", + "ds = transport_model.mesh\n", + "gdf = transport_model.gdf\n", + "time_index = 60\n", + "mn_val = 4\n", + "mval = 25\n", + "date_value = ds.time.isel(time=time_index).values" + ] + }, + { + "cell_type": "markdown", + "id": "374633ff-30cf-48a3-b5c3-6bc73d690f88", + "metadata": {}, + "source": [ + "Start by creating a base map of a plan view of Sumwere Creek using the `geoviews` library. Including the `hover` and `tap` tools allows users to hover over the plot to see values and turns on the ability to use the tap stream that allows users to click on a cell and receive feedback from that tap. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95fb690b", + "metadata": {}, + "outputs": [], + "source": [ + "ras_sub_df = gdf[(gdf.datetime == date_value) & (gdf.concentration != 0)]\n", + "units = ds[CONCENTRATION].Units\n", + "ras_map = gv.Polygons(\n", + " ras_sub_df,\n", + " vdims=['concentration', 'cell']).opts(\n", + " height = 800,\n", + " width = 800,\n", + " color='concentration',\n", + " cmap='RdYlBu_r',\n", + " line_width = 0.1,\n", + " tools = ['hover', 'tap'],\n", + " clabel = f\"Concentration ({units})\",\n", + " xaxis=None,\n", + " yaxis=None,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "10c064e1-58d7-44b5-90a5-e914f50a1e88", + "metadata": {}, + "source": [ + "The cell below defines the tap stream and initializes an empty list of plots to display. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5b8a690", + "metadata": {}, + "outputs": [], + "source": [ + "tap_stream = hv.streams.Tap(source=ras_map, x=None, y=None)\n", + "plots = []" + ] + }, + { + "cell_type": "markdown", + "id": "086f5ae1-61c9-43ec-8dd7-3d97233ca903", + "metadata": {}, + "source": [ + "The `tap_plot` function identifies which cell has been clicked and generates a timeseries plot for that cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b2c8431-06e6-44ca-8f5a-6f2ffae4f51b", + "metadata": {}, + "outputs": [], + "source": [ + "def tap_plot(x, y):\n", + " # filter data\n", + " clicked_data = ras_sub_df.cx[x:x, y:y]\n", + " if x != None and y != None:\n", + " # identify cell number and pull concentration timeseries for that cell\n", + " cell = clicked_data['cell'].iloc[0]\n", + " cs = ds.concentration.isel(nface=cell, time=slice(0, TIME_STEPS))\n", + "\n", + " # Create timeseries plot\n", + " curve = hv.Curve(\n", + " cs,\n", + " ).opts(\n", + " title=f'Time series',\n", + " height=800,\n", + " width=800,\n", + " line_width=5,\n", + " fontsize= {'title': 18, 'labels': 16, 'xticks': 12, 'yticks': 12},\n", + " ylabel= 'Water Temperature (C)'\n", + " )\n", + "\n", + " # Append to list of plots (allows multiple lines to appear at the same time)\n", + " plots.append(curve)\n", + " # Return an overlay of all the plots\n", + " return hv.Overlay(plots).opts(legend_position='right')\n", + " else:\n", + " # Create an empty timeseries plot telling users to click on a cell to generate a timeseries\n", + " xs = np.linspace(-5,5,100)\n", + " empty_curve = hv.Curve((xs,-(xs-2)**2)).opts(\n", + " title=f'Time series',\n", + " line_color='white',\n", + " height=800, \n", + " width=800,\n", + " xaxis=None,\n", + " yaxis=None,\n", + " )* hv.Text(0, -20, \"Please click a cell on the map to display a timeseries.\")\n", + " return empty_curve\n", + "\n", + "# Create Dynamic Map that references the tap stream.\n", + "tap_dmap = hv.DynamicMap(tap_plot, streams=[tap_stream])" + ] + }, + { + "cell_type": "markdown", + "id": "6d3d9114-6daa-486f-beaf-629e7f06911c", + "metadata": {}, + "source": [ + "The following function and button allows users to clear all timeseries plots if they wish to start fresh:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf70743d", + "metadata": {}, + "outputs": [], + "source": [ + "def reset_tap_stream(event):\n", + " global plots\n", + " tap_stream.event(x=None, y=None)\n", + " plots = []\n", + " \n", + "button = pn.widgets.Button(name='Reset', button_type='primary')\n", + "button.on_click(reset_tap_stream)" + ] + }, + { + "cell_type": "markdown", + "id": "1bea5541-de92-4f29-86ab-e0d8df1f7167", + "metadata": {}, + "source": [ + "Now display the plot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c1661ac-e670-4752-ae8f-8889bf81288a", + "metadata": {}, + "outputs": [], + "source": [ + "layout = pn.Row(\n", + " ras_map,\n", + " tap_dmap.opts(\n", + " hv.opts.Curve(framewise=True, yaxis='right'),\n", + " ),\n", + " button\n", + " )\n", + "layout.servable()" + ] + }, + { + "cell_type": "markdown", + "id": "38a9609e-9090-413b-bbd3-b9fd0017f1cf", + "metadata": {}, + "source": [ + "#### Dynamic Map Visualization\n", + "Make a plot with a scrubber bar that shows a map over time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8fbb429e-0939-4513-9f35-a893f22f109c", + "metadata": {}, + "outputs": [], + "source": [ + "ds = transport_model.mesh\n", + "gdf = transport_model.gdf\n", + "import hvplot.pandas " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d7bb0cb-32fd-4f96-916d-a084e60e4e6a", + "metadata": {}, + "outputs": [], + "source": [ + "# eliminate cells without any temperature\n", + "gdf_sub = gdf[gdf.concentration != 0]\n", + "gdf_subset = gdf_sub[(gdf_sub['datetime'] > '2022-05-13 08:00:00')]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7937eec0-e050-43ff-8a3c-57bbb72abfc0", + "metadata": {}, + "outputs": [], + "source": [ + "plot_to_save = gdf_subset.hvplot(\n", + " geo=True,\n", + " groupby=\"datetime\",\n", + " # z = 'concentration',\n", + " c = 'concentration', # minute_gdf_subset.concentration,\n", + " clim=(4, 25),\n", + " cmap='RdYlBu_r',\n", + " clabel='Water Temperature (C)',\n", + " line_width = 0.1,\n", + " height=700,\n", + " width=800,\n", + " widget_location='bottom',\n", + " line_color='white',\n", + " \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b62985fb-0876-4bf8-b79e-a5a30a8731f7", + "metadata": {}, + "outputs": [], + "source": [ + "plot_to_save" + ] + }, + { + "cell_type": "raw", + "id": "09061d44-666a-40fc-8388-8acc597b72d0", + "metadata": {}, + "source": [ + "plot_to_save.save(filename='data_temp/output.html', embed=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/dev_sandbox/80_debug_constituents_linking_to_TSM b/examples/dev_sandbox/80_debug_constituents_linking_to_TSM new file mode 100644 index 0000000..ec92a6e --- /dev/null +++ b/examples/dev_sandbox/80_debug_constituents_linking_to_TSM @@ -0,0 +1,34 @@ +# import modules +from pathlib import Path +import os +import pandas as pd +import xarray as xr +import clearwater_riverine as cwr + + +#point to config +dir_str = os.path.abspath("") +dir = Path(dir_str) +dir_sandbox = dir / "examples" / "dev_sandbox" +config_filepath = dir_sandbox / "demo_config.yml" +print(dir) +print(config_filepath) +print(config_filepath.exists()) + + +#setup model +transport_model = cwr.ClearwaterRiverine( + config_filepath=config_filepath, + verbose=True, +) + + +#make an array the shape of the temp array with 5,000 everywhere +arbitrary_values_tracer = xr.full_like(transport_model.mesh.conservative_tracer, 200) +print(arbitrary_values_tracer) +arbitrary_values_temp = xr.full_like(transport_model.mesh.temperature, 5000) +update_concentration = {'conservative_tracer':arbitrary_values_tracer.isel(time=1), + 'temperature': arbitrary_values_temp.isel(time=1)} + +transport_model.update(update_concentration) + diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 5cbe965..6511235 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -189,9 +189,9 @@ def update( for constituent_name, constituent in self.constituent_dict.items(): # Allow users to override concentration - if isinstance(update_concentration, dict) and constituent in update_concentration.keys(): + if isinstance(update_concentration, dict) and constituent_name in update_concentration.keys(): self.mesh[constituent_name][self.time_step][0: self.mesh.nreal + 1] = \ - update_concentration[constituent_name].values[0:self.mesh.nreal + 1] + update_concentration[constituent_name].values[0:self.mesh.nreal + 1] x = update_concentration[constituent_name].values[0:self.mesh.nreal + 1] else: x = self.mesh[constituent_name][self.time_step][0:self.mesh.nreal + 1] From 55ff5bb1c8dba84f1b44615c6b423ecaab82604c Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Thu, 20 Jun 2024 16:54:11 -0400 Subject: [PATCH 22/41] notebook updated with plots after coupled model ran notebook updated with plots after coupled model ran --- ...e_modules_updated_(scaled)_crs_30sec.ipynb | 288 ++++++++++++++++-- 1 file changed, 260 insertions(+), 28 deletions(-) diff --git a/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb b/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb index c1ec119..0a42dd2 100644 --- a/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb +++ b/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb @@ -994,35 +994,130 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 48, + "id": "1d2e2db1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#this cell can be executed after the model has run\n", + "reaction_model.dataset.water_temp_c.isel(nface=216, seconds=slice(1000, 2000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, "id": "0db37f39", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "#this cell can be executed after the model has run\n", - "#reaction_model.dataset.q_solar.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + "reaction_model.dataset.q_solar.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "id": "ac09bc56", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "#this cell can be executed after the model has run\n", - "#reaction_model.dataset.air_temp_c.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + "reaction_model.dataset.air_temp_c.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "id": "ef180547", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "#this cell can be executed after the model has run\n", - "#reaction_model.dataset.surface_area.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" + "reaction_model.dataset.surface_area.isel(nface=216, seconds=slice(0, TIME_STEPS)).plot()" ] }, { @@ -1047,7 +1142,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "462f0a9e-7b70-4ae3-bb06-9e67ba4b80ca", "metadata": {}, "outputs": [], @@ -1064,7 +1159,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "32e3aed0-8dad-4767-bd0f-2bfe5308b4fe", "metadata": {}, "outputs": [], @@ -1144,20 +1239,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "28b35563-bf79-4be1-9c30-7d86b41d2e7e", "metadata": {}, "outputs": [], "source": [ - "TIME_STEPS = 172800 # len(transport_model.mesh.time) - 60" + "TIME_STEPS = 5760 # len(transport_model.mesh.time) - 60" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "408f2fbe-ffbd-4cfb-afa2-45df1a5526f2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "IndexError", + "evalue": "index 5761 is out of bounds for axis 0 with size 5761", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", + "File \u001b[1;32m:1\u001b[0m\n", + "Cell \u001b[1;32mIn[34], line 27\u001b[0m, in \u001b[0;36mrun_n_timesteps\u001b[1;34m(time_steps, reaction, transport, meteo_params, concentration_update, logging, log_file_name)\u001b[0m\n\u001b[0;32m 24\u001b[0m logger\u001b[38;5;241m.\u001b[39mdebug(status)\n\u001b[0;32m 26\u001b[0m \u001b[38;5;66;03m# Top of timestep: update transport model using values with output from reaction model, if available\u001b[39;00m\n\u001b[1;32m---> 27\u001b[0m \u001b[43mtransport\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconcentration_update\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 29\u001b[0m \u001b[38;5;66;03m# Update state values\u001b[39;00m\n\u001b[0;32m 30\u001b[0m updated_state_values \u001b[38;5;241m=\u001b[39m {\n\u001b[0;32m 31\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mwater_temp_c\u001b[39m\u001b[38;5;124m'\u001b[39m: transport\u001b[38;5;241m.\u001b[39mmesh[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtemperature\u001b[39m\u001b[38;5;124m'\u001b[39m]\u001b[38;5;241m.\u001b[39misel(\n\u001b[0;32m 32\u001b[0m time\u001b[38;5;241m=\u001b[39mi,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 50\u001b[0m ) \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;241m+\u001b[39m meteo_params[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mair_temp_c\u001b[39m\u001b[38;5;124m'\u001b[39m][i],\n\u001b[0;32m 51\u001b[0m }\n", + "File \u001b[1;32mD:\\Clearwater\\ClearWater-riverine\\src\\clearwater_riverine\\transport.py:179\u001b[0m, in \u001b[0;36mClearwaterRiverine.update\u001b[1;34m(self, update_concentration)\u001b[0m\n\u001b[0;32m 175\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Update a single timestep.\"\"\"\u001b[39;00m\n\u001b[0;32m 177\u001b[0m \u001b[38;5;66;03m# Update the left hand side of the matrix\u001b[39;00m\n\u001b[0;32m 178\u001b[0m \u001b[38;5;66;03m# This is the same for all constituents\u001b[39;00m\n\u001b[1;32m--> 179\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlhs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_values\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 180\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmesh\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 181\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtime_step\u001b[49m\n\u001b[0;32m 182\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 184\u001b[0m \u001b[38;5;66;03m# Define compressed sparse row matrix for LHS\u001b[39;00m\n\u001b[0;32m 185\u001b[0m A \u001b[38;5;241m=\u001b[39m csr_matrix(\n\u001b[0;32m 186\u001b[0m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlhs\u001b[38;5;241m.\u001b[39mcoef, (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlhs\u001b[38;5;241m.\u001b[39mrows, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlhs\u001b[38;5;241m.\u001b[39mcols)),\n\u001b[0;32m 187\u001b[0m shape\u001b[38;5;241m=\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmesh\u001b[38;5;241m.\u001b[39mnreal \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmesh\u001b[38;5;241m.\u001b[39mnreal \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m 188\u001b[0m )\n", + "File \u001b[1;32mD:\\Clearwater\\ClearWater-riverine\\src\\clearwater_riverine\\linalg.py:66\u001b[0m, in \u001b[0;36mLHS.update_values\u001b[1;34m(self, mesh, t)\u001b[0m\n\u001b[0;32m 62\u001b[0m flow_out_indices_internal \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere((mesh[ADVECTION_COEFFICIENT][t] \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m&\u001b[39m \\\n\u001b[0;32m 63\u001b[0m (np\u001b[38;5;241m.\u001b[39misin(mesh\u001b[38;5;241m.\u001b[39mnedge, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minternal_edges)))[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m 64\u001b[0m flow_in_indices \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere((mesh[ADVECTION_COEFFICIENT][t] \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m&\u001b[39m \\\n\u001b[0;32m 65\u001b[0m (np\u001b[38;5;241m.\u001b[39misin(mesh\u001b[38;5;241m.\u001b[39mnedge, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minternal_edges)))[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m---> 66\u001b[0m empty_cells \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mwhere(\u001b[43mmesh\u001b[49m\u001b[43m[\u001b[49m\u001b[43mVOLUME\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[43mt\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m)[\u001b[38;5;241m0\u001b[39m][\u001b[38;5;241m0\u001b[39m:\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnreal_count]\n\u001b[0;32m 68\u001b[0m \u001b[38;5;66;03m# initialize arrays that will define the sparse matrix \u001b[39;00m\n\u001b[0;32m 69\u001b[0m len_val \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minternal_edge_count \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnreal_count \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \\\n\u001b[0;32m 70\u001b[0m \u001b[38;5;28mlen\u001b[39m(flow_out_indices)\u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(flow_in_indices)\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(empty_cells) \u001b[38;5;241m+\u001b[39m \\\n\u001b[0;32m 71\u001b[0m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreal_edges_face1) \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreal_edges_face2)\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\dataarray.py:875\u001b[0m, in \u001b[0;36mDataArray.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 872\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_coord(key)\n\u001b[0;32m 873\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m 874\u001b[0m \u001b[38;5;66;03m# xarray-style array indexing\u001b[39;00m\n\u001b[1;32m--> 875\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_item_key_to_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\dataarray.py:1508\u001b[0m, in \u001b[0;36mDataArray.isel\u001b[1;34m(self, indexers, drop, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[0;32m 1503\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_from_temp_dataset(ds)\n\u001b[0;32m 1505\u001b[0m \u001b[38;5;66;03m# Much faster algorithm for when all indexers are ints, slices, one-dimensional\u001b[39;00m\n\u001b[0;32m 1506\u001b[0m \u001b[38;5;66;03m# lists, or zero or one-dimensional np.ndarray's\u001b[39;00m\n\u001b[1;32m-> 1508\u001b[0m variable \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43misel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexers\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmissing_dims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmissing_dims\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1509\u001b[0m indexes, index_variables \u001b[38;5;241m=\u001b[39m isel_indexes(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mxindexes, indexers)\n\u001b[0;32m 1511\u001b[0m coords \u001b[38;5;241m=\u001b[39m {}\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\variable.py:1033\u001b[0m, in \u001b[0;36mVariable.isel\u001b[1;34m(self, indexers, missing_dims, **indexers_kwargs)\u001b[0m\n\u001b[0;32m 1030\u001b[0m indexers \u001b[38;5;241m=\u001b[39m drop_dims_from_indexers(indexers, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims, missing_dims)\n\u001b[0;32m 1032\u001b[0m key \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(indexers\u001b[38;5;241m.\u001b[39mget(dim, \u001b[38;5;28mslice\u001b[39m(\u001b[38;5;28;01mNone\u001b[39;00m)) \u001b[38;5;28;01mfor\u001b[39;00m dim \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdims)\n\u001b[1;32m-> 1033\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\variable.py:800\u001b[0m, in \u001b[0;36mVariable.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m 797\u001b[0m dims, indexer, new_order \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_broadcast_indexes(key)\n\u001b[0;32m 798\u001b[0m indexable \u001b[38;5;241m=\u001b[39m as_indexable(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data)\n\u001b[1;32m--> 800\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mindexing\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mapply_indexer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindexable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindexer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 802\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_order:\n\u001b[0;32m 803\u001b[0m data \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mmoveaxis(data, \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(new_order)), new_order)\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\indexing.py:1026\u001b[0m, in \u001b[0;36mapply_indexer\u001b[1;34m(indexable, indexer)\u001b[0m\n\u001b[0;32m 1024\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m indexable\u001b[38;5;241m.\u001b[39moindex[indexer]\n\u001b[0;32m 1025\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mindexable\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindexer\u001b[49m\u001b[43m]\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\rushmore\\AppData\\Local\\miniconda3\\envs\\clearwater_riverine\\Lib\\site-packages\\xarray\\core\\indexing.py:1515\u001b[0m, in \u001b[0;36mNumpyIndexingAdapter.__getitem__\u001b[1;34m(self, indexer)\u001b[0m\n\u001b[0;32m 1511\u001b[0m \u001b[38;5;66;03m# We want 0d slices rather than scalars. This is achieved by\u001b[39;00m\n\u001b[0;32m 1512\u001b[0m \u001b[38;5;66;03m# appending an ellipsis (see\u001b[39;00m\n\u001b[0;32m 1513\u001b[0m \u001b[38;5;66;03m# https://numpy.org/doc/stable/reference/arrays.indexing.html#detailed-notes).\u001b[39;00m\n\u001b[0;32m 1514\u001b[0m key \u001b[38;5;241m=\u001b[39m indexer\u001b[38;5;241m.\u001b[39mtuple \u001b[38;5;241m+\u001b[39m (\u001b[38;5;28mEllipsis\u001b[39m,)\n\u001b[1;32m-> 1515\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43marray\u001b[49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n", + "\u001b[1;31mIndexError\u001b[0m: index 5761 is out of bounds for axis 0 with size 5761" + ] + } + ], "source": [ "%%time\n", "run_n_timesteps(\n", @@ -1171,60 +1287,176 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "1ffec8b8-04e2-4a05-b835-f4f507bfeb7c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "transport_model.mesh.temperature.isel(time=5000).plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "id": "d0c630a5-339a-495d-a2a0-91e4735869e5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "transport_model.mesh.temperature.isel(nface=217).plot()#, time=slice(0, TIME_STEPS)).plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "id": "5377d829", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "transport_model.mesh.temperature.isel(nface=217, time=slice(21600, TIME_STEPS)).plot()" + "transport_model.mesh.temperature.isel(nface=217, time=slice(100, TIME_STEPS)).plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "eab93216", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "transport_model.mesh.temperature.isel(nface=207, time=slice(0, TIME_STEPS)).plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "57dd8774", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(5761, 444)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "np.shape(transport_model.constituent_dict['temperature'].input_array)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "id": "eaa7b560-a7ba-4737-a9c3-bd090bc8a7d6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "transport_model.mesh.temperature.isel(nface=165, time=slice(1000, TIME_STEPS)).plot()" ] From f4c6c4dc24b5b4b8b5fde0c7c3c2ef4d9dfc9ee7 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 20 Jun 2024 20:32:53 -0500 Subject: [PATCH 23/41] signature apparent in Riverine here @jrutyna. I'm not quite sure what fixed it but it looks like it's running correctly for me now. That discontinuity doesn't appear and I see the daily TSM signature in the riverine mesh. Can you try running this again and seeing if you get the same? --- ...e_modules_updated_(scaled)_crs_30sec.ipynb | 540 ++++++++++-------- 1 file changed, 307 insertions(+), 233 deletions(-) diff --git a/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb b/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb index 0a42dd2..606bb6a 100644 --- a/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb +++ b/examples/dev_sandbox/02_coupling_riverine_modules_updated_(scaled)_crs_30sec.ipynb @@ -48,7 +48,7 @@ "outputs": [ { "data": { - "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", "application/vnd.holoviews_load.v0+json": "" }, "metadata": {}, @@ -90,17 +90,18 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1005" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import clearwater_riverine as cwr" + ] + }, + { + "cell_type": "markdown", + "id": "fb9b46da-dde2-42ca-a156-4320b9b55ba3", + "metadata": {}, + "source": [ + "## Instantiate Model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ae2ef0cd-b448-405a-bfb7-ea69f4bd638f", + "metadata": {}, + "outputs": [], + "source": [ + "network_path = Path(r'W:\\2ERDC12 - Clearwater\\Clearwater_testing_TSM\\plan_48_simulation')\n", + "wetted_surface_area_path = network_path / \"wetted_surface_area.zarr\"\n", + "q_solar_path = network_path / 'cwr_boundary_conditions_q_solar_p28.csv'\n", + "air_temp_path = network_path / 'cwr_boundary_conditions_TairC_p28.csv'\n", + "config_file = network_path / 'demo_config.yml'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c1f71478", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#flow_field_fpath.exists()\n", + "config_file.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8a8eb193", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 100\n" + ] + } + ], + "source": [ + "# test on 100 timesteps\n", + "start_index = 0 # int((8*60*60)/30)\n", + "end_index = 100\n", + "print(start_index, end_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "de6f3781", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "CPU times: total: 797 ms\n", + "Wall time: 7.87 s\n" + ] + } + ], + "source": [ + "%%time\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_file,\n", + " verbose=True,\n", + " datetime_range= (start_index, end_index)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "223320f8", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()" + ] + }, + { + "cell_type": "markdown", + "id": "edff52de", + "metadata": {}, + "source": [ + "## `plot`" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "29b3b443", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sjordan\\OneDrive - LimnoTech\\Documents\\GitHub\\ClearWater-riverine\\src\\clearwater_riverine\\transport.py:528: UserWarning: No constituent name defined. Plotting temperature.\n", + " warnings.warn(\n" + ] + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":DynamicMap [datetime]\n", + " :Overlay\n", + " .Polygons.I :Polygons [Longitude,Latitude] (temperature,cell)\n", + " .WMTS.I :WMTS [Longitude,Latitude]" + ] + }, + "execution_count": 7, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1007" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# all defaults\n", + "transport_model.plot(\n", + " crs='EPSG:26916',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3f837a3e", + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":DynamicMap [datetime]\n", + " :Overlay\n", + " .Polygons.I :Polygons [Longitude,Latitude] (volume,cell)\n", + " .WMTS.I :WMTS [Longitude,Latitude]" + ] + }, + "execution_count": 11, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p3249" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "transport_model.plot(\n", + " constituent_name='volume',\n", + " clim=(10, 25),\n", + " cmap='RdYlBu_r',\n", + " filter_empty = True,\n", + "\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "726bea30-b133-4083-b2fb-b8b1f30c7458", + "metadata": {}, + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + ":DynamicMap [datetime]\n", + " :Overlay\n", + " .Polygons.I :Polygons [Longitude,Latitude] (volume,cell)\n", + " .WMTS.I :WMTS [Longitude,Latitude]" + ] + }, + "execution_count": 12, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p3688" + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "# what woudl this look like if we don't filter empty cells?\n", + "transport_model.plot(\n", + " constituent_name='volume',\n", + " clim=(10, 25),\n", + " cmap='RdYlBu_r',\n", + " filter_empty = False,\n", + "\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "33979529-a08d-46fe-a6b8-391aec8a66ab", + "metadata": {}, + "source": [ + "## `static_plot`" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "90550172-946e-4d29-84ec-d4c03a59b05d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sjordan\\OneDrive - LimnoTech\\Documents\\GitHub\\ClearWater-riverine\\src\\clearwater_riverine\\transport.py:528: UserWarning: No constituent name defined. Plotting temperature.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f98639c1-3928-4ac2-a3d6-f4c6e55aa345", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/clearwater_riverine/transport.py b/src/clearwater_riverine/transport.py index 8634780..e96999d 100644 --- a/src/clearwater_riverine/transport.py +++ b/src/clearwater_riverine/transport.py @@ -26,7 +26,7 @@ EDGES_FACE2, CHANGE_IN_TIME, NUMBER_OF_REAL_CELLS, - CONCENTRATION + VOLUME, ) from clearwater_riverine.utilities import UnitConverter from clearwater_riverine.linalg import LHS, RHS @@ -103,12 +103,12 @@ def __init__( diffusion_coefficient_input = model_config['diffusion_coefficient'] if not flow_field_file_path: flow_field_file_path = model_config['flow_field_filepath'] - self.constituents = model_config['constituents'].keys() + self.constituents = list(model_config['constituents'].keys()) else: if flow_field_file_path: ## TODO: add some checking that input set up correctly if isinstance(constituent_dict, Dict): - self.constituents = constituent_dict.keys() + self.constituents = list(constituent_dict.keys()) model_config = {'constituents': constituent_dict} else: raise TypeError( @@ -340,14 +340,24 @@ def simulate_wq( # self.mesh.cwr.save_clearwater_xarray(output_file_path) print(' 100%') + + def set_value_range( + self, + constituent_name: Optional[str] = None + ): + """Set value ranges for constituents.""" + if constituent_name != None: + self.constituent_dict[constituent_name].set_value_range(self.mesh) + else: + for _, constituent in self.constituent_dict.items(): + constituent.set_value_range(self.mesh) def finalize( self, save: Optional[bool] = False, output_filepath: Optional[str] = None ): - for _, constituent in self.constituent_dict.items(): - constituent.set_value_range(self.mesh) + self.set_value_range() if save == True: self.mesh.cwr.save_clearwater_xarray(output_filepath) @@ -425,19 +435,29 @@ def _prep_gdf( def _update_gdf(self): """Update gdf values.""" self.plotting_time_step = self.time_step + constituent_dfs = [] + gdf_elements = self.constituents + [VOLUME] + for constituent in gdf_elements: + df_from_array = self.mesh[constituent].isel( + nface=slice(0,self.nreal_index) + ).to_dataframe() + df_from_array.reset_index(inplace=True) + constituent_dfs.append(df_from_array) + + all_constituents = pd.concat( + constituent_dfs, + axis=1, + ) + all_constituents = all_constituents.loc[:, ~all_constituents.columns.duplicated()] - df_from_array = self.mesh[[self.constituents]].isel( - nface=slice(0,self.nreal_index) - ).to_dataframe() - df_from_array.reset_index(inplace=True) self.df_merged = gpd.GeoDataFrame( - pd.merge( - df_from_array, - self.poly_gdf, - on='nface', - how='left' + pd.merge( + all_constituents, + self.poly_gdf, + on='nface', + how='left' + ) ) - ) self.df_merged.rename( columns={ 'nface':'cell', @@ -468,6 +488,8 @@ def _maximum_plotting_value( if clim_max != None: mx_val = clim_max else: + if self.constituent_dict[constituent_name].max_value == None: + self.set_value_range(constituent_name) mx_val = self.constituent_dict[constituent_name].max_value return mx_val @@ -491,6 +513,8 @@ def _minimum_plotting_value( if clim_min != None: mn_val = clim_min else: + if self.constituent_dict[constituent_name].min_value == None: + self.set_value_range(constituent_name) mn_val = self.constituent_dict[constituent_name].min_value return mn_val @@ -519,13 +543,14 @@ def _define_clims( constituent_name=constituent_name ) mn_val = self._minimum_plotting_value( - clim_max=clim[0], + clim_min=clim[0], constituent_name=constituent_name ) return mx_val, mn_val def _prep_plot( self, + constituent_name: str | None, clim: tuple, gdf_plot=False, crs: Optional[str] = None, @@ -556,7 +581,8 @@ def plot( crs: Optional[str] = None, clim: Optional[tuple] = (None, None), cmap: Optional[str] = 'OrRd', - time_index_range: Optional[tuple] = (0, -1) + time_index_range: Optional[tuple] = (0, -1), + filter_empty: Optional[bool] = True, ): """Creates a dynamic polygon plot of concentrations in the RAS2D model domain. @@ -569,10 +595,11 @@ def plot( clim_max (float, optional): maximum value for color bar. If not specifies, the default will be the maximum concentration value in the model domain over the entire simulation horizon. time_index_range (tuple, optional): minimum and maximum time index to plot. + filter_empty (boolean, optional): provides users the ability to filter out empty cells. """ constituent_name, mx_val, mn_val = self._prep_plot( - self, + constituent_name=constituent_name, clim=clim, gdf_plot=True, crs=crs, @@ -581,6 +608,8 @@ def plot( def map_generator(datetime): """This function generates plots for the DynamicMap""" ras_sub_df = self.gdf[self.gdf.datetime == datetime] + if filter_empty: + ras_sub_df = ras_sub_df[ras_sub_df[VOLUME] != 0] units = self.mesh[constituent_name].Units ras_map = gv.Polygons( ras_sub_df, @@ -615,7 +644,7 @@ def quick_plot( clim_max (float, optional): maximum value for color bar. """ constituent_name, mx_val, mn_val = self._prep_plot( - self, + constituent_name=constituent_name, clim=clim, ) @@ -691,7 +720,7 @@ def static_plot( """ constituent_name, mx_val, mn_val = self._prep_plot( - self, + constituent_name=constituent_name, clim=clim, gdf_plot=True, crs=crs, @@ -702,7 +731,7 @@ def static_plot( ).values c = self.gdf[ - (self.gdf.datetime == date_value) & (self.gdf.concentration !=0 ) + (self.gdf.datetime == date_value) & (self.gdf[VOLUME] != 0) ].plot( column=constituent_name, cmap=cmap, From 8692293e8980374f30f6add531df5a126b2b7c52 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Tue, 9 Jul 2024 09:08:41 -0500 Subject: [PATCH 30/41] update saving function so can save to netcdf --- .../dev_sandbox/constituents-dev-save.ipynb | 901 ++++++++++++++++++ src/clearwater_riverine/mesh.py | 4 +- 2 files changed, 904 insertions(+), 1 deletion(-) create mode 100644 examples/dev_sandbox/constituents-dev-save.ipynb diff --git a/examples/dev_sandbox/constituents-dev-save.ipynb b/examples/dev_sandbox/constituents-dev-save.ipynb new file mode 100644 index 0000000..bea956b --- /dev/null +++ b/examples/dev_sandbox/constituents-dev-save.ipynb @@ -0,0 +1,901 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9466a47a-b847-4d63-b323-ca996a0650b3", + "metadata": {}, + "source": [ + "# Save to netCDF" + ] + }, + { + "cell_type": "markdown", + "id": "f34af218-4b58-447d-907c-3fc89f057499", + "metadata": {}, + "source": [ + "## Model Set-Up\n", + "### General Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c280997b-7e02-4079-b8fe-707a0729ed86", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " var force = true;\n", + " var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n", + " var reloading = false;\n", + " var Bokeh = root.Bokeh;\n", + " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + "\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " if (!reloading) {\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error() {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " var skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n", + " require([\"jspanel\"], function(jsPanel) {\n", + "\twindow.jsPanel = jsPanel\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-modal\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-tooltip\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-hint\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-layout\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-contextmenu\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-dock\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"gridstack\"], function(GridStack) {\n", + "\twindow.GridStack = GridStack\n", + "\ton_load()\n", + " })\n", + " require([\"notyf\"], function() {\n", + "\ton_load()\n", + " })\n", + " root._bokeh_is_loading = css_urls.length + 9;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " var existing_stylesheets = []\n", + " var links = document.getElementsByTagName('link')\n", + " for (var i = 0; i < links.length; i++) {\n", + " var link = links[i]\n", + " if (link.href != null) {\n", + "\texisting_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (var i = 0; i < css_urls.length; i++) {\n", + " var url = css_urls[i];\n", + " if (existing_stylesheets.indexOf(url) !== -1) {\n", + "\ton_load()\n", + "\tcontinue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } var existing_scripts = []\n", + " var scripts = document.getElementsByTagName('script')\n", + " for (var i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + "\texisting_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (var i = 0; i < js_urls.length; i++) {\n", + " var url = js_urls[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (var i = 0; i < js_modules.length; i++) {\n", + " var url = js_modules[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " var url = js_exports[name];\n", + " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n", + " var js_modules = [];\n", + " var js_exports = {};\n", + " var css_urls = [];\n", + " var inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (var i = 0; i < inline_js.length; i++) {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + "\tvar NewBokeh = root.Bokeh;\n", + "\tif (Bokeh.versions === undefined) {\n", + "\t Bokeh.versions = new Map();\n", + "\t}\n", + "\tif (NewBokeh.version !== Bokeh.version) {\n", + "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + "\t}\n", + "\troot.Bokeh = Bokeh;\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " Bokeh = root.Bokeh;\n", + " bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " if (!reloading && (!bokeh_loaded || is_dev)) {\n", + "\troot.Bokeh = undefined;\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + "\trun_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1005" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import clearwater_riverine as cwr" + ] + }, + { + "cell_type": "markdown", + "id": "fb9b46da-dde2-42ca-a156-4320b9b55ba3", + "metadata": {}, + "source": [ + "## Instantiate Model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ae2ef0cd-b448-405a-bfb7-ea69f4bd638f", + "metadata": {}, + "outputs": [], + "source": [ + "network_path = Path(r'W:\\2ERDC12 - Clearwater\\Clearwater_testing_TSM\\plan_48_simulation')\n", + "wetted_surface_area_path = network_path / \"wetted_surface_area.zarr\"\n", + "q_solar_path = network_path / 'cwr_boundary_conditions_q_solar_p28.csv'\n", + "air_temp_path = network_path / 'cwr_boundary_conditions_TairC_p28.csv'\n", + "config_file = network_path / 'demo_config.yml'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c1f71478", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#flow_field_fpath.exists()\n", + "config_file.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8a8eb193", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 100\n" + ] + } + ], + "source": [ + "start_index = 0 # int((8*60*60)/30)\n", + "end_index = 100\n", + "print(start_index, end_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "de6f3781", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "CPU times: total: 1.09 s\n", + "Wall time: 49.4 s\n" + ] + } + ], + "source": [ + "%%time\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_file,\n", + " verbose=True,\n", + " datetime_range= (start_index, end_index)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "223320f8", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(len(transport_model.mesh.time) - 1):\n", + " transport_model.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "71b16fdb-1015-44d9-b692-a5ff6f332b8f", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.finalize(\n", + " save=True,\n", + " output_filepath='temp/test-output.nc'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b4c04b0-fc92-46dc-957d-d5e71c6e93d1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/clearwater_riverine/mesh.py b/src/clearwater_riverine/mesh.py index 42db188..35bc6e4 100644 --- a/src/clearwater_riverine/mesh.py +++ b/src/clearwater_riverine/mesh.py @@ -110,7 +110,9 @@ def save_clearwater_xarray(self, output_file_path: str) -> None: 'face_cell_indexes_df', 'face_volume_elevation_info', 'face_volume_elevation_values', - 'boundary_data']: + 'boundary_data', + 'volume_calculation_required', + 'face_area_calculation_required']: self._attempt_delete(key) # write output From 84d5061c31ee993425cb36a62cc47bae409c9f4b Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Wed, 24 Jul 2024 15:08:34 -0400 Subject: [PATCH 31/41] Coupling riverine to NSM1 is working! --- .../04_coupling_riverine_NSM_modules.ipynb | 37992 ++++++++++++++++ examples/dev_sandbox/debug_linking_to_NSM1.py | 485 + 2 files changed, 38477 insertions(+) create mode 100644 examples/04_coupling_riverine_NSM_modules.ipynb create mode 100644 examples/dev_sandbox/debug_linking_to_NSM1.py diff --git a/examples/04_coupling_riverine_NSM_modules.ipynb b/examples/04_coupling_riverine_NSM_modules.ipynb new file mode 100644 index 0000000..7a3d710 --- /dev/null +++ b/examples/04_coupling_riverine_NSM_modules.ipynb @@ -0,0 +1,37992 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9466a47a-b847-4d63-b323-ca996a0650b3", + "metadata": {}, + "source": [ + "# ClearWater-Riverine Demo 2: Coupling Transport to Water Quality Reactions with ClearWater-Modules\n", + "\n", + "**Objective**: Demonstrate a more complex scenario of coupled transport and reaction models in Sumwere Creek, using the [ClearWater-modules](https://github.com/EcohydrologyTeam/ClearWater-modules) to simulate heat exchange with the atmosphere.\n", + "\n", + "This second notebook builds on the introduction to using [ClearWater-riverine](https://github.com/EcohydrologyTeam/ClearWater-riverine) provided in demo notebook 1.\n", + "\n", + "## Background \n", + "This notebook couples Clearwater-riverine (transport) with Clearwater-modules (reactions) - specifically, the Temperature Simulation Model (TSM). The Temperature Simulation Module (TSM) is an essential component of ClearWater (Corps Library for Environmental Analysis and Restoration of Watersheds). TSM plays a crucial role in simulating and predicting water temperature within aquatic ecosystems. TSM utilizes a comprehensive energy balance approach to account for various factors contributing to heat inputs and outputs in the water environment. It considers both external forcing functions and heat exchanges occurring at the water surface and the sediment-water interface. The primary contributors to heat exchange at the water surface include shortwave solar radiation, longwave atmospheric radiation, heat conduction from the atmosphere to the water, and direct heat inputs. Conversely, the primary factors that remove heat from the system are longwave radiation emitted by the water, evaporation, and heat conduction from the water to the atmosphere. \n", + "The core principle behind TSM is the application of the laws of conservation of energy to compute water temperature. This means that the change in heat content of the water is directly related to changes in temperature, which, in turn, are influenced by various heat flux components. The specific heat of water is employed to establish this relationship. Each term of the heat flux equation can be calculated based on the input provided by the user, allowing for flexibility in modeling different environmental conditions\n", + "\n", + "## Example Case Study\n", + "\n", + "This example shows how to run Clearwater Riverine coupled with Clearwater Modules in a fictional location, \"Sumwere Creek\" (shown below). The flow field for Sumwere Creek comes from a HEC-RAS 2D model, which has a domain of 200x200 meters and a base mesh of 10x10 meters. \n", + "\n", + "![image.png](../docs/imgs/SumwereCreek_coarse.png)\n", + "\n", + "The upstream boundary for Sumwere Creek is at the top left of the model domain, flowing into the domain at a constant 3 cms. At the first bend in the creek, there is an additional boundary representing a spring-fed tributary to the creek (1 cms). Further downstream, there is a meander in the stream forming a slow-flowing oxbow lake. There is another boundary flowing into that oxbow lake, representing a powerplant discharge (0.5 cms). \n", + "\n", + "The downstream boundary is a constant stage set at 20.75 The upstream inflows have a water temperature of 15 degrees C; the spring-fed creek has constant inflows of 5 C, and the powerplant is steady at 20 C with periodic higher temperature (25 C) discharges in a downstream meander. \n", + "\n", + "We simulate this scenario over the course of two full days, using meteorological parameters from Arizona (extreme temperature swings between night and day) to help show off the impacts of TSM.\n", + "\n", + "### Data Availability\n", + "All data required run this notebook is available at this [Google Drive](https://drive.google.com/drive/folders/1I_di8WrK95QwBga-W8iuJaJJMZsnIYSS?usp=drive_link). Please download the entire folder and place it in the `data_temp` folder of this repository to run the rest of the notebook." + ] + }, + { + "cell_type": "markdown", + "id": "f34af218-4b58-447d-907c-3fc89f057499", + "metadata": {}, + "source": [ + "## Model Set-Up\n", + "### General Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c280997b-7e02-4079-b8fe-707a0729ed86", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1009" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import logging\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "import holoviews as hv\n", + "import geoviews as gv\n", + "# from holoviews import opts\n", + "import panel as pn\n", + "hv.extension(\"bokeh\")" + ] + }, + { + "cell_type": "markdown", + "id": "baed1b6e-f756-4ca1-b959-4628ab2df47a", + "metadata": {}, + "source": [ + "### Import ClearWater-riverine\n", + "These steps require first completing **[Installation](https://github.com/EcohydrologyTeam/ClearWater-riverine?tab=readme-ov-file#installation)** of a [conda](https://conda.io/docs/) virtual environment customized for the ClearWater-riverine library." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "41338e34-2b59-4cd4-b6b3-a52f6edf7768", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('d:/Clearwater/ClearWater-riverine')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Find project directory (i.e. the parent to `/examples` directory for this notebook)\n", + "project_path = Path.cwd().parent\n", + "project_path" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e2bcf299-c36b-432a-8e28-d1366d0b9c87", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "WindowsPath('d:/Clearwater/ClearWater-riverine/src')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your source directory should be: \n", + "src_path = project_path / 'src'\n", + "src_path" + ] + }, + { + "cell_type": "markdown", + "id": "5cd020f2-ace9-4f32-a818-9a8716d21e53", + "metadata": {}, + "source": [ + "Next, we'll need to import Clearwater Riverine. While the package is still under development, the easiest way to do this is to use the [`conda develop`](https://docs.conda.io/projects/conda-build/en/latest/resources/commands/conda-develop.html) command in the console or terminal like this, replacing the `'/path/to/module/src'` with your specific path to the source directory. In other words:\n", + "- Copy from the output of `src_path` from the cell above, and \n", + "- Paste it after `!conda develop` in the cell below (replacing the previous user's path). \n", + "\n", + "NOTE: If your path has any blank spaces, you must enclose the path with quotes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9874c4fb-a442-46d9-a442-0df0f3cd01b3", + "metadata": {}, + "outputs": [], + "source": [ + "!conda develop '/Users/aaufdenkampe/Documents/Python/ClearWater-riverine/src'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d0676e2a-bdc9-4774-ab6c-c81927353da4", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", + "application/vnd.holoviews_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ] + }, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1011" + } + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "\n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "
\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import clearwater_riverine as cwr" + ] + }, + { + "cell_type": "markdown", + "id": "66bddd72-10d7-42f1-ad02-b8cc1e9a4cbf", + "metadata": {}, + "source": [ + "### Import ClearWater-Modules" + ] + }, + { + "cell_type": "markdown", + "id": "e56f2ee1-c9f6-4517-8f77-57d34c387b74", + "metadata": {}, + "source": [ + "We will also need to install Clearwater Modules' `Energy Budget` module. While this package is also still under development, the best way to install is with `conda develop`. You will need to clone the [ClearWater Modules](https://github.com/EcohydrologyTeam/ClearWater-modules) repository. Then, use conda develop pointing to the path of your `clearwater-modules` folder like below.\n", + "\n", + "NOTE: You will need to find this path yourself. Remember that if your path has any blank spaces, you must enclose the path with quotes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d081f53f-f7ef-4edb-81f2-e9cbcfcfabe6", + "metadata": {}, + "outputs": [], + "source": [ + "!conda develop '/Users/aaufdenkampe/Documents/Python/ClearWater-modules/src'" + ] + }, + { + "cell_type": "markdown", + "id": "cd44e256", + "metadata": {}, + "source": [ + "You now need to restart the Python kernel for this notebook, if the path didn't already exist." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ec258d25-c3b2-4b7e-a511-40f65c6058bc", + "metadata": {}, + "outputs": [], + "source": [ + "from clearwater_modules.nsm1.model import NutrientBudget" + ] + }, + { + "cell_type": "markdown", + "id": "fb9b46da-dde2-42ca-a156-4320b9b55ba3", + "metadata": {}, + "source": [ + "## Instantiate Models\n", + "### Clearwater-Riverine\n", + "\n", + "Ensure that you have followed the instructions in the Data Availability Section, and that you have all files downloaded in `examples/data_temp/sumwere_creek_coarse_p38`. For a more detailed explanation of all the steps in this process, please see [01_getting_started_riverine.ipynb](./01_getting_started_riverine.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ae2ef0cd-b448-405a-bfb7-ea69f4bd638f", + "metadata": {}, + "outputs": [], + "source": [ + "network_path = Path(r'W:\\2ERDC12 - Clearwater\\Clearwater_testing_NSM\\plan_48_simulation')\n", + "wetted_surface_area_path = network_path / \"wetted_surface_area.zarr\"\n", + "q_solar_path = network_path / 'cwr_boundary_conditions_q_solar_p28.csv'\n", + "air_temp_path = network_path / 'cwr_boundary_conditions_TairC_p28.csv'\n", + "config_file = network_path / 'demo_config.yml'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c1f71478", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#flow_field_fpath.exists()\n", + "config_file.exists()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8a8eb193", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 172800\n" + ] + } + ], + "source": [ + "start_index = 0 # int((8*60*60)/30)\n", + "end_index = 48*60*60\n", + "print(start_index, end_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "de6f3781", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating Model Mesh...\n", + "Calculating Required Parameters...\n", + "CPU times: total: 1.44 s\n", + "Wall time: 1.85 s\n" + ] + } + ], + "source": [ + "%%time\n", + "transport_model = cwr.ClearwaterRiverine(\n", + " config_filepath=config_file,\n", + " verbose=True,\n", + " datetime_range= (start_index, end_index)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8fb5383b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 495MB\n",
+       "Dimensions:                 (node: 549, time: 5761, nface: 444, nmax_face: 8,\n",
+       "                             nedge: 915, 2: 2)\n",
+       "Coordinates:\n",
+       "    node_x                  (node) float64 4kB 5.004e+05 5.005e+05 ... 5.024e+05\n",
+       "    node_y                  (node) float64 4kB 2.381e+03 2.376e+03 ... 500.0\n",
+       "  * time                    (time) datetime64[ns] 46kB 2022-05-13 ... 2022-05-15\n",
+       "    face_x                  (nface) float64 4kB 5.005e+05 ... 5.024e+05\n",
+       "    face_y                  (nface) float64 4kB 2.45e+03 2.45e+03 ... 564.4\n",
+       "Dimensions without coordinates: node, nface, nmax_face, nedge, 2\n",
+       "Data variables: (12/34)\n",
+       "    mesh2d                  int32 4B 0\n",
+       "    face_nodes              (nface, nmax_face) int32 14kB 0 1 2 3 ... -1 -1 -1\n",
+       "    edge_nodes              (nedge, 2) int32 7kB 0 1 1 2 2 ... 547 418 548 519\n",
+       "    edge_face_connectivity  (nedge, 2) int32 7kB 0 207 0 208 ... 194 442 329 443\n",
+       "    edges_face1             (nedge) int32 4kB 0 0 0 0 207 ... 366 0 19 194 329\n",
+       "    edges_face2             (nedge) int32 4kB 207 208 1 367 ... 440 441 442 443\n",
+       "    ...                      ...\n",
+       "    DOC                     (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n",
+       "    DIC                     (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n",
+       "    POM                     (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n",
+       "    CBOD                    (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n",
+       "    PX                      (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n",
+       "    Alk                     (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n",
+       "Attributes: (12/13)\n",
+       "    Conventions:                       CF-1.8 UGRID-1.0 Deltares-0.10\n",
+       "    diffusion_coefficient:             0.1\n",
+       "    volume_calculation_required:       False\n",
+       "    face_area_calculation_required:    False\n",
+       "    face_area_elevation_info:          Empty DataFrame\\nColumns: []\\nIndex: []\n",
+       "    face_area_elevation_values:        Empty DataFrame\\nColumns: []\\nIndex: []\n",
+       "    ...                                ...\n",
+       "    face_cell_indexes_df:              Empty DataFrame\\nColumns: []\\nIndex: []\n",
+       "    face_volume_elevation_info:        Empty DataFrame\\nColumns: []\\nIndex: []\n",
+       "    face_volume_elevation_values:      Empty DataFrame\\nColumns: []\\nIndex: []\n",
+       "    boundary_data:                     Empty DataFrame\\nColumns: []\\nIndex: []\n",
+       "    units:                             Metric\n",
+       "    nreal:                             366
" + ], + "text/plain": [ + " Size: 495MB\n", + "Dimensions: (node: 549, time: 5761, nface: 444, nmax_face: 8,\n", + " nedge: 915, 2: 2)\n", + "Coordinates:\n", + " node_x (node) float64 4kB 5.004e+05 5.005e+05 ... 5.024e+05\n", + " node_y (node) float64 4kB 2.381e+03 2.376e+03 ... 500.0\n", + " * time (time) datetime64[ns] 46kB 2022-05-13 ... 2022-05-15\n", + " face_x (nface) float64 4kB 5.005e+05 ... 5.024e+05\n", + " face_y (nface) float64 4kB 2.45e+03 2.45e+03 ... 564.4\n", + "Dimensions without coordinates: node, nface, nmax_face, nedge, 2\n", + "Data variables: (12/34)\n", + " mesh2d int32 4B 0\n", + " face_nodes (nface, nmax_face) int32 14kB 0 1 2 3 ... -1 -1 -1\n", + " edge_nodes (nedge, 2) int32 7kB 0 1 1 2 2 ... 547 418 548 519\n", + " edge_face_connectivity (nedge, 2) int32 7kB 0 207 0 208 ... 194 442 329 443\n", + " edges_face1 (nedge) int32 4kB 0 0 0 0 207 ... 366 0 19 194 329\n", + " edges_face2 (nedge) int32 4kB 207 208 1 367 ... 440 441 442 443\n", + " ... ...\n", + " DOC (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n", + " DIC (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n", + " POM (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n", + " CBOD (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n", + " PX (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n", + " Alk (time, nface) float64 20MB 1.0 1.0 1.0 ... nan nan\n", + "Attributes: (12/13)\n", + " Conventions: CF-1.8 UGRID-1.0 Deltares-0.10\n", + " diffusion_coefficient: 0.1\n", + " volume_calculation_required: False\n", + " face_area_calculation_required: False\n", + " face_area_elevation_info: Empty DataFrame\\nColumns: []\\nIndex: []\n", + " face_area_elevation_values: Empty DataFrame\\nColumns: []\\nIndex: []\n", + " ... ...\n", + " face_cell_indexes_df: Empty DataFrame\\nColumns: []\\nIndex: []\n", + " face_volume_elevation_info: Empty DataFrame\\nColumns: []\\nIndex: []\n", + " face_volume_elevation_values: Empty DataFrame\\nColumns: []\\nIndex: []\n", + " boundary_data: Empty DataFrame\\nColumns: []\\nIndex: []\n", + " units: Metric\n", + " nreal: 366" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#print(transport_model.constituent_dict)\n", + "transport_model.mesh" + ] + }, + { + "cell_type": "markdown", + "id": "dcfb43d5-07c5-4c4a-842c-438734b71767", + "metadata": {}, + "source": [ + "The Clearwater Riverine currently has the cell surface area, not the *wetted* cell surface area, as required for TSM. Ultimately, we will work on incorporating this calculation into Clearwater Riverine; however, for the sake of this example, we have the wetted surface areas saved in a zarr. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c0132f5a-2c31-4484-9680-44cb37407fd4", + "metadata": {}, + "outputs": [], + "source": [ + "wetted_sa = xr.open_zarr(wetted_surface_area_path)\n", + "wetted_sa = wetted_sa.compute()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6365f6de-a977-4975-a4fb-ad1f2b2275d3", + "metadata": {}, + "outputs": [], + "source": [ + "wetted_sa_subset = wetted_sa.isel(time=slice(start_index, end_index+1))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8046a726", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "wetted_sa_subset.wetted_surface_area.isel(nface=216).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a2846c4d-d26f-4ed4-b86e-6624aba1e696", + "metadata": {}, + "outputs": [], + "source": [ + "#transport_model.mesh['wetted_surface_area'] = wetted_sa_subset['wetted_surface_area']\n", + "\n", + "transport_model.mesh['wetted_surface_area'] = xr.DataArray(\n", + " wetted_sa_subset['wetted_surface_area'].values,\n", + " dims=('time', 'nface')\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c14fc85a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.wetted_surface_area.isel(nface=216).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "ef31e680-4792-4e1d-85b0-ab682dd36a53", + "metadata": {}, + "source": [ + "### Clearwater-Modules\n", + "\n", + "#### Initial State Values\n", + "The initial state values are `water_temp_c`, `volume`, and `surface_area` come from Clearwater-riverine mesh at the first timestep." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "befc95d9-663d-42f7-9f96-ec96821dcf40", + "metadata": {}, + "outputs": [], + "source": [ + "# Provide xr.data array values for initial state values\n", + "initial_state_values = {\n", + " 'Ap': transport_model.mesh['Ap'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'DOX': transport_model.mesh['DOX'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'NH4': transport_model.mesh['NH4'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'NO3': transport_model.mesh['NO3'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'TIP': transport_model.mesh['TIP'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'Ab': transport_model.mesh['Ab'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'OrgN': transport_model.mesh['OrgN'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'N2': transport_model.mesh['N2'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'OrgP': transport_model.mesh['OrgP'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'POC': transport_model.mesh['POC'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'DOC': transport_model.mesh['DOC'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'DIC': transport_model.mesh['DIC'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'POM': transport_model.mesh['POM'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'CBOD': transport_model.mesh['CBOD'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'PX': transport_model.mesh['PX'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'Alk': transport_model.mesh['Alk'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'volume': transport_model.mesh['volume'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal+1)\n", + " ),\n", + " 'surface_area': transport_model.mesh['wetted_surface_area'].isel(\n", + " time=0,\n", + " nface=slice(0, transport_model.mesh.nreal + 1)\n", + " ),\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "738c906c-2143-404a-982c-cba751248fc1", + "metadata": {}, + "source": [ + "#### Meteorological Parameters\n", + "The meteorological parameters that we'll be adjusting for this model are `q_solar` and `air_temp_c`. In this example, `q_solar` and `air_temp_c` are pulled from meteorological stations in Arizona. \n", + "We will need to interpolate these datasets to our model timestep, using the following function:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3d319864-884e-40db-9a85-93f56c87ba53", + "metadata": {}, + "outputs": [], + "source": [ + "def interpolate_to_model_timestep(meteo_df, model_dates, col_name):\n", + " merged_df = pd.merge_asof(\n", + " pd.DataFrame({'time': model_dates}),\n", + " meteo_df,\n", + " left_on='time',\n", + " right_on='Datetime')\n", + " merged_df[col_name.lower()] = merged_df[col_name].interpolate(method='linear')\n", + " merged_df.drop(\n", + " columns=['Datetime', col_name],\n", + " inplace=True)\n", + " merged_df.rename(\n", + " columns={'time': 'Datetime'},\n", + " inplace=True,\n", + " )\n", + " return merged_df" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "abc09be6-f808-49bc-b6e9-dc2f792928d6", + "metadata": {}, + "outputs": [], + "source": [ + "xarray_time_index = pd.DatetimeIndex(\n", + " transport_model.mesh.time.values\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "48f7491a-25ee-48cb-8609-4c174ff53073", + "metadata": {}, + "source": [ + "Create timeseries of Q solar and Air Temperature aligned with the timestep of the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0145082a-c55b-43be-abd0-75647b5863bb", + "metadata": {}, + "outputs": [], + "source": [ + "# Q Solar\n", + "q_solar = pd.read_csv(\n", + " q_solar_path, \n", + " parse_dates=['Datetime'])\n", + "q_solar.dropna(axis=0, inplace=True)\n", + "\n", + "q_solar_interp = interpolate_to_model_timestep(\n", + " q_solar,\n", + " xarray_time_index,\n", + " 'q_Solar'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "2b0ba137-e173-442e-b2a9-0478e7adad33", + "metadata": {}, + "outputs": [], + "source": [ + "# Air Temperature\n", + "air_temp_c = pd.read_csv(\n", + " air_temp_path, \n", + " parse_dates=['Datetime'])\n", + "air_temp_c.dropna(axis=0, inplace=True)\n", + "\n", + "air_temp_c_interp = interpolate_to_model_timestep(\n", + " air_temp_c,\n", + " xarray_time_index,\n", + " 'TairC'\n", + ")\n", + "\n", + "air_temp_c_interp['air_temp_c'] = (air_temp_c_interp.tairc - 32)* (5/9)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0964e5b0-b9b4-4299-bfe5-2514eaf4b795", + "metadata": {}, + "outputs": [], + "source": [ + "# process for clearwater-modules input\n", + "q_solar_array = q_solar_interp.q_solar.to_numpy()\n", + "air_temp_array = air_temp_c_interp.air_temp_c.to_numpy()\n", + "\n", + "# for each individual timestep\n", + "all_meteo_params = {\n", + " 'q_solar': q_solar_array,\n", + " 'air_temp_c': air_temp_array,\n", + "}\n", + "\n", + "# for initial conditions\n", + "initial_meteo_params = {\n", + " 'air_temp_c': air_temp_array[0],\n", + " 'q_solar': q_solar_array[0],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "468dbf2a-5bc5-4186-b543-56e13ab4e34f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5761,)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.shape(air_temp_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e832b78f-9599-4c10-bdfc-d0dc0b0b69ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5761\n", + "\n" + ] + } + ], + "source": [ + "time_Steps = len(transport_model.mesh.time)\n", + "print(time_Steps)\n", + "print(type(time_Steps))" + ] + }, + { + "cell_type": "markdown", + "id": "782cbe25-8c4f-4a3b-a134-3507bf20f247", + "metadata": {}, + "source": [ + "#### Instantiate Clearwater Modules\n", + "We instantiate Clearwater Modules with the following:\n", + "* `initial_state_values` (required): our initial conditions of water temperature, cell volumes, and cell surface areas.\n", + "* `time_dim` (optional): the model timestep\n", + "* `meteo_parameters` (optional): intitial meteorological parameters. If not provided, all meteo parameters will fall to default values.\n", + "* `track_dynamic_variables` (optional): boolean indicating whether or not the user wants to track all intermediate information used in the calculations. We set this to `False` to save on memory.\n", + "* `use_sed_temp` (optional): boolean indicating whether to use the sediment temperature in TSM calculations. We opt to turn this off for simplicity.\n", + "* `updateable_static_variables` (optional): by default, the meteorological variables are static in TSM. If we want these to update over time, we must provide a list of variables that we want to be updateable as input when instantiating the model. " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "86b811c9-f20b-4d23-8af4-85cd2a7876b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing from dicts...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\base.py:223: UserWarning: Variable volume is not a state variable, skipping.\n", + " warnings.warn(\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\base.py:223: UserWarning: Variable surface_area is not a state variable, skipping.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model initialized from input dicts successfully!.\n" + ] + } + ], + "source": [ + "reaction_model = NutrientBudget(\n", + " time_steps=time_Steps,\n", + " initial_state_values=initial_state_values,\n", + " updateable_static_variables=['q_solar'],\n", + " \n", + " algae_parameters = {\n", + " 'AWd': 100,\n", + " 'AWc': 40,\n", + " 'AWn': 7.2,\n", + " 'AWp': 1,\n", + " 'AWa': 1000,\n", + " 'KL': 10,\n", + " 'KsN': 0.04,\n", + " 'KsP': 0.0012,\n", + " 'mu_max_20': 1,\n", + " 'kdp_20': 0.15,\n", + " 'krp_20': 0.2,\n", + " 'vsap': 0.15,\n", + " 'growth_rate_option': 3,\n", + " 'light_limitation_option': 1 \n", + " },\n", + "\n", + " global_parameters={\n", + " 'use_NH4': True,\n", + " 'use_NO3': True, \n", + " 'use_OrgN': False,\n", + " 'use_OrgP': False,\n", + " 'use_TIP': True, \n", + " 'use_SedFlux': False,\n", + " 'use_DOX': True,\n", + " 'use_Algae': True,\n", + " 'use_Balgae': False,\n", + " 'use_POC': False,\n", + " 'use_DOC': False,\n", + " 'use_DIC': False,\n", + " 'use_N2': False,\n", + " 'use_Pathogen': False,\n", + " 'use_Alk': False,\n", + " 'use_POM': False \n", + " },\n", + "\n", + "\n", + " global_vars = {\n", + " 'vson': 0.01,\n", + " 'vsoc': 0.01,\n", + " 'vsop': 0.01,\n", + " 'vs': 0.01,\n", + " 'SOD_20': .5,\n", + " 'SOD_theta': 1.047,\n", + " 'vb': 0.01,\n", + " 'fcom': 0.4,\n", + " 'kaw_20_user': 0,\n", + " 'kah_20_user': 1,\n", + " 'hydraulic_reaeration_option': 1,\n", + " 'wind_reaeration_option': 1, \n", + " 'dt': 0.0003472222,\n", + " 'depth': 1.5,\n", + " 'TwaterC': 25,\n", + " 'theta': 1.047,\n", + " 'velocity': 1,\n", + " 'flow': 150,\n", + " 'topwidth': 100,\n", + " 'slope': .0002,\n", + " 'shear_velocity': 0.05334,\n", + " 'pressure_atm': 1013.25,\n", + " 'wind_speed': 3,\n", + " 'q_solar': 500,\n", + " 'Solid': 1,\n", + " 'lambda0': 0.02,\n", + " 'lambda1': 0.0088,\n", + " 'lambda2': 0.054,\n", + " 'lambdas': 0.056,\n", + " 'lambdam': 0.174, \n", + " 'Fr_PAR': 0.47 \n", + " },\n", + "\n", + " track_dynamic_variables=False, \n", + " time_dim='seconds' \n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "id": "2d2da52a-724d-46c7-9ed7-fda8bedfa6f3", + "metadata": {}, + "source": [ + "## Couple Models\n", + "Optionally, you can log output if you run for a long simulation to track progress." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "462f0a9e-7b70-4ae3-bb06-9e67ba4b80ca", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_function_logger(name):\n", + " logger = logging.getLogger('function_logger')\n", + " handler = logging.FileHandler(f'{name}.log')\n", + " formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n", + " handler.setFormatter(formatter)\n", + " logger.addHandler(handler)\n", + " logger.setLevel(logging.DEBUG) # Adjust the level based on your needs\n", + " return logger" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "32e3aed0-8dad-4767-bd0f-2bfe5308b4fe", + "metadata": {}, + "outputs": [], + "source": [ + "def run_n_timesteps(\n", + " time_steps: int,\n", + " reaction: NutrientBudget,\n", + " transport: cwr.ClearwaterRiverine,\n", + " meteo_params: dict,\n", + " concentration_update = None,\n", + " logging = True,\n", + " log_file_name='log',\n", + "):\n", + " \"\"\"Function to couple Clearwater Riverine and Modules for n timesteps.\"\"\"\n", + "\n", + " # Set up logger\n", + " if logging:\n", + " logger = setup_function_logger(f'{log_file_name}')\n", + "\n", + " for i in range(1, time_steps):\n", + " if i % 100 == 0:\n", + " status = {\n", + " 'timesteps': i,\n", + " 'cwr': transport.mesh.nbytes * 1e-9,\n", + " 'cwm': reaction.dataset.nbytes*1e-9,\n", + " }\n", + " if logging:\n", + " logger.debug(status)\n", + "\n", + " # Top of timestep: update transport model using values with output from reaction model, if available\n", + " transport.update(concentration_update)\n", + "\n", + " # Update state values\n", + " updated_state_values = {\n", + " 'Ap': transport.mesh['Ap'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'NH4': transport.mesh['NH4'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'NO3': transport.mesh['NO3'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'TIP': transport.mesh['TIP'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'DOX': transport.mesh['DOX'].isel(\n", + " time=i,\n", + " nface=slice(0,transport.mesh.nreal+1)\n", + " ), \n", + " 'q_solar': transport.mesh.Ap.isel(\n", + " time=i,\n", + " nface=slice(0, transport.mesh.nreal + 1)\n", + " ) * 0 + meteo_params['q_solar'][i],\n", + " }\n", + "\n", + " # Bottom of timestep: update nutrient budget (NSM1)\n", + " reaction.increment_timestep(updated_state_values)\n", + "\n", + " # Prepare data for input back into Riverine\n", + " ds = reaction.dataset.copy()\n", + " ds['Ap'] = ds['Ap'].where(\n", + " ~np.isinf(ds['Ap']),\n", + " transport.mesh['Ap'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['Ap'] = ds['Ap'].fillna(\n", + " transport.mesh['Ap'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + "\n", + "\n", + " ds['DOX'] = ds['DOX'].where(\n", + " ~np.isinf(ds['DOX']),\n", + " transport.mesh['DOX'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['DOX'] = ds['DOX'].fillna(\n", + " transport.mesh['DOX'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + "\n", + "\n", + " ds['NH4'] = ds['NH4'].where(\n", + " ~np.isinf(ds['NH4']),\n", + " transport.mesh['NH4'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['NH4'] = ds['NH4'].fillna(\n", + " transport.mesh['NH4'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + "\n", + "\n", + " ds['NO3'] = ds['NO3'].where(\n", + " ~np.isinf(ds['NO3']),\n", + " transport.mesh['NO3'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['NO3'] = ds['NO3'].fillna(\n", + " transport.mesh['NO3'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + "\n", + "\n", + " ds['TIP'] = ds['TIP'].where(\n", + " ~np.isinf(ds['TIP']),\n", + " transport.mesh['TIP'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " ) \n", + " ds['TIP'] = ds['TIP'].fillna(\n", + " transport.mesh['TIP'].isel(\n", + " nface=slice(0, transport.mesh.nreal+1),\n", + " time=i\n", + " )\n", + " )\n", + "\n", + "\n", + " concentration_update = {\"Ap\": ds.Ap.isel(seconds=i),\n", + " \"DOX\": ds.DOX.isel(seconds=i),\n", + " \"NH4\": ds.NH4.isel(seconds=i),\n", + " \"NO3\": ds.NO3.isel(seconds=i),\n", + " \"TIP\": ds.TIP.isel(seconds=i)\n", + " }\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "28b35563-bf79-4be1-9c30-7d86b41d2e7e", + "metadata": {}, + "outputs": [], + "source": [ + "TIME_STEPS = len(transport_model.mesh.time) - 1 # 5760 # len(transport_model.mesh.time) - 60" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "6572e8e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5760" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "TIME_STEPS" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "408f2fbe-ffbd-4cfb-afa2-45df1a5526f2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:596: RuntimeWarning: divide by zero encountered in divide\n", + " mu_max_tc * FL * 2.0 / (1.0 / FN + 1.0 / FP)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1223: RuntimeWarning: invalid value encountered in divide\n", + " PN * NH4 / (PN * NH4 + (1.0 - PN) * NO3)\n", + "D:\\Clearwater\\ClearWater-modules\\src\\clearwater_modules\\nsm1\\processes.py:1279: RuntimeWarning: invalid value encountered in divide\n", + " (PNb * NH4) / (PNb * NH4 + (1.0 - PNb) * NO3)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 1h 17min 33s\n", + "Wall time: 1h 17min 48s\n" + ] + } + ], + "source": [ + "%%time\n", + "run_n_timesteps(\n", + " TIME_STEPS,\n", + " reaction_model,\n", + " transport_model,\n", + " all_meteo_params,\n", + " logging=True,\n", + ")\n", + "\n", + "#zarr_outpath = network_path / 'output.zarr'\n", + "#netCDF_outpath = network_path / 'output.nc'\n", + "#transport_model.finalize(True, zarr_outpath)\n", + "#transport_model.finalize(True, netCDF_outpath)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5ce5d8b", + "metadata": {}, + "outputs": [], + "source": [ + "zarr_outpath = network_path / 'output.zarr'\n", + "netCDF_outpath = network_path / 'output.nc'\n", + "transport_model.finalize(True, zarr_outpath)\n", + "transport_model.finalize(True, netCDF_outpath)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "1ffec8b8-04e2-4a05-b835-f4f507bfeb7c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.Ap.isel(time=5000).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "d0c630a5-339a-495d-a2a0-91e4735869e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.Ap.isel(nface=151).plot()#, time=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "856f4cb6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.Ap.isel(nface=151, time=slice(0, 50)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "5c81a38a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.DOX.isel(nface=151, time=slice(0, 5000)).plot()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "1dfaa667", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.DOX.isel(nface=217, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "ad9bf52d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.Ap.isel(nface=217, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "426fa202", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.NO3.isel(nface=151, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "92609341", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.NH4.isel(nface=151, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "5db5b8be", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.Ap.isel(nface=207, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "d6648856", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.DOX.isel(nface=207, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "e4ecd765", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.TIP.isel(nface=207, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "c7e3d3e4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.mesh.TIP.isel(nface=151, time=slice(0, 5000)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "124a7880", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "34aaac4f30824a7d99e977f83245c82b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "BokehModel(combine_events=True, render_bundle={'docs_json': {'fd459e6c-4c0b-453b-b75c-58114812a966': {'version…" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "transport_model.plot(\n", + " crs='EPSG:26916',\n", + " constituent_name='Ap',\n", + " clim=(10, 25),\n", + " cmap='RdYlBu_r',\n", + " filter_empty = True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "742b621c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=1000,\n", + " crs='EPSG:26916',\n", + " constituent_name='Ap',\n", + " clim=(0, 15),\n", + " cmap='RdYlBu_r',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "639c4bd0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=5000,\n", + " crs='EPSG:26916',\n", + " constituent_name='Ap',\n", + " clim=(0, 550),\n", + " cmap='RdYlBu_r',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "d3c8887b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=1000,\n", + " crs='EPSG:26916',\n", + " constituent_name='DOX',\n", + " clim=(3, 9),\n", + " cmap='RdYlBu_r',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "c0af23be", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=1000,\n", + " crs='EPSG:26916',\n", + " constituent_name='NH4',\n", + " clim=(0, 2),\n", + " cmap='RdYlBu_r',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "01dec69d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=1000,\n", + " crs='EPSG:26916',\n", + " constituent_name='NO3',\n", + " clim=(0, 1.25),\n", + " cmap='RdYlBu_r',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "a96eb135", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "transport_model.static_plot(\n", + " plotting_timestep=5000,\n", + " crs='EPSG:26916',\n", + " constituent_name='TIP',\n", + " clim=(0, 65),\n", + " cmap='RdYlBu_r',\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5377d829", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=217, time=slice(100, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eab93216", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=207, time=slice(0, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57dd8774", + "metadata": {}, + "outputs": [], + "source": [ + "np.shape(transport_model.constituent_dict['temperature'].input_array)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eaa7b560-a7ba-4737-a9c3-bd090bc8a7d6", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.mesh.temperature.isel(nface=165, time=slice(1000, TIME_STEPS)).plot()" + ] + }, + { + "cell_type": "markdown", + "id": "af441d7e-19d2-41a3-b7ff-6e0126993469", + "metadata": {}, + "source": [ + "## Plot Results" + ] + }, + { + "cell_type": "markdown", + "id": "793d31d6-9ef8-4692-bd58-981e3dee7fb1", + "metadata": {}, + "source": [ + "### Built-In Functions\n", + "Use the built-in plotting function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "440784b0-77a7-46fa-a73a-20b40ab2fd42", + "metadata": {}, + "outputs": [], + "source": [ + "transport_model.plot(\n", + " crs='EPSG:26916',\n", + " clim=(5, 26)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b6aadcb2-4186-4aac-a036-0f2c1e9978f6", + "metadata": {}, + "source": [ + "### Build Panel Apps\n", + "\n", + "#### Interactive Timeseries Plotting\n", + "This is an exmaple of an interactive map that allows you to click on a single cell and see the timeseries for that cell:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6dc19e97-9725-4f80-864b-2d034623314a", + "metadata": {}, + "outputs": [], + "source": [ + "from clearwater_riverine.variables import (\n", + " NUMBER_OF_REAL_CELLS,\n", + " CONCENTRATION,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cae6e61-9877-447d-bece-7b7dacfd3851", + "metadata": {}, + "outputs": [], + "source": [ + "# create inputs for panel app\n", + "ds = transport_model.mesh\n", + "gdf = transport_model.gdf\n", + "time_index = 60\n", + "mn_val = 4\n", + "mval = 25\n", + "date_value = ds.time.isel(time=time_index).values" + ] + }, + { + "cell_type": "markdown", + "id": "374633ff-30cf-48a3-b5c3-6bc73d690f88", + "metadata": {}, + "source": [ + "Start by creating a base map of a plan view of Sumwere Creek using the `geoviews` library. Including the `hover` and `tap` tools allows users to hover over the plot to see values and turns on the ability to use the tap stream that allows users to click on a cell and receive feedback from that tap. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95fb690b", + "metadata": {}, + "outputs": [], + "source": [ + "ras_sub_df = gdf[(gdf.datetime == date_value) & (gdf.concentration != 0)]\n", + "units = ds[CONCENTRATION].Units\n", + "ras_map = gv.Polygons(\n", + " ras_sub_df,\n", + " vdims=['concentration', 'cell']).opts(\n", + " height = 800,\n", + " width = 800,\n", + " color='concentration',\n", + " cmap='RdYlBu_r',\n", + " line_width = 0.1,\n", + " tools = ['hover', 'tap'],\n", + " clabel = f\"Concentration ({units})\",\n", + " xaxis=None,\n", + " yaxis=None,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "10c064e1-58d7-44b5-90a5-e914f50a1e88", + "metadata": {}, + "source": [ + "The cell below defines the tap stream and initializes an empty list of plots to display. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5b8a690", + "metadata": {}, + "outputs": [], + "source": [ + "tap_stream = hv.streams.Tap(source=ras_map, x=None, y=None)\n", + "plots = []" + ] + }, + { + "cell_type": "markdown", + "id": "086f5ae1-61c9-43ec-8dd7-3d97233ca903", + "metadata": {}, + "source": [ + "The `tap_plot` function identifies which cell has been clicked and generates a timeseries plot for that cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b2c8431-06e6-44ca-8f5a-6f2ffae4f51b", + "metadata": {}, + "outputs": [], + "source": [ + "def tap_plot(x, y):\n", + " # filter data\n", + " clicked_data = ras_sub_df.cx[x:x, y:y]\n", + " if x != None and y != None:\n", + " # identify cell number and pull concentration timeseries for that cell\n", + " cell = clicked_data['cell'].iloc[0]\n", + " cs = ds.concentration.isel(nface=cell, time=slice(0, TIME_STEPS))\n", + "\n", + " # Create timeseries plot\n", + " curve = hv.Curve(\n", + " cs,\n", + " ).opts(\n", + " title=f'Time series',\n", + " height=800,\n", + " width=800,\n", + " line_width=5,\n", + " fontsize= {'title': 18, 'labels': 16, 'xticks': 12, 'yticks': 12},\n", + " ylabel= 'Water Temperature (C)'\n", + " )\n", + "\n", + " # Append to list of plots (allows multiple lines to appear at the same time)\n", + " plots.append(curve)\n", + " # Return an overlay of all the plots\n", + " return hv.Overlay(plots).opts(legend_position='right')\n", + " else:\n", + " # Create an empty timeseries plot telling users to click on a cell to generate a timeseries\n", + " xs = np.linspace(-5,5,100)\n", + " empty_curve = hv.Curve((xs,-(xs-2)**2)).opts(\n", + " title=f'Time series',\n", + " line_color='white',\n", + " height=800, \n", + " width=800,\n", + " xaxis=None,\n", + " yaxis=None,\n", + " )* hv.Text(0, -20, \"Please click a cell on the map to display a timeseries.\")\n", + " return empty_curve\n", + "\n", + "# Create Dynamic Map that references the tap stream.\n", + "tap_dmap = hv.DynamicMap(tap_plot, streams=[tap_stream])" + ] + }, + { + "cell_type": "markdown", + "id": "6d3d9114-6daa-486f-beaf-629e7f06911c", + "metadata": {}, + "source": [ + "The following function and button allows users to clear all timeseries plots if they wish to start fresh:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf70743d", + "metadata": {}, + "outputs": [], + "source": [ + "def reset_tap_stream(event):\n", + " global plots\n", + " tap_stream.event(x=None, y=None)\n", + " plots = []\n", + " \n", + "button = pn.widgets.Button(name='Reset', button_type='primary')\n", + "button.on_click(reset_tap_stream)" + ] + }, + { + "cell_type": "markdown", + "id": "1bea5541-de92-4f29-86ab-e0d8df1f7167", + "metadata": {}, + "source": [ + "Now display the plot:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c1661ac-e670-4752-ae8f-8889bf81288a", + "metadata": {}, + "outputs": [], + "source": [ + "layout = pn.Row(\n", + " ras_map,\n", + " tap_dmap.opts(\n", + " hv.opts.Curve(framewise=True, yaxis='right'),\n", + " ),\n", + " button\n", + " )\n", + "layout.servable()" + ] + }, + { + "cell_type": "markdown", + "id": "38a9609e-9090-413b-bbd3-b9fd0017f1cf", + "metadata": {}, + "source": [ + "#### Dynamic Map Visualization\n", + "Make a plot with a scrubber bar that shows a map over time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8fbb429e-0939-4513-9f35-a893f22f109c", + "metadata": {}, + "outputs": [], + "source": [ + "ds = transport_model.mesh\n", + "gdf = transport_model.gdf\n", + "import hvplot.pandas " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d7bb0cb-32fd-4f96-916d-a084e60e4e6a", + "metadata": {}, + "outputs": [], + "source": [ + "# eliminate cells without any temperature\n", + "gdf_sub = gdf[gdf.concentration != 0]\n", + "gdf_subset = gdf_sub[(gdf_sub['datetime'] > '2022-05-13 08:00:00')]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7937eec0-e050-43ff-8a3c-57bbb72abfc0", + "metadata": {}, + "outputs": [], + "source": [ + "plot_to_save = gdf_subset.hvplot(\n", + " geo=True,\n", + " groupby=\"datetime\",\n", + " # z = 'concentration',\n", + " c = 'concentration', # minute_gdf_subset.concentration,\n", + " clim=(4, 25),\n", + " cmap='RdYlBu_r',\n", + " clabel='Water Temperature (C)',\n", + " line_width = 0.1,\n", + " height=700,\n", + " width=800,\n", + " widget_location='bottom',\n", + " line_color='white',\n", + " \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b62985fb-0876-4bf8-b79e-a5a30a8731f7", + "metadata": {}, + "outputs": [], + "source": [ + "plot_to_save" + ] + }, + { + "cell_type": "raw", + "id": "09061d44-666a-40fc-8388-8acc597b72d0", + "metadata": {}, + "source": [ + "plot_to_save.save(filename='data_temp/output.html', embed=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/dev_sandbox/debug_linking_to_NSM1.py b/examples/dev_sandbox/debug_linking_to_NSM1.py new file mode 100644 index 0000000..4a170ad --- /dev/null +++ b/examples/dev_sandbox/debug_linking_to_NSM1.py @@ -0,0 +1,485 @@ +# import modules +from pathlib import Path +import os +import logging +import numpy as np +import pandas as pd +import xarray as xr +import holoviews as hv +import geoviews as gv +# from holoviews import opts +import panel as pn +hv.extension("bokeh") + +import clearwater_riverine as cwr +from clearwater_modules.nsm1.model import NutrientBudget + + +project_path = Path.cwd().parent +src_path = project_path / 'src' +print(project_path) +print(src_path) + +#point to config +network_path = Path(r'W:\2ERDC12 - Clearwater\Clearwater_testing_NSM\plan_48_simulation') +wetted_surface_area_path = network_path / "wetted_surface_area.zarr" +q_solar_path = network_path / 'cwr_boundary_conditions_q_solar_p28.csv' +air_temp_path = network_path / 'cwr_boundary_conditions_TairC_p28.csv' +config_file = network_path / 'demo_config.yml' +print(config_file.exists()) + +start_index = 0 # int((8*60*60)/30) +end_index = 48*60*60 +print(start_index, end_index) + +transport_model = cwr.ClearwaterRiverine( + config_filepath=config_file, + verbose=True, + datetime_range= (start_index, end_index) +) + +wetted_sa = xr.open_zarr(wetted_surface_area_path) +wetted_sa = wetted_sa.compute() +wetted_sa_subset = wetted_sa.isel(time=slice(start_index, end_index+1)) + +transport_model.mesh['wetted_surface_area'] = xr.DataArray( + wetted_sa_subset['wetted_surface_area'].values, + dims=('time', 'nface') +) + + + + +# Provide xr.data array values for initial state values +initial_state_values = { + 'Ap': transport_model.mesh['Ap'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'DOX': transport_model.mesh['DOX'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'NH4': transport_model.mesh['NH4'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'NO3': transport_model.mesh['NO3'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'TIP': transport_model.mesh['TIP'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'Ab': transport_model.mesh['Ab'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'OrgN': transport_model.mesh['OrgN'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'N2': transport_model.mesh['N2'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'OrgP': transport_model.mesh['OrgP'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'POC': transport_model.mesh['POC'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'DOC': transport_model.mesh['DOC'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'DIC': transport_model.mesh['DIC'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'POM': transport_model.mesh['POM'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'CBOD': transport_model.mesh['CBOD'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'PX': transport_model.mesh['PX'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'Alk': transport_model.mesh['Alk'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'volume': transport_model.mesh['volume'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal+1) + ), + 'surface_area': transport_model.mesh['wetted_surface_area'].isel( + time=0, + nface=slice(0, transport_model.mesh.nreal + 1) + ), +} + + + + +def interpolate_to_model_timestep(meteo_df, model_dates, col_name): + merged_df = pd.merge_asof( + pd.DataFrame({'time': model_dates}), + meteo_df, + left_on='time', + right_on='Datetime') + merged_df[col_name.lower()] = merged_df[col_name].interpolate(method='linear') + merged_df.drop( + columns=['Datetime', col_name], + inplace=True) + merged_df.rename( + columns={'time': 'Datetime'}, + inplace=True, + ) + return merged_df + + +xarray_time_index = pd.DatetimeIndex( + transport_model.mesh.time.values +) + + +# Q Solar +q_solar = pd.read_csv( + q_solar_path, + parse_dates=['Datetime']) +q_solar.dropna(axis=0, inplace=True) + +q_solar_interp = interpolate_to_model_timestep( + q_solar, + xarray_time_index, + 'q_Solar' +) + + + +# Air Temperature +air_temp_c = pd.read_csv( + air_temp_path, + parse_dates=['Datetime']) +air_temp_c.dropna(axis=0, inplace=True) + +air_temp_c_interp = interpolate_to_model_timestep( + air_temp_c, + xarray_time_index, + 'TairC' +) + +air_temp_c_interp['air_temp_c'] = (air_temp_c_interp.tairc - 32)* (5/9) + + + + +# process for clearwater-modules input +q_solar_array = q_solar_interp.q_solar.to_numpy() +air_temp_array = air_temp_c_interp.air_temp_c.to_numpy() + +# for each individual timestep +all_meteo_params = { + 'q_solar': q_solar_array, + 'air_temp_c': air_temp_array, +} + +# for initial conditions +initial_meteo_params = { + 'air_temp_c': air_temp_array[0], + 'q_solar': q_solar_array[0], +} + + + +time_Steps = len(transport_model.mesh.time) + + +reaction_model = NutrientBudget( + time_steps=time_Steps, + initial_state_values=initial_state_values, + #updateable_static_variables=['q_solar'], + + algae_parameters = { + 'AWd': 100, + 'AWc': 40, + 'AWn': 7.2, + 'AWp': 1, + 'AWa': 1000, + 'KL': 10, + 'KsN': 0.04, + 'KsP': 0.0012, + 'mu_max_20': 1, + 'kdp_20': 0.15, + 'krp_20': 0.2, + 'vsap': 0.15, + 'growth_rate_option': 3, + 'light_limitation_option': 1 + }, + + global_parameters={ + 'use_NH4': True, + 'use_NO3': True, + 'use_OrgN': False, + 'use_OrgP': False, + 'use_TIP': True, + 'use_SedFlux': False, + 'use_DOX': True, + 'use_Algae': True, + 'use_Balgae': False, + 'use_POC': False, + 'use_DOC': False, + 'use_DIC': False, + 'use_N2': False, + 'use_Pathogen': False, + 'use_Alk': False, + 'use_POM': False + }, + + global_vars = { + 'vson': 0.01, + 'vsoc': 0.01, + 'vsop': 0.01, + 'vs': 0.01, + 'SOD_20': .5, + 'SOD_theta': 1.047, + 'vb': 0.01, + 'fcom': 0.4, + 'kaw_20_user': 0, + 'kah_20_user': 1, + 'hydraulic_reaeration_option': 1, + 'wind_reaeration_option': 1, + 'dt': 0.0003472222, + 'depth': 1.5, + 'TwaterC': 25, + 'theta': 1.047, + 'velocity': 1, + 'flow': 150, + 'topwidth': 100, + 'slope': .0002, + 'shear_velocity': 0.05334, + 'pressure_atm': 1013.25, + 'wind_speed': 3, + 'q_solar': 500, + 'Solid': 1, + 'lambda0': 0.02, + 'lambda1': 0.0088, + 'lambda2': 0.054, + 'lambdas': 0.056, + 'lambdam': 0.174, + 'Fr_PAR': 0.47 + }, + + track_dynamic_variables=False, + time_dim='seconds' + ) + + + + +def setup_function_logger(name): + logger = logging.getLogger('function_logger') + handler = logging.FileHandler(f'{name}.log') + formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') + handler.setFormatter(formatter) + logger.addHandler(handler) + logger.setLevel(logging.DEBUG) # Adjust the level based on your needs + return logger + + + + +def run_n_timesteps( + time_steps: int, + reaction: NutrientBudget, + transport: cwr.ClearwaterRiverine, + meteo_params: dict, + concentration_update = None, + logging = True, + log_file_name='log', +): + """Function to couple Clearwater Riverine and Modules for n timesteps.""" + print('func--> run_n_timesteps: ', time_steps) #####for debugging + # Set up logger + if logging: + logger = setup_function_logger(f'{log_file_name}') + + for i in range(1, time_steps): + if i % 100 == 0: + status = { + 'timesteps': i, + 'cwr': transport.mesh.nbytes * 1e-9, + 'cwm': reaction.dataset.nbytes*1e-9, + } + if logging: + logger.debug(status) + + # Top of timestep: update transport model using values with output from reaction model, if available + transport.update(concentration_update) + + # Update state values + updated_state_values = { + 'Ap': transport.mesh['Ap'].isel( + time=i, + nface=slice(0,transport.mesh.nreal+1) + ), + 'NH4': transport.mesh['NH4'].isel( + time=i, + nface=slice(0,transport.mesh.nreal+1) + ), + 'NO3': transport.mesh['NO3'].isel( + time=i, + nface=slice(0,transport.mesh.nreal+1) + ), + 'TIP': transport.mesh['TIP'].isel( + time=i, + nface=slice(0,transport.mesh.nreal+1) + ), + 'DOX': transport.mesh['DOX'].isel( + time=i, + nface=slice(0,transport.mesh.nreal+1) + ), + #'q_solar': transport.mesh.Ap.isel( + # time=i, + # nface=slice(0, transport.mesh.nreal + 1) + #) * 0 + meteo_params['q_solar'][i], + } + + # Bottom of timestep: update nutrient budget (NSM1) + reaction.increment_timestep(updated_state_values) + + # Prepare data for input back into Riverine + ds = reaction.dataset.copy() + ds['Ap'] = ds['Ap'].where( + ~np.isinf(ds['Ap']), + transport.mesh['Ap'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + ds['Ap'] = ds['Ap'].fillna( + transport.mesh['Ap'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + + + ds['DOX'] = ds['DOX'].where( + ~np.isinf(ds['DOX']), + transport.mesh['DOX'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + ds['DOX'] = ds['DOX'].fillna( + transport.mesh['DOX'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + + + ds['NH4'] = ds['NH4'].where( + ~np.isinf(ds['NH4']), + transport.mesh['NH4'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + ds['NH4'] = ds['NH4'].fillna( + transport.mesh['NH4'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + + + ds['NO3'] = ds['NO3'].where( + ~np.isinf(ds['NO3']), + transport.mesh['NO3'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + ds['NO3'] = ds['NO3'].fillna( + transport.mesh['NO3'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + + + ds['TIP'] = ds['TIP'].where( + ~np.isinf(ds['TIP']), + transport.mesh['TIP'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + ds['TIP'] = ds['TIP'].fillna( + transport.mesh['TIP'].isel( + nface=slice(0, transport.mesh.nreal+1), + time=i + ) + ) + + + concentration_update = {"Ap": ds.Ap.isel(seconds=i), + "DOX": ds.DOX.isel(seconds=i), + "NH4": ds.NH4.isel(seconds=i), + "NO3": ds.NO3.isel(seconds=i), + "TIP": ds.TIP.isel(seconds=i) + } + + + +TIME_STEPS = len(transport_model.mesh.time) - 1 + + + +run_n_timesteps( + TIME_STEPS, + reaction_model, + transport_model, + all_meteo_params, + logging=True, +) + + + +#dir_str = os.path.abspath("") +#dir = Path(dir_str) +#dir_sandbox = dir / "examples" / "dev_sandbox" +#config_filepath = dir_sandbox / "demo_config.yml" +#print(dir) +#print(config_filepath) +#print(config_filepath.exists()) + + +#setup model +#transport_model = cwr.ClearwaterRiverine( +# config_filepath=config_filepath, +# verbose=True, +#) + + +#make an array the shape of the temp array with 5,000 everywhere +#arbitrary_values_tracer = xr.full_like(transport_model.mesh.conservative_tracer, 200) +#print(arbitrary_values_tracer) +#arbitrary_values_temp = xr.full_like(transport_model.mesh.temperature, 5000) +#update_concentration = {'conservative_tracer_IncorrectName':arbitrary_values_tracer.isel(time=1), +# 'conservative_tracer':arbitrary_values_tracer.isel(time=1), +# 'temperature_IncorrectName': arbitrary_values_temp.isel(time=1), +# 'temperature': arbitrary_values_temp.isel(time=1)} + +#transport_model.update(update_concentration) + From eb40ac399136d1bb89322795d9575a92a6521edf Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 25 Jul 2024 10:15:46 -0500 Subject: [PATCH 32/41] update getting started notebook --- examples/01_getting_started_riverine.ipynb | 1418 ++++++++++++++++++-- 1 file changed, 1274 insertions(+), 144 deletions(-) diff --git a/examples/01_getting_started_riverine.ipynb b/examples/01_getting_started_riverine.ipynb index 56e51ba..7421bfd 100644 --- a/examples/01_getting_started_riverine.ipynb +++ b/examples/01_getting_started_riverine.ipynb @@ -48,22 +48,538 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 18, "id": "891feb6f-d0eb-4285-90d4-167a3863ddd7", "metadata": {}, "outputs": [ { "data": { - "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.4'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.8/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.8/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.8/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.4.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.4.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.4.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.4.min.js\", \"https://cdn.holoviz.org/panel/1.3.8/dist/panel.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", - "application/vnd.holoviews_load.v0+json": "" + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " var force = true;\n", + " var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n", + " var reloading = false;\n", + " var Bokeh = root.Bokeh;\n", + " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + "\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks;\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + " if (js_modules == null) js_modules = [];\n", + " if (js_exports == null) js_exports = {};\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + "\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " if (!reloading) {\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " }\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + " window._bokeh_on_load = on_load\n", + "\n", + " function on_error() {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " var skip = [];\n", + " if (window.requirejs) {\n", + " window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n", + " require([\"jspanel\"], function(jsPanel) {\n", + "\twindow.jsPanel = jsPanel\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-modal\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-tooltip\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-hint\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-layout\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-contextmenu\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"jspanel-dock\"], function() {\n", + "\ton_load()\n", + " })\n", + " require([\"gridstack\"], function(GridStack) {\n", + "\twindow.GridStack = GridStack\n", + "\ton_load()\n", + " })\n", + " require([\"notyf\"], function() {\n", + "\ton_load()\n", + " })\n", + " root._bokeh_is_loading = css_urls.length + 9;\n", + " } else {\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", + " }\n", + "\n", + " var existing_stylesheets = []\n", + " var links = document.getElementsByTagName('link')\n", + " for (var i = 0; i < links.length; i++) {\n", + " var link = links[i]\n", + " if (link.href != null) {\n", + "\texisting_stylesheets.push(link.href)\n", + " }\n", + " }\n", + " for (var i = 0; i < css_urls.length; i++) {\n", + " var url = css_urls[i];\n", + " if (existing_stylesheets.indexOf(url) !== -1) {\n", + "\ton_load()\n", + "\tcontinue;\n", + " }\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n", + " var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n", + " for (var i = 0; i < urls.length; i++) {\n", + " skip.push(urls[i])\n", + " }\n", + " } var existing_scripts = []\n", + " var scripts = document.getElementsByTagName('script')\n", + " for (var i = 0; i < scripts.length; i++) {\n", + " var script = scripts[i]\n", + " if (script.src != null) {\n", + "\texisting_scripts.push(script.src)\n", + " }\n", + " }\n", + " for (var i = 0; i < js_urls.length; i++) {\n", + " var url = js_urls[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (var i = 0; i < js_modules.length; i++) {\n", + " var url = js_modules[i];\n", + " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.src = url;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " for (const name in js_exports) {\n", + " var url = js_exports[name];\n", + " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", + "\tif (!window.requirejs) {\n", + "\t on_load();\n", + "\t}\n", + "\tcontinue;\n", + " }\n", + " var element = document.createElement('script');\n", + " element.onerror = on_error;\n", + " element.async = false;\n", + " element.type = \"module\";\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " element.textContent = `\n", + " import ${name} from \"${url}\"\n", + " window.${name} = ${name}\n", + " window._bokeh_on_load()\n", + " `\n", + " document.head.appendChild(element);\n", + " }\n", + " if (!js_urls.length && !js_modules.length) {\n", + " on_load()\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n", + " var js_modules = [];\n", + " var js_exports = {};\n", + " var css_urls = [];\n", + " var inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {} // ensure no trailing comma for IE\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if ((root.Bokeh !== undefined) || (force === true)) {\n", + " for (var i = 0; i < inline_js.length; i++) {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " }\n", + " // Cache old bokeh versions\n", + " if (Bokeh != undefined && !reloading) {\n", + "\tvar NewBokeh = root.Bokeh;\n", + "\tif (Bokeh.versions === undefined) {\n", + "\t Bokeh.versions = new Map();\n", + "\t}\n", + "\tif (NewBokeh.version !== Bokeh.version) {\n", + "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + "\t}\n", + "\troot.Bokeh = Bokeh;\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " }\n", + " root._bokeh_is_initializing = false\n", + " }\n", + "\n", + " function load_or_wait() {\n", + " // Implement a backoff loop that tries to ensure we do not load multiple\n", + " // versions of Bokeh and its dependencies at the same time.\n", + " // In recent versions we use the root._bokeh_is_initializing flag\n", + " // to determine whether there is an ongoing attempt to initialize\n", + " // bokeh, however for backward compatibility we also try to ensure\n", + " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", + " // before older versions are fully initialized.\n", + " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " root._bokeh_is_initializing = false;\n", + " root._bokeh_onload_callbacks = undefined;\n", + " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", + " load_or_wait();\n", + " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", + " setTimeout(load_or_wait, 100);\n", + " } else {\n", + " Bokeh = root.Bokeh;\n", + " bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + " root._bokeh_is_initializing = true\n", + " root._bokeh_onload_callbacks = []\n", + " if (!reloading && (!bokeh_loaded || is_dev)) {\n", + "\troot.Bokeh = undefined;\n", + " }\n", + " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", + "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + "\trun_inline_js();\n", + " });\n", + " }\n", + " }\n", + " // Give older versions of the autoload script a head-start to ensure\n", + " // they initialize before we start loading newer version.\n", + " setTimeout(load_or_wait, 100)\n", + "}(window));" + ], + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" }, "metadata": {}, "output_type": "display_data" }, { "data": { - "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", - "application/vnd.holoviews_load.v0+json": "" + "application/javascript": [ + "\n", + "if ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n", + " window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n", + "}\n", + "\n", + "\n", + " function JupyterCommManager() {\n", + " }\n", + "\n", + " JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n", + " if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " comm_manager.register_target(comm_id, function(comm) {\n", + " comm.on_msg(msg_handler);\n", + " });\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n", + " comm.onMsg = msg_handler;\n", + " });\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " console.log(message)\n", + " var content = {data: message.data, comm_id};\n", + " var buffers = []\n", + " for (var buffer of message.buffers || []) {\n", + " buffers.push(new DataView(buffer))\n", + " }\n", + " var metadata = message.metadata || {};\n", + " var msg = {content, buffers, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " })\n", + " }\n", + " }\n", + "\n", + " JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n", + " if (comm_id in window.PyViz.comms) {\n", + " return window.PyViz.comms[comm_id];\n", + " } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n", + " var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n", + " var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n", + " if (msg_handler) {\n", + " comm.on_msg(msg_handler);\n", + " }\n", + " } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n", + " var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n", + " comm.open();\n", + " if (msg_handler) {\n", + " comm.onMsg = msg_handler;\n", + " }\n", + " } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n", + " var comm_promise = google.colab.kernel.comms.open(comm_id)\n", + " comm_promise.then((comm) => {\n", + " window.PyViz.comms[comm_id] = comm;\n", + " if (msg_handler) {\n", + " var messages = comm.messages[Symbol.asyncIterator]();\n", + " function processIteratorResult(result) {\n", + " var message = result.value;\n", + " var content = {data: message.data};\n", + " var metadata = message.metadata || {comm_id};\n", + " var msg = {content, metadata}\n", + " msg_handler(msg);\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " return messages.next().then(processIteratorResult);\n", + " }\n", + " }) \n", + " var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n", + " return comm_promise.then((comm) => {\n", + " comm.send(data, metadata, buffers, disposeOnDone);\n", + " });\n", + " };\n", + " var comm = {\n", + " send: sendClosure\n", + " };\n", + " }\n", + " window.PyViz.comms[comm_id] = comm;\n", + " return comm;\n", + " }\n", + " window.PyViz.comm_manager = new JupyterCommManager();\n", + " \n", + "\n", + "\n", + "var JS_MIME_TYPE = 'application/javascript';\n", + "var HTML_MIME_TYPE = 'text/html';\n", + "var EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\n", + "var CLASS_NAME = 'output';\n", + "\n", + "/**\n", + " * Render data to the DOM node\n", + " */\n", + "function render(props, node) {\n", + " var div = document.createElement(\"div\");\n", + " var script = document.createElement(\"script\");\n", + " node.appendChild(div);\n", + " node.appendChild(script);\n", + "}\n", + "\n", + "/**\n", + " * Handle when a new output is added\n", + " */\n", + "function handle_add_output(event, handle) {\n", + " var output_area = handle.output_area;\n", + " var output = handle.output;\n", + " if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + " var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + " if (id !== undefined) {\n", + " var nchildren = toinsert.length;\n", + " var html_node = toinsert[nchildren-1].children[0];\n", + " html_node.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var scripts = [];\n", + " var nodelist = html_node.querySelectorAll(\"script\");\n", + " for (var i in nodelist) {\n", + " if (nodelist.hasOwnProperty(i)) {\n", + " scripts.push(nodelist[i])\n", + " }\n", + " }\n", + "\n", + " scripts.forEach( function (oldScript) {\n", + " var newScript = document.createElement(\"script\");\n", + " var attrs = [];\n", + " var nodemap = oldScript.attributes;\n", + " for (var j in nodemap) {\n", + " if (nodemap.hasOwnProperty(j)) {\n", + " attrs.push(nodemap[j])\n", + " }\n", + " }\n", + " attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n", + " newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n", + " oldScript.parentNode.replaceChild(newScript, oldScript);\n", + " });\n", + " if (JS_MIME_TYPE in output.data) {\n", + " toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n", + " }\n", + " output_area._hv_plot_id = id;\n", + " if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n", + " window.PyViz.plot_index[id] = Bokeh.index[id];\n", + " } else {\n", + " window.PyViz.plot_index[id] = null;\n", + " }\n", + " } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " var bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " var script_attrs = bk_div.children[0].attributes;\n", + " for (var i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + "function handle_clear_output(event, handle) {\n", + " var id = handle.cell.output_area._hv_plot_id;\n", + " var server_id = handle.cell.output_area._bokeh_server_id;\n", + " if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n", + " var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n", + " if (server_id !== null) {\n", + " comm.send({event_type: 'server_delete', 'id': server_id});\n", + " return;\n", + " } else if (comm !== null) {\n", + " comm.send({event_type: 'delete', 'id': id});\n", + " }\n", + " delete PyViz.plot_index[id];\n", + " if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n", + " var doc = window.Bokeh.index[id].model.document\n", + " doc.clear();\n", + " const i = window.Bokeh.documents.indexOf(doc);\n", + " if (i > -1) {\n", + " window.Bokeh.documents.splice(i, 1);\n", + " }\n", + " }\n", + "}\n", + "\n", + "/**\n", + " * Handle kernel restart event\n", + " */\n", + "function handle_kernel_cleanup(event, handle) {\n", + " delete PyViz.comms[\"hv-extension-comm\"];\n", + " window.PyViz.plot_index = {}\n", + "}\n", + "\n", + "/**\n", + " * Handle update_display_data messages\n", + " */\n", + "function handle_update_output(event, handle) {\n", + " handle_clear_output(event, {cell: {output_area: handle.output_area}})\n", + " handle_add_output(event, handle)\n", + "}\n", + "\n", + "function register_renderer(events, OutputArea) {\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " var toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[0]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " events.on('output_added.OutputArea', handle_add_output);\n", + " events.on('output_updated.OutputArea', handle_update_output);\n", + " events.on('clear_output.CodeCell', handle_clear_output);\n", + " events.on('delete.Cell', handle_clear_output);\n", + " events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n", + "\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " safe: true,\n", + " index: 0\n", + " });\n", + "}\n", + "\n", + "if (window.Jupyter !== undefined) {\n", + " try {\n", + " var events = require('base/js/events');\n", + " var OutputArea = require('notebook/js/outputarea').OutputArea;\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " } catch(err) {\n", + " }\n", + "}\n" + ], + "application/vnd.holoviews_load.v0+json": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n" }, "metadata": {}, "output_type": "display_data" @@ -96,17 +612,18 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" ], "text/plain": [ - ":Curve [time] (concentration)" + ":Curve [time] (water_temp_c)" ] }, - "execution_count": 13, + "execution_count": 19, "metadata": { "application/vnd.holoviews_exec.v0+json": { - "id": "p1013" + "id": "p1081" } }, "output_type": "execute_result" @@ -1828,7 +2865,7 @@ "source": [ "# plot full time horizon for a single cell\n", "hv.Curve(\n", - " transport_model.mesh.concentration.isel(nface=281)\n", + " transport_model.mesh.water_temp_c.isel(nface=281)\n", ")" ] }, @@ -1842,7 +2879,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "id": "62af62f4-209d-43d9-8c1c-425f50d7ae3c", "metadata": {}, "outputs": [], @@ -1853,7 +2890,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 21, "id": "cf3e2799-506f-49da-84fe-49cc65e13169", "metadata": {}, "outputs": [ @@ -1866,17 +2903,18 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" ], "text/plain": [ - ":Curve [time] (concentration)" + ":Curve [time] (water_temp_c)" ] }, - "execution_count": 15, + "execution_count": 21, "metadata": { "application/vnd.holoviews_exec.v0+json": { - "id": "p1087" + "id": "p1151" } }, "output_type": "execute_result" @@ -1948,7 +2986,7 @@ "source": [ "# plot full time horizon\n", "hv.Curve(\n", - " transport_model.mesh.concentration.isel(nface=281)\n", + " transport_model.mesh.water_temp_c.isel(nface=281)\n", ")" ] }, @@ -1967,31 +3005,115 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "id": "b1041752-3748-419a-831d-385077b7d22e", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sjordan\\OneDrive - LimnoTech\\Documents\\GitHub\\ClearWater-riverine\\src\\clearwater_riverine\\transport.py:528: UserWarning: No constituent name defined. Plotting water_temp_c.\n", + " warnings.warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.07 s, sys: 310 ms, total: 1.38 s\n", - "Wall time: 1.48 s\n" + "CPU times: total: 2.59 s\n", + "Wall time: 2.66 s\n" ] }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9c6c0e5486bc4d648c229fde8351380d", - "version_major": 2, - "version_minor": 0 - }, + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], "text/plain": [ - "BokehModel(combine_events=True, render_bundle={'docs_json': {'ad0b7d93-3584-454e-ba9b-2d80319133b9': {'version…" + ":DynamicMap [datetime]\n", + " :Overlay\n", + " .Polygons.I :Polygons [Longitude,Latitude] (water_temp_c,cell)\n", + " .WMTS.I :WMTS [Longitude,Latitude]" ] }, - "execution_count": 16, - "metadata": {}, + "execution_count": 22, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1221" + } + }, "output_type": "execute_result" } ], @@ -2010,6 +3132,14 @@ "source": [ "Using the time scrubber to the right, we can see how the temperature changes spatially over time. We see the cool water entering the domain from the creek at the first bend, and the warm water entering from the powerplant into the oxbow lake. The cool and warm water mixes." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81fbe020-d372-4a18-856d-b844efd45cd8", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -2028,7 +3158,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.6" } }, "nbformat": 4, From cdfcfeb51cd886c7bea10d661d7162ce37bae389 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 25 Jul 2024 10:17:33 -0500 Subject: [PATCH 33/41] update getting started --- examples/01_getting_started_riverine.ipynb | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/examples/01_getting_started_riverine.ipynb b/examples/01_getting_started_riverine.ipynb index 7421bfd..4334302 100644 --- a/examples/01_getting_started_riverine.ipynb +++ b/examples/01_getting_started_riverine.ipynb @@ -1761,6 +1761,14 @@ ")" ] }, + { + "cell_type": "markdown", + "id": "1d7c6195-4cda-4ff2-8c6f-bd640a72480d", + "metadata": {}, + "source": [ + "**Note:** models can alternatively get instantiated with a config file. See [02_coupling_riverine_modules.ipynb](./02_coupling_riverine_modules.ipynb) for an example instantiating using this method." + ] + }, { "cell_type": "markdown", "id": "310a8d2c-8193-46c5-b609-534242841404", From 35eda42915f4046d42e88ff262ac9b095814008a Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 25 Jul 2024 10:46:04 -0500 Subject: [PATCH 34/41] update getting started to larger mesh --- examples/01_getting_started_riverine.ipynb | 933 +++++++++++---------- 1 file changed, 472 insertions(+), 461 deletions(-) diff --git a/examples/01_getting_started_riverine.ipynb b/examples/01_getting_started_riverine.ipynb index 4334302..06462cd 100644 --- a/examples/01_getting_started_riverine.ipynb +++ b/examples/01_getting_started_riverine.ipynb @@ -33,7 +33,18 @@ "The downstream boundary is a constant stage set at 20.75 m. The upstream inflows have a water temperature of 15 degrees C; the spring-fed creek has constant inflows of 5 C, and the powerplant is steady at 20 C with periodic higher temperature (25 C) discharges in a downstream meander.\n", "\n", "### Data Availability\n", - "All data required run this notebook is available at this [Google Drive](https://drive.google.com/drive/folders/1I_di8WrK95QwBga-W8iuJaJJMZsnIYSS?usp=drive_link). Please download the entire folder and place it in the `data_temp` folder of this repository to run the rest of the notebook." + "All data required run this notebook is available at this [Google Drive](https://drive.google.com/drive/folders/19uCjAJPZh4g6r1ZWzk1D_B8jZGluSc4N?usp=drive_link). \n", + "This notebook will use the `sumwere_creek_coarse_p48` model. Please download the entire folder and place it in the `data_temp` folder of this repository to run the rest of the notebook. Alternatively, if you would like to run a different version of the model (see the [ReadMe](https://docs.google.com/document/d/1FKjrTZHUYmYxo0mgn72dOezHtq-CFR86rQ1ObD1ZY0c/edit) for details), download that folder, place it in the `datat_temp` folder, and define the name of the mesh folder below:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "beea827a-e533-40a6-8b0e-200e893d5752", + "metadata": {}, + "outputs": [], + "source": [ + "model_name = 'sumwere_creek_coarse_p48'" ] }, { @@ -48,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 2, "id": "891feb6f-d0eb-4285-90d4-167a3863ddd7", "metadata": {}, "outputs": [ @@ -263,7 +274,7 @@ " document.body.appendChild(element);\n", " }\n", "\n", - " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n", + " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\"];\n", " var js_modules = [];\n", " var js_exports = {};\n", " var css_urls = [];\n", @@ -331,7 +342,7 @@ " setTimeout(load_or_wait, 100)\n", "}(window));" ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.11.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.3.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var is_dev = py_version.indexOf(\"+\") !== -1 || py_version.indexOf(\"-\") !== -1;\n var reloading = false;\n var Bokeh = root.Bokeh;\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {'jspanel': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/jspanel', 'jspanel-modal': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal', 'jspanel-tooltip': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip', 'jspanel-hint': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint', 'jspanel-layout': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout', 'jspanel-contextmenu': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu', 'jspanel-dock': 'https://cdn.jsdelivr.net/npm/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock', 'gridstack': 'https://cdn.jsdelivr.net/npm/gridstack@7.2.3/dist/gridstack-all', 'notyf': 'https://cdn.jsdelivr.net/npm/notyf@3/notyf.min'}, 'shim': {'jspanel': {'exports': 'jsPanel'}, 'gridstack': {'exports': 'GridStack'}}});\n require([\"jspanel\"], function(jsPanel) {\n\twindow.jsPanel = jsPanel\n\ton_load()\n })\n require([\"jspanel-modal\"], function() {\n\ton_load()\n })\n require([\"jspanel-tooltip\"], function() {\n\ton_load()\n })\n require([\"jspanel-hint\"], function() {\n\ton_load()\n })\n require([\"jspanel-layout\"], function() {\n\ton_load()\n })\n require([\"jspanel-contextmenu\"], function() {\n\ton_load()\n })\n require([\"jspanel-dock\"], function() {\n\ton_load()\n })\n require([\"gridstack\"], function(GridStack) {\n\twindow.GridStack = GridStack\n\ton_load()\n })\n require([\"notyf\"], function() {\n\ton_load()\n })\n root._bokeh_is_loading = css_urls.length + 9;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } if (((window['jsPanel'] !== undefined) && (!(window['jsPanel'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/jspanel.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/modal/jspanel.modal.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/tooltip/jspanel.tooltip.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/hint/jspanel.hint.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/layout/jspanel.layout.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/contextmenu/jspanel.contextmenu.js', 'https://cdn.holoviz.org/panel/1.3.1/dist/bundled/floatpanel/jspanel4@4.12.0/dist/extensions/dock/jspanel.dock.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['GridStack'] !== undefined) && (!(window['GridStack'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/gridstack/gridstack@7.2.3/dist/gridstack-all.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } if (((window['Notyf'] !== undefined) && (!(window['Notyf'] instanceof HTMLElement))) || window.requirejs) {\n var urls = ['https://cdn.holoviz.org/panel/1.3.1/dist/bundled/notificationarea/notyf@3/notyf.min.js'];\n for (var i = 0; i < urls.length; i++) {\n skip.push(urls[i])\n }\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.3.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.3.1.min.js\", \"https://cdn.holoviz.org/panel/1.3.1/dist/panel.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n Bokeh = root.Bokeh;\n bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n if (!reloading && (!bokeh_loaded || is_dev)) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" }, "metadata": {}, "output_type": "display_data" @@ -612,12 +623,12 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" - ], - "text/plain": [ - "Column\n", - " [0] HoloViews(DynamicMap, height=700, sizing_mode='fixed', widget_location='bottom', width=800)\n", - " [1] WidgetBox(align=('center', 'end'))\n", - " [0] DiscreteSlider(margin=(20, 20, 20, 20), name='datetime', options=OrderedDict([('2022-05-13 ...]), value=numpy.datetime64('2022-05-..., width=250)" - ] - }, - "execution_count": 38, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "p2390" - } - }, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "plot_to_save" ] From 7b8a131a806f6302017a3fc67e9d275a344dca95 Mon Sep 17 00:00:00 2001 From: Sarah Jordan Date: Thu, 25 Jul 2024 12:34:51 -0500 Subject: [PATCH 39/41] update dynamic viz --- examples/02_coupling_riverine_modules.ipynb | 103 +++++++++++++++++++- 1 file changed, 100 insertions(+), 3 deletions(-) diff --git a/examples/02_coupling_riverine_modules.ipynb b/examples/02_coupling_riverine_modules.ipynb index 8055717..1729c67 100644 --- a/examples/02_coupling_riverine_modules.ipynb +++ b/examples/02_coupling_riverine_modules.ipynb @@ -3599,7 +3599,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "7937eec0-e050-43ff-8a3c-57bbb72abfc0", "metadata": {}, "outputs": [], @@ -3623,10 +3623,107 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "id": "b62985fb-0876-4bf8-b79e-a5a30a8731f7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.holoviews_exec.v0+json": "", + "text/html": [ + "
\n", + "
\n", + "
\n", + "" + ], + "text/plain": [ + "Column\n", + " [0] HoloViews(DynamicMap, height=700, sizing_mode='fixed', widget_location='bottom', width=800)\n", + " [1] WidgetBox(align=('center', 'end'))\n", + " [0] DiscreteSlider(margin=(20, 20, 20, 20), name='datetime', options=OrderedDict([('2022-05-13 ...]), value=numpy.datetime64('2022-05-..., width=250)" + ] + }, + "execution_count": 43, + "metadata": { + "application/vnd.holoviews_exec.v0+json": { + "id": "p1946" + } + }, + "output_type": "execute_result" + } + ], "source": [ "plot_to_save" ] From 0cb011753618128bfa920606ed25c4b6eb1bd83f Mon Sep 17 00:00:00 2001 From: Jason M Rutyna Date: Thu, 25 Jul 2024 13:49:46 -0400 Subject: [PATCH 40/41] tested riverine and NSM coupling with latest commits to Clearwater Modules main branch --- .../04_coupling_riverine_NSM_modules.ipynb | 35023 ++++++++-------- 1 file changed, 17411 insertions(+), 17612 deletions(-) diff --git a/examples/04_coupling_riverine_NSM_modules.ipynb b/examples/04_coupling_riverine_NSM_modules.ipynb index 7a3d710..5302d1b 100644 --- a/examples/04_coupling_riverine_NSM_modules.ipynb +++ b/examples/04_coupling_riverine_NSM_modules.ipynb @@ -45,227 +45,18 @@ "execution_count": 1, "id": "c280997b-7e02-4079-b8fe-707a0729ed86", "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.1'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.1.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.1.min.js\", \"https://cdn.holoviz.org/panel/1.4.2/dist/panel.min.js\", \"https://cdn.jsdelivr.net/npm/@holoviz/geoviews@1.12.0/dist/geoviews.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));", - "application/vnd.holoviews_load.v0+json": "" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": "\nif ((window.PyViz === undefined) || (window.PyViz instanceof HTMLElement)) {\n window.PyViz = {comms: {}, comm_status:{}, kernels:{}, receivers: {}, plot_index: []}\n}\n\n\n function JupyterCommManager() {\n }\n\n JupyterCommManager.prototype.register_target = function(plot_id, comm_id, msg_handler) {\n if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n comm_manager.register_target(comm_id, function(comm) {\n comm.on_msg(msg_handler);\n });\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n window.PyViz.kernels[plot_id].registerCommTarget(comm_id, function(comm) {\n comm.onMsg = msg_handler;\n });\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n google.colab.kernel.comms.registerTarget(comm_id, (comm) => {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n console.log(message)\n var content = {data: message.data, comm_id};\n var buffers = []\n for (var buffer of message.buffers || []) {\n buffers.push(new DataView(buffer))\n }\n var metadata = message.metadata || {};\n var msg = {content, buffers, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n })\n }\n }\n\n JupyterCommManager.prototype.get_client_comm = function(plot_id, comm_id, msg_handler) {\n if (comm_id in window.PyViz.comms) {\n return window.PyViz.comms[comm_id];\n } else if (window.comm_manager || ((window.Jupyter !== undefined) && (Jupyter.notebook.kernel != null))) {\n var comm_manager = window.comm_manager || Jupyter.notebook.kernel.comm_manager;\n var comm = comm_manager.new_comm(comm_id, {}, {}, {}, comm_id);\n if (msg_handler) {\n comm.on_msg(msg_handler);\n }\n } else if ((plot_id in window.PyViz.kernels) && (window.PyViz.kernels[plot_id])) {\n var comm = window.PyViz.kernels[plot_id].connectToComm(comm_id);\n comm.open();\n if (msg_handler) {\n comm.onMsg = msg_handler;\n }\n } else if (typeof google != 'undefined' && google.colab.kernel != null) {\n var comm_promise = google.colab.kernel.comms.open(comm_id)\n comm_promise.then((comm) => {\n window.PyViz.comms[comm_id] = comm;\n if (msg_handler) {\n var messages = comm.messages[Symbol.asyncIterator]();\n function processIteratorResult(result) {\n var message = result.value;\n var content = {data: message.data};\n var metadata = message.metadata || {comm_id};\n var msg = {content, metadata}\n msg_handler(msg);\n return messages.next().then(processIteratorResult);\n }\n return messages.next().then(processIteratorResult);\n }\n }) \n var sendClosure = (data, metadata, buffers, disposeOnDone) => {\n return comm_promise.then((comm) => {\n comm.send(data, metadata, buffers, disposeOnDone);\n });\n };\n var comm = {\n send: sendClosure\n };\n }\n window.PyViz.comms[comm_id] = comm;\n return comm;\n }\n window.PyViz.comm_manager = new JupyterCommManager();\n \n\n\nvar JS_MIME_TYPE = 'application/javascript';\nvar HTML_MIME_TYPE = 'text/html';\nvar EXEC_MIME_TYPE = 'application/vnd.holoviews_exec.v0+json';\nvar CLASS_NAME = 'output';\n\n/**\n * Render data to the DOM node\n */\nfunction render(props, node) {\n var div = document.createElement(\"div\");\n var script = document.createElement(\"script\");\n node.appendChild(div);\n node.appendChild(script);\n}\n\n/**\n * Handle when a new output is added\n */\nfunction handle_add_output(event, handle) {\n var output_area = handle.output_area;\n var output = handle.output;\n if ((output.data == undefined) || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n return\n }\n var id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n if (id !== undefined) {\n var nchildren = toinsert.length;\n var html_node = toinsert[nchildren-1].children[0];\n html_node.innerHTML = output.data[HTML_MIME_TYPE];\n var scripts = [];\n var nodelist = html_node.querySelectorAll(\"script\");\n for (var i in nodelist) {\n if (nodelist.hasOwnProperty(i)) {\n scripts.push(nodelist[i])\n }\n }\n\n scripts.forEach( function (oldScript) {\n var newScript = document.createElement(\"script\");\n var attrs = [];\n var nodemap = oldScript.attributes;\n for (var j in nodemap) {\n if (nodemap.hasOwnProperty(j)) {\n attrs.push(nodemap[j])\n }\n }\n attrs.forEach(function(attr) { newScript.setAttribute(attr.name, attr.value) });\n newScript.appendChild(document.createTextNode(oldScript.innerHTML));\n oldScript.parentNode.replaceChild(newScript, oldScript);\n });\n if (JS_MIME_TYPE in output.data) {\n toinsert[nchildren-1].children[1].textContent = output.data[JS_MIME_TYPE];\n }\n output_area._hv_plot_id = id;\n if ((window.Bokeh !== undefined) && (id in Bokeh.index)) {\n window.PyViz.plot_index[id] = Bokeh.index[id];\n } else {\n window.PyViz.plot_index[id] = null;\n }\n } else if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n var bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n var script_attrs = bk_div.children[0].attributes;\n for (var i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].childNodes[1].setAttribute(script_attrs[i].name, script_attrs[i].value);\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n}\n\n/**\n * Handle when an output is cleared or removed\n */\nfunction handle_clear_output(event, handle) {\n var id = handle.cell.output_area._hv_plot_id;\n var server_id = handle.cell.output_area._bokeh_server_id;\n if (((id === undefined) || !(id in PyViz.plot_index)) && (server_id !== undefined)) { return; }\n var comm = window.PyViz.comm_manager.get_client_comm(\"hv-extension-comm\", \"hv-extension-comm\", function () {});\n if (server_id !== null) {\n comm.send({event_type: 'server_delete', 'id': server_id});\n return;\n } else if (comm !== null) {\n comm.send({event_type: 'delete', 'id': id});\n }\n delete PyViz.plot_index[id];\n if ((window.Bokeh !== undefined) & (id in window.Bokeh.index)) {\n var doc = window.Bokeh.index[id].model.document\n doc.clear();\n const i = window.Bokeh.documents.indexOf(doc);\n if (i > -1) {\n window.Bokeh.documents.splice(i, 1);\n }\n }\n}\n\n/**\n * Handle kernel restart event\n */\nfunction handle_kernel_cleanup(event, handle) {\n delete PyViz.comms[\"hv-extension-comm\"];\n window.PyViz.plot_index = {}\n}\n\n/**\n * Handle update_display_data messages\n */\nfunction handle_update_output(event, handle) {\n handle_clear_output(event, {cell: {output_area: handle.output_area}})\n handle_add_output(event, handle)\n}\n\nfunction register_renderer(events, OutputArea) {\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n var toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[0]);\n element.append(toinsert);\n return toinsert\n }\n\n events.on('output_added.OutputArea', handle_add_output);\n events.on('output_updated.OutputArea', handle_update_output);\n events.on('clear_output.CodeCell', handle_clear_output);\n events.on('delete.Cell', handle_clear_output);\n events.on('kernel_ready.Kernel', handle_kernel_cleanup);\n\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n safe: true,\n index: 0\n });\n}\n\nif (window.Jupyter !== undefined) {\n try {\n var events = require('base/js/events');\n var OutputArea = require('notebook/js/outputarea').OutputArea;\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n } catch(err) {\n }\n}\n", - "application/vnd.holoviews_load.v0+json": "" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ] - }, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "p1009" - } - }, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "\n", - "
\n", - "\n", - "\n", - "\n", - " \n", - " \n", - "\n", - "\n", - "\n", - "\n", - "
\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from pathlib import Path\n", "import logging\n", "import numpy as np\n", "import pandas as pd\n", "import xarray as xr\n", - "import holoviews as hv\n", - "import geoviews as gv\n", + "#import holoviews as hv\n", + "#import geoviews as gv\n", "# from holoviews import opts\n", - "import panel as pn\n", - "hv.extension(\"bokeh\")" + "#import panel as pn\n", + "#hv.extension(\"bokeh\")" ] }, { @@ -395,12 +186,12 @@ "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ - "
\n", - "
\n", + "
\n", + "
\n", "
\n", "" - ], + "application/vnd.jupyter.widget-view+json": { + "model_id": "71a340f1223242f89b90864b15a5f5e7", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - ":DynamicMap [datetime]\n", - " :Overlay\n", - " .Polygons.I :Polygons [Longitude,Latitude] (temperature,cell)\n", - " .WMTS.I :WMTS [Longitude,Latitude]" + "BokehModel(combine_events=True, render_bundle={'docs_json': {'bde5c132-63db-4cd9-ab3b-4b31ef5649b1': {'version…" ] }, - "execution_count": 32, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "p1009" - } - }, + "execution_count": 25, + "metadata": {}, "output_type": "execute_result" } ], @@ -3273,7 +2145,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 26, "id": "6dc19e97-9725-4f80-864b-2d034623314a", "metadata": {}, "outputs": [], @@ -3286,7 +2158,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 27, "id": "8cae6e61-9877-447d-bece-7b7dacfd3851", "metadata": {}, "outputs": [], @@ -3310,7 +2182,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 28, "id": "95fb690b", "metadata": {}, "outputs": [], @@ -3320,8 +2192,8 @@ "ras_map = gv.Polygons(\n", " ras_sub_df,\n", " vdims=['temperature', 'cell']).opts(\n", - " height = 800,\n", - " width = 800,\n", + " height = 400,\n", + " width = 400,\n", " color='Temperature',\n", " cmap='RdYlBu_r',\n", " line_width = 0.1,\n", @@ -3342,7 +2214,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 29, "id": "f5b8a690", "metadata": {}, "outputs": [], @@ -3361,7 +2233,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 30, "id": "5b2c8431-06e6-44ca-8f5a-6f2ffae4f51b", "metadata": {}, "outputs": [], @@ -3372,15 +2244,15 @@ " if x != None and y != None:\n", " # identify cell number and pull concentration timeseries for that cell\n", " cell = clicked_data['cell'].iloc[0]\n", - " cs = ds.temperature.isel(nface=cell, time=slice(0, TIME_STEPS))\n", + " cs = ds.temperature.isel(nface=cell, time=slice(0, time_steps))\n", "\n", " # Create timeseries plot\n", " curve = hv.Curve(\n", " cs,\n", " ).opts(\n", " title=f'Time series',\n", - " height=800,\n", - " width=800,\n", + " height=400,\n", + " width=400,\n", " line_width=5,\n", " fontsize= {'title': 18, 'labels': 16, 'xticks': 12, 'yticks': 12},\n", " ylabel= 'Water Temperature (C)'\n", @@ -3396,8 +2268,8 @@ " empty_curve = hv.Curve((xs,-(xs-2)**2)).opts(\n", " title=f'Time series',\n", " line_color='white',\n", - " height=800, \n", - " width=800,\n", + " height=400, \n", + " width=400,\n", " xaxis=None,\n", " yaxis=None,\n", " )* hv.Text(0, -20, \"Please click a cell on the map to display a timeseries.\")\n", @@ -3417,17 +2289,17 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 31, "id": "bf70743d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Watcher(inst=Button(button_type='primary', name='Reset'), cls=, fn=, mode='args', onlychanged=False, parameter_names=('clicks',), what='value', queued=False, precedence=0)" + "Watcher(inst=Button(button_type='primary', name='Reset'), cls=, fn=, mode='args', onlychanged=False, parameter_names=('clicks',), what='value', queued=False, precedence=0)" ] }, - "execution_count": 38, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -3452,104 +2324,23 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 32, "id": "1c1661ac-e670-4752-ae8f-8889bf81288a", "metadata": {}, "outputs": [ - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ], + "application/vnd.jupyter.widget-view+json": { + "model_id": "6f7ad73bf1b046638d275d1b93605a92", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "Row\n", - " [0] HoloViews(Polygons, height=800, sizing_mode='fixed', width=800)\n", - " [1] HoloViews(DynamicMap, height=800, sizing_mode='fixed', width=800)\n", - " [2] Button(button_type='primary', name='Reset')" + "BokehModel(combine_events=True, render_bundle={'docs_json': {'67aa45b8-7332-4c64-836c-ac2592a03bbb': {'version…" ] }, - "execution_count": 39, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "p1464" - } - }, + "execution_count": 32, + "metadata": {}, "output_type": "execute_result" } ], @@ -3575,7 +2366,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 33, "id": "8fbb429e-0939-4513-9f35-a893f22f109c", "metadata": {}, "outputs": [], @@ -3587,7 +2378,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 34, "id": "9d7bb0cb-32fd-4f96-916d-a084e60e4e6a", "metadata": {}, "outputs": [], @@ -3599,7 +2390,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 35, "id": "7937eec0-e050-43ff-8a3c-57bbb72abfc0", "metadata": {}, "outputs": [], @@ -3613,8 +2404,8 @@ " cmap='RdYlBu_r',\n", " clabel='Water Temperature (C)',\n", " line_width = 0.1,\n", - " height=700,\n", - " width=800,\n", + " height=400,\n", + " width=500,\n", " widget_location='bottom',\n", " line_color='white',\n", " \n", @@ -3623,104 +2414,23 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 36, "id": "b62985fb-0876-4bf8-b79e-a5a30a8731f7", "metadata": {}, "outputs": [ - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": {}, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "application/vnd.holoviews_exec.v0+json": "", - "text/html": [ - "
\n", - "
\n", - "
\n", - "" - ], + "application/vnd.jupyter.widget-view+json": { + "model_id": "21326336314648668fd1ba38d9ec6ce0", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "Column\n", - " [0] HoloViews(DynamicMap, height=700, sizing_mode='fixed', widget_location='bottom', width=800)\n", - " [1] WidgetBox(align=('center', 'end'))\n", - " [0] DiscreteSlider(margin=(20, 20, 20, 20), name='datetime', options=OrderedDict([('2022-05-13 ...]), value=numpy.datetime64('2022-05-..., width=250)" + "BokehModel(combine_events=True, render_bundle={'docs_json': {'3405a12d-5bca-494a-aefb-6d67a2263e8f': {'version…" ] }, - "execution_count": 43, - "metadata": { - "application/vnd.holoviews_exec.v0+json": { - "id": "p1946" - } - }, + "execution_count": 36, + "metadata": {}, "output_type": "execute_result" } ], @@ -3735,6 +2445,12 @@ "source": [ "plot_to_save.save(filename='data_temp/output.html', embed=True)" ] + }, + { + "cell_type": "raw", + "id": "166af9ad", + "metadata": {}, + "source": [] } ], "metadata": { @@ -3753,7 +2469,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.11.9" } }, "nbformat": 4,