From 197c10a481f4ec472ad2a5b26cd2c2803de171fc Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Tue, 25 Jun 2024 18:22:26 -0500
Subject: [PATCH 1/8] Added nonh features

---
 notes.md                          |  60 +++
 setup.py                          |   2 +-
 xbTools/general/dict_utils.py     |  42 ++
 xbTools/general/executing_runs.py |  90 +++-
 xbTools/general/file_utils.py     |  25 ++
 xbTools/general/geometry.py       |   1 -
 xbTools/general/wave_functions.py |   3 +-
 xbTools/grid/creation.py          |  25 +-
 xbTools/grid/grid_check.py        |   5 +-
 xbTools/xbeachpost.py             |  19 +-
 xbTools/xbeachtools.py            | 684 ++++++++++++++++++++++--------
 11 files changed, 749 insertions(+), 207 deletions(-)
 create mode 100644 notes.md
 create mode 100644 xbTools/general/dict_utils.py
 create mode 100644 xbTools/general/file_utils.py

diff --git a/notes.md b/notes.md
new file mode 100644
index 0000000..b817aaf
--- /dev/null
+++ b/notes.md
@@ -0,0 +1,60 @@
+# Notes on xBeach-ToolBox
+
+## Folders
+
+### General
+
+1) deg2uv.py
+
+This script contains one function that converts degrees to u,v vectors and the reverse
+
+Functions:
+    * deg2uv - converts degrees to u, v vectors
+    * uv2deg - converts u, v vectors to degrees
+
+2) executing_runs.py
+   * xb_run_script_win     - Create batch script to run simulations. (Not sure exactly what this is doing. Especially what the N parameter does)
+   * generate_batch_script - generates a batch script for a xbeach model
+   * run_batch_script      - Runs a batch script. current not working all the way
+  
+3) geometry.py
+   * rotate                - rotates a vecotor through the origin that is set by the user
+   * rotate_grid           - Rotates a grid
+   * grid_world2local      - Figures out the rotation of a grid and then returns it in local coordinates
+   * samples_to_local_grid - shifts a vector and then rotates it
+   * in_polygon            - Checks whether a set of coordinates are in a polygon
+   * get_points_in_polygon - Returns True for points in polygon and Returns False for points outside of the polygon - May replace in_polygon in the future
+   * path_distance         - Computes the distance along a polyline
+   * 
+
+4) visualize_mesh.py
+   * plot_mesh                - Plot the mesh based on the meshgrid regular grid - **Uses **kwargs to feed inputs into the plotting functions. This is a good idea**
+   * write_mesh_to_shp        - Convert mesh to shapefile
+   * grid_parameter_to_shape  - Saves a paramter defined at a grid point to a shapefile
+  
+5) wave_functions
+   * dispersion                - Computes the wave nuber given a radial frequency and water depth
+   * wavecelerity              - Computes the group velocity and wave celerity ratio
+   * directional_spread_kuik   - Determine mean wave direction and directional spreading
+   * celertiry_ratio_equals_09 - Function to find water depth for which the n ratio equal 0.9
+   * offshore_depth            - Compute the required offshore depth to correctly force the waves
+
+### grid
+
+6) creation.py
+   * xgrid                 - Compute spatially varying grid based on the local wave length
+   * ygrid                 - function to setup a basic ygrid array
+   * grid_transition       - Function for grid transition from one cell to the other. (Still not sure what this means)
+
+7) extension.py
+   * lateral_extend        - Extend the model domain at both laterial sides with n number of cells
+   * seaward_extend        - Compute the seaward extend of the bathymery based on an artificial  slope and required offshore depth
+
+8) grid_check.py
+   * diff                  - Computes the difference in subsequent items
+   * smoothness            - Perform grid checks based on D3D-quickin procedure for smoothness in m and n-direction and stores figures
+   * aspect_ratio          - Perform grid checks based on D3D-quickin procedure
+   * orthogonality         - Perform grid checks based on D3D-quickin procedure for orthogonality and stores figures
+
+9) refinement.py
+   * grid_refine_grid      - refines the grid with the factor xfactor in xdirection and yfactor in y direction
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 9d13776..e8fdae9 100644
--- a/setup.py
+++ b/setup.py
@@ -13,6 +13,6 @@
       license='GNU General Public License v3.0',
       packages=['xbTools','xbTools.grid','xbTools.general'],
       package_data={'': ['*.json']}, # always include .json files in the package contents
-      python_requires='>=3, <4',
+      python_requires='>=3.1, <4',
       install_requires=['numpy','matplotlib>=3.5.0','netCDF4>=1.6.0','scipy>=1.10.0','datetime','geopandas>=0.13.0','shapely>=2.0.0','fiona>=1.9.4.post1','pytest'],
       zip_safe=False)
diff --git a/xbTools/general/dict_utils.py b/xbTools/general/dict_utils.py
new file mode 100644
index 0000000..bfe05ff
--- /dev/null
+++ b/xbTools/general/dict_utils.py
@@ -0,0 +1,42 @@
+# dict_utils.py
+
+def check_keys_exist(dict1, dict2):
+    """
+    Check if all keys from dict1 are present in dict2.
+
+    Parameters:
+    - dict1 (dict): Dictionary to check keys.
+    - dict2 (dict): Dictionary to check against.
+
+    Returns:
+    - bool: True if all keys from dict1 are in dict2, False otherwise.
+    """
+    return all(key in dict2 for key in dict1)
+
+def check_strings_in_dict(list_of_strings, dict_strings):
+    """
+    Check if all strings in list_of_strings are present as values in dict_strings.
+
+    Parameters:
+    - list_of_strings (list): List of strings to check.
+    - dict_strings (dict): Dictionary with string values.
+
+    Returns:
+    - bool: True if all strings in list_of_strings are in dict_strings, False otherwise.
+    """
+    dict_values = set(dict_strings.values())
+    return all(string in dict_values for string in list_of_strings)
+
+# Other utility functions can go here if needed
+# def other_utility_function():
+#     pass
+
+# Test for the code
+if __name__ == "__main__":
+    dict1 = {'a': 1, 'b': 2, 'c': 3}
+    dict2 = {'a': 10, 'b': 20, 'c': 30, 'd': 40}
+
+    print(check_keys_exist(dict1, dict2))  # Output: True
+
+    dict3 = {'a': 10, 'c': 30}
+    print(check_keys_exist(dict1, dict3))  # Output: False
diff --git a/xbTools/general/executing_runs.py b/xbTools/general/executing_runs.py
index 999a995..05a3d4d 100644
--- a/xbTools/general/executing_runs.py
+++ b/xbTools/general/executing_runs.py
@@ -7,6 +7,7 @@
 # import python modules
 import os
 import numpy as np
+import subprocess
 
 from xbTools.xbeachtools import XBeachModelSetup
 
@@ -20,9 +21,9 @@ def xb_run_script_win(xb, N, maindir, xbeach_exe):
         list with simulation paths or XBeachModelSetup class
     N : int
         Number of batch scripts.
-    maindir : TYPE
+    maindir : string
         path where run script is created.
-    xbeach_exe : TYPE
+    xbeach_exe : string
         path of XBeach executable.
 
     Returns
@@ -44,6 +45,8 @@ def xb_run_script_win(xb, N, maindir, xbeach_exe):
         path_sims = [xb.model_path]
     
     ## number of batch scripts
+    # TODO: This will cause an error if a string is passed into this function. This would return the length of the string divided by the N
+    # TODO: Don't think this makes any sense
     Nmax = int(np.ceil(len(path_sims)/N))
     
     ## string
@@ -63,5 +66,84 @@ def xb_run_script_win(xb, N, maindir, xbeach_exe):
         print(os.path.join(maindir,'run{}.bat'.format(run_number)))
         with open(os.path.join(maindir,'run{}.bat'.format(run_number)), 'w') as f:
             f.write(string)
-   
-    
\ No newline at end of file
+
+def generate_batch_script(model_folder, exe_path, batch_file_name = "run_model.bat", include_cd = False, batch_file_folder = None):
+    """
+    Generates an batch script inside of the model directory, linking to the exe_path
+    
+    Parameters
+    ----------
+    model_folder: string
+        Directory to the model that the batch script should be created for
+    
+    exe_path: string
+        Directory to the executable that should be linked to in the batch file
+    
+    batch_file_name: string (Optional)
+        Name of the batch script that should be generated. Defaults to "run_model.bat"
+    
+    include_cd: Boolean (Optional)
+        Controls if a "cd {model directory}" statement is included in the batch file.
+
+    batch_file_folder: string (Optional)
+        Input a directory that should hold the batch file. This overrides including the file inside of the model folder
+        NOTE: This causes include_cd to be True
+    Returns
+    -------
+    None.
+    
+    """
+
+    if batch_file_folder is None:
+        # Make the batch file path
+        batch_file_path = os.path.join(model_folder, batch_file_name)
+    
+    else:
+        # Make the include_cd statement true, because for the batch file to be saved in a different directory than the model it will have to cd into
+        # that directory
+        include_cd = True
+        batch_file_path = os.path.join(batch_file_folder)
+
+    # init empty string to possibly hold the change directory statement
+    cd_str = ""
+
+    if include_cd:
+        cd_str = "cd \"{}\"".format(model_folder)
+
+    # Make the string that will be written to the file
+    batch_str = cd_str + "call \"{}\"".format(exe_path)
+
+    # Create the file and open it in write mode
+    with open(batch_file_path, "w") as f:
+        # write the string to the batch file
+        f.write(batch_str)
+
+def run_batch_script(batch_script_path):
+    # TODO: Need to test this some more. There are some troubles when the permissions 
+    """
+    Run a batch script given a path
+    
+    Parameters
+    ----------
+    batch_script_path : string
+        The path to a batch script that the user wants to run. This will cause the script to be run inside of the python script
+
+    Returns
+    -------
+    None.
+
+    TODO: There's some trouble that when this is imported it tends to not work. When it is directly in the .ipynb file it works fine.
+    TODO: Note sure what's going on with it
+    '''
+    """
+
+    # Run the batch file
+    try:
+        subprocess.run(batch_script_path, check=True, shell=True)
+        print(f"Batch file '{batch_script_path}' executed successfully.")
+    except subprocess.CalledProcessError as e:
+        # If not succcessful catch the error and print to the python script
+        print(f"An error occurred while executing the batch file: {e}")
+
+if __name__ == "__main__":
+    pass
diff --git a/xbTools/general/file_utils.py b/xbTools/general/file_utils.py
new file mode 100644
index 0000000..dd68474
--- /dev/null
+++ b/xbTools/general/file_utils.py
@@ -0,0 +1,25 @@
+"""
+Functions that help you output or work with files
+"""
+
+def write_2d_arr_2_file(arr, file_path, decimal_digits=3):
+    """
+    Writes a 2d array into a file with each row of the 2d array written as a row in the file.
+
+    Inputs:
+        file_path      : Name of the file that the data should be written to.
+        arr            : 2d array that should be written to the file.
+        decimal_digits : Number of decimal digits to format the elements in the array (default is 2).
+    """
+
+    # Create a format string based on the number of decimal digits
+    format_str = f"{{:.{decimal_digits}f}}"
+
+    # Open the file in write mode
+    with open(file_path, 'w') as file:
+        # Write each row of the array to the file
+        for row in arr:
+            formatted_row = ' '.join(format_str.format(value) for value in row)
+            file.write(formatted_row + '\n')
+
+
diff --git a/xbTools/general/geometry.py b/xbTools/general/geometry.py
index 33384e4..065d0bd 100644
--- a/xbTools/general/geometry.py
+++ b/xbTools/general/geometry.py
@@ -46,7 +46,6 @@ def rotate(x, y, theta, origin = [0,0]):
 
     return xrot.reshape(ny, nx)+x0, yrot.reshape(ny, nx)+y0
 
-
 def rotate_grid(xgr, ygr, theta):
     '''
     Rotate_grid(xgr,ygr,theta)
diff --git a/xbTools/general/wave_functions.py b/xbTools/general/wave_functions.py
index 3b479e1..190fe27 100644
--- a/xbTools/general/wave_functions.py
+++ b/xbTools/general/wave_functions.py
@@ -8,7 +8,7 @@
 
 def dispersion(w, d, max_error=0.00001,g=9.81):
     '''
-    Computes the wave number given a radial frequeny and water depth
+    Computes the wave number given a radial frequency and water depth
 
     Parameters
     ----------
@@ -46,7 +46,6 @@ def dispersion(w, d, max_error=0.00001,g=9.81):
         print ('Warning: no convergence')
     return k 
 
-
 def wavecelerity(Tp, d, g=9.81):
     '''
     Computes the group velocity and wave celerity ratio based on the wave period and water depth.
diff --git a/xbTools/grid/creation.py b/xbTools/grid/creation.py
index c4d734c..36c1c16 100644
--- a/xbTools/grid/creation.py
+++ b/xbTools/grid/creation.py
@@ -196,7 +196,6 @@ def xgrid(x,z,
         xgr = xgr-xgr[-1]+xend
     return xgr, zgr
 
-
 def ygrid(y,
            dymin = 5,
            dymax = 20,
@@ -283,15 +282,27 @@ def ygrid(y,
     return ygr 
 
 def grid_transition(cell1, cell2, distance):
-    
     """
-    function for grid_transition from one cell to the other
+    Function for grid transition from one cell to the other.
+
+    Parameters:
+        cell1 (float): Size of cell 1.
+        cell2 (float): Size of cell 2.
+        distance (float): Distance to transition over.
 
     Returns:
-        ff, nf, gridf, error 
-    
-    #todo improve docstring and syntax of code
-    """  
+        tuple: Tuple containing:
+            ff (np.ndarray): Array of scaling factors.
+            nf (int): Number of grid points.
+            gridf (list): List of grid points.
+            error (float): Error in transition.
+
+    Notes:
+        - This function calculates the transition grid between two cells.
+        - Adjusts the grid transition based on distance.
+
+    # TODO: Improve the syntax of this function and the docstring
+    """
 
     precision = 1e-10
     maxloop = 1e2
diff --git a/xbTools/grid/grid_check.py b/xbTools/grid/grid_check.py
index 1906acf..d71add8 100644
--- a/xbTools/grid/grid_check.py
+++ b/xbTools/grid/grid_check.py
@@ -11,6 +11,9 @@
 
 def diff(A,direc = 0):
     '''
+    NOTE: There's a built in numpy function to do this: np.diff( "vector or matrix")
+    Link: https://numpy.org/doc/stable/reference/generated/numpy.diff.html
+    
     Computes the difference in subsequent items
     A is either a vector or a 2D matrix
     if A is a matrix, 
@@ -69,7 +72,7 @@ def smoothness(x, y, outputloc = ''):
     '''
     Perform grid checks based on D3D-quickin procedure for 
     smoothness in m and n-direction and stores figures
-    note that it is advisable to use local coordinate system!
+    NOTE: It is advisable to use local coordinate system!
     Author: Cas van Bemmelen
     Date: 26-06-2023
     
diff --git a/xbTools/xbeachpost.py b/xbTools/xbeachpost.py
index 7d297d3..b555694 100644
--- a/xbTools/xbeachpost.py
+++ b/xbTools/xbeachpost.py
@@ -32,8 +32,8 @@ def __init__(self, fname, model_path):
         """_summary_
 
         Args:
-            fname (_type_): _description_
-            model_path (_type_): _description_
+            fname (string): File name - Doesn't seem to be used for anything
+            model_path (string): Path to folder containing file
         """        
         self.fname = fname
         self.model_path = model_path
@@ -60,7 +60,6 @@ def __init__(self, fname, model_path):
                           'u_max', 'v_max', 'ue_max', 've_max', 'Subg_max', 'Svbg_max', 'Susg_max', 'Svsg_max',
                           'u_min', 'v_min', 'ue_min', 've_min', 'Subg_min', 'Svbg_min', 'Susg_min', 'Svsg_min']
 
-
     def get_metadata(self):
         '''
         function to print metadata from XBlog.txt
@@ -147,6 +146,8 @@ def get_params(self):
 
         # read params from params file
         params = {}
+        # TODO: This get's caught up when there's an equal sign in a comment. Should check if there's a 
+                # comment sign on the line before trying to unpack values
         for d in dat:
             if '=' in d:
                 x1, x2 = d.split('=')
@@ -291,7 +292,6 @@ def get_wind(self):
             self.wind['time'] = dat[:, 0]
             self.wind['u10'] = dat[:, 1]
             self.wind['u10dir'] = dat[:, 2]
-
             
     def load_model_setup(self):
         """_summary_
@@ -302,7 +302,6 @@ def load_model_setup(self):
         self.get_vegetation()
         self.get_tide()
 
-
     def load_output_coordinates(self):
         """_summary_
 
@@ -425,6 +424,7 @@ def load_modeloutput(self, var):
             var (_type_): _description_
         """        
         if var in self.var:
+            print("Variable already loaded")
             return
 
         if '_mean' in var:
@@ -438,7 +438,10 @@ def load_modeloutput(self, var):
         elif 'point_' in var:
             assert sum([var[6:] in x for x in self.params['pointvar']]) > 0, '{} not in xb output'
         else:
-            assert sum([var in x for x in self.params['globalvar']]) > 0, '{} not in xb output'
+            # Check if the variable is one of the outputted global variables from the model
+            if var not in self.params['globalvar']:
+                raise IndexError("Variable is not an available globalvar output." + 
+                                 " The available outputs are {}".format(self.params["globalvar"]))
 
         # if not yet present, load coordinates
         if self.var == {}:
@@ -518,7 +521,6 @@ def get_modeloutput_by_station(self, var, station):
 
         return self.var['pointtime'][:Nt-1], self.var[var][:Nt-1, index]
 
-
     def _mdates_concise_subplot_axes(self, ax):
         """_summary_
 
@@ -533,7 +535,6 @@ def _mdates_concise_subplot_axes(self, ax):
         except:
             ax.xaxis.set_major_formatter(formatter)
 
-
     def fig_check_tide_bc(self):
         """_summary_
 
@@ -889,8 +890,6 @@ def fig_map_diffvar(self, var, label, it0=0, itend=np.inf, clim=None, figsize=No
             plt.savefig(os.path.join(self.model_path, 'fig', 'difmap_{}_it_{}-{}.png'.format(var, itend, it0)), dpi=200)
         return fig, ax
 
-
-    
     def fig_cross_var(self,var, it, iy=None, itype=None, coord=None, plot_ref_bathy=True, figax = None, zmin=-25, ylim=None, fmt='.-'):
         """_summary_
 
diff --git a/xbTools/xbeachtools.py b/xbTools/xbeachtools.py
index 64ead13..8a2383b 100644
--- a/xbTools/xbeachtools.py
+++ b/xbTools/xbeachtools.py
@@ -18,13 +18,16 @@
 from .general.geometry import rotate_grid
 from .general.deg2uv import deg2uv
 
+# Dictionary functions
+from xbTools.general.file_utils import write_2d_arr_2_file
+
 class XBeachModelSetup():
     '''
     XBeach model setup class
     ''' 
     
-    def __init__(self,fname):
-        self.fname      = fname
+    def __init__(self,file_name):
+        self.file_name      = file_name
         ## by default set wbctype and wavemodel to None
         self.wbctype    = None
         self.wavemodel  = None
@@ -34,21 +37,28 @@ def __init__(self,fname):
         self.model_path = None
         self.friction_layer = None
         self.wavefriction_layer = None
+
+        # WaveHello Added these 
+        self.wavefriction = None
+        self.friction = None
+        self.nebed = None
+
         self.struct = None
         
-    def __repr__(self):
+    def __str__(self):
         """_summary_
 
         Returns:
-            _type_: _description_
+            file_name (string): Name of the xBeach model file
         """        
-        return self.fname
+        return self.file_name
     
     def set_params(self,input_par_dict):
-        """_summary_
+        """
+        Sets the wavemodel and any of the parameters in the par.json file (?) for the model
 
         Args:
-            input_par_dict (_type_): _description_
+            input_par_dict (dict): dict of input param flags and the associated values
         """        
         ## set wavemodel. Default is Surfbeat
         if 'wavemodel' not in input_par_dict:
@@ -61,28 +71,37 @@ def set_params(self,input_par_dict):
         if 'wbctype' in input_par_dict:
             self.wbctype = input_par_dict['wbctype'] 
 
-
         ## load parameters and categories
+        # Open the par.json file in read mode
         f           = open(os.path.join(os.path.dirname(__file__), 'par.json'),'r')
+
+        # Read the json file and store it as a python dict
         par_dict    = json.loads(f.read())
+        
         ## create input dict
         self.input_par = {}
+
+        # Init 'par' key as a nested dict
         self.input_par['par'] = {}
+
         ## loop over input parameters 
-        
         for input_par in input_par_dict:
             value_added = False
-            ## loop over categories
+
+            ## loop over categories from the par.json file
             for par_category in par_dict:
                 ## if input parameter is in category, add parameter
                 if input_par in par_dict[par_category]:
                     ## create category if not exist
                     if not par_category in self.input_par:
                         self.input_par[par_category] = {}
+                        
                     ## add parameter and value                    
                     self.input_par[par_category][input_par] = input_par_dict[input_par]
                     value_added = True
+
             if not value_added:
+                # Add all parameters that don't match a key in the par.json file to this new dict
                 self.input_par['par'][input_par] = input_par_dict[input_par]
             
     def set_grid(self,xgr,ygr,zgr, posdwn=1, xori=0, yori=0,alfa=0, thetamin=-90, thetamax = 90, thetanaut = 0, dtheta=10, dtheta_s=10):
@@ -197,27 +216,173 @@ def set_wavefriction(self, wavefriction, wavefriction_layer = 1):
         self.wavefriction = wavefriction
         self.wavefriction_layer = wavefriction_layer
 
-    def set_waves(self,wbctype, input_struct):
-        """_summary_
+    @staticmethod
+    def _get_wbctype_required_params(wbctype):
+        """
+        Returns the required inputs for the selcted wbctype.
+        NOTE: This is only for the new boundary conditions
+        
+        Inputs:
+            wbctype (string): One of the selected instat boundary condtion types
+
+            Possible inputs for wbctype are: 
+
+            swan: XBeach can read standard SWAN 2D variance density or energy density output files (+.sp2 files) as specified in the SWAN v40.51 manual. 
+            
+            vardens: 2D spectral information that is not in SWAN format can be provided using a formatted variance density spectrum file
+            
+            off: 
+            
+            jonstable:  Each line in the spectrum definition file contains a parametric definition of a spectrum, 
+                         like in a regular JONSWAP definition file, plus the duration for which that spectrum is used during the simulation.
+            
+            reuse: makes XBeach reuse wave time series that were generated during a previous simulation. 
+                   This can be a simulation using the same or a different model as long as the computational grids are identical
+            
+            ts_1: First-order time series of waves (keyword insat = ts_1). 
+                  XBeach will calculate the bound long wave based on the theory of [LHS64]).
+            
+            ts_2: Second-order time series of waves (keyword insat = ts_2). 
+                  The bound long wave is specified by the user via a long wave elevation.
+            
+            
+            ts_nonh: Requires a boundary condition file that contains free surface elevations and velocities (both in u and v).
+                     Possible input values are z (surf. elevation), t, u, v, w, dU, dV, q (discharge), dq
+
+            parametric: 
+        """
+
+        # Using False to note that the required parameters haven't been included here yet
+        wbctype_options = {'swan'        : False,
+                          'vardens'      : False,
+                           'off'         : False,
+                           'jonstable'   : ['Hm0','Tp','mainang','gammajsp','s','duration','dtbc'],
+                           'resuse'      : False, 
+                           'ts_1'        : False, 
+                           'ts_2'        : False, 
+                           'ts_nonh'     : ["boun_U_dict"],
+                           'parametric': ['Hm0','Tp','mainang','gammajsp','s','fnyq']
+                           }
+
+        try:
+            required_params = wbctype_options[wbctype]
+        except KeyError as error:
+            raise KeyError("Input: {} is not an option for wbctype conditions.\
+                           Possible options are: {}".format(wbctype, wbctype_options.keys()))
+        
+        if required_params is False:
+            raise ValueError(" Option is valid but, writing {} not implemented yet".format(wbctype))
+        
+        return required_params
+    
+    @staticmethod
+    def _get_instat_required_params(instat_type):
+        """
+        Returns the required inputs for the input boundary condition
+
+        NOTE: This is only for the old boundary condition type - instat
+
+        Inputs:
+            instat_type (string): One of the selected instat boundary condtion types
+
+            Possible inputs for instat_type are:
+            bichrom: 
+
+            ts_1: First-order time series of waves (keyword insat = ts_1). 
+                  XBeach will calculate the bound long wave based on the theory of [LHS64]).
+            
+            ts_2: Second-order time series of waves (keyword insat = ts_2). 
+                  The bound long wave is specified by the user via a long wave elevation.
+            
+            jons : A JONSWAP wave spectrum is parametrically defined in a file that is referenced using the bcfile keyword. 
+                  This file contains a single parameter per line in arbitrary order.
+            
+            swan: XBeach can read standard SWAN 2D variance density or energy density output files (+.sp2 files) as specified in the SWAN v40.51 manual. 
+            
+            vardens: 2D spectral information that is not in SWAN format can be provided using a formatted variance density spectrum file
+            
+            reuse: makes XBeach reuse wave time series that were generated during a previous simulation. 
+                   This can be a simulation using the same or a different model as long as the computational grids are identical
+            
+            ts_nonh: Requires a boundary condition file that contains free surface elevations and velocities (both in u and v).
+                     Possible input values are z (surf. elevation), t, u, v, w, dU, dV, q (discharge), dq
+            off: 
+            stat_table: Only in case of insat = stat_table the time-varying stationary wave boundary conditions are fully described
+                       in an external file referenced by the bcfile keyword.
+            jonstable:  Each line in the spectrum definition file contains a parametric definition of a spectrum, 
+                         like in a regular JONSWAP definition file, plus the duration for which that spectrum is used during the simulation.
+        """
 
+        # Using False to note that the required parameters haven't been included here yet
+        instat_type_options = {
+                                'bichrom'     : False,
+                                'ts_1'        : False, 
+                                'ts_2'        : False, 
+                                'jons'        : False,
+                                'swan'        : False,
+                                'vardens'     : False,
+                                'resuse'      : False, 
+                                'ts_nonh'     : ["boun_U_dict"],
+                                'off'         : False,
+                                'stat_table'  : ['Hm0','Tp','mainang','gammajsp','s','duration','dtbc'],
+                                'jonstable '  : ['Hm0','Tp','mainang','gammajsp','s','fnyq']
+                                }
+
+        try:
+            required_params = instat_type_options[instat_type]
+        except KeyError as error:
+            raise KeyError("Input: {} is not an option for instat_type conditions.\
+                           Possible options are: {}".format(instat_type, instat_type_options.keys()))
+        
+        if required_params is False:
+            raise ValueError(" Option is valid but, writing {} not implemented yet".format(instat_type))
+        
+        return required_params
+
+    def set_waves(self, wbctype, input_struct, instat_bc = False):
+        """
+
+        Gets the required inputs for the selected boundary condition and stores the values in a dict for 
+        later output. 
+   
         Args:
-            wbctype (_type_): _description_
-            input_struct (_type_): _description_
+            wbctype (string)   : String input that selects one of the boundary condition options
+            input_struct (dict): Dict contains the information
+            instat_bc (bool): Flag for if the old boundary conditions should be used (Defaults to False)
+        
+        Calls:
+            _get_wbctype_required_params: To get the required params for the wbctype boundary conditions
+            _get_instat_required_params : To get the required params for the instat boundary conditions
+
+        See the called functions for more information on the boundary conditions
         """        
         self.wbctype = wbctype
-        ##
-        if wbctype=='jonstable':
-            required_par = ['Hm0','Tp','mainang','gammajsp','s','duration','dtbc']
-        elif wbctype=='parametric':
-            required_par = ['Hm0','Tp','mainang','gammajsp','s','fnyq']
-        else:
-            assert False, 'Wrong wbctype'
         
+        # Get the thr requried input parameters
+
+        if not instat_bc:
+            # Use the wbctype conditions
+            required_par = self._get_wbctype_required_params(wbctype)
+
+        elif instat_bc:
+            # Use the instat conditions
+            required_par = self._get_instat_required_params(wbctype)
+
+        # Store the required parameters for later usage
+        self.required_wbc_params = required_par
+
+        # Init dict to hold the waves_boundary conditions
         self.waves_boundary  = {}
+                            
+        # Loop over the required parameters...
         for item in required_par:
-            assert item in input_struct, '{} missing'.format(item)
-            self.waves_boundary[item] =  input_struct[item]
+            # Check that the required param is in the input_struct
+            if item not in input_struct:
+                raise KeyError("Required parameter: {} isn't found in input_struct. Required parameters are: {}".format(item, required_par))
             
+            # If param is in input string add it to waves_boundary dict for later output
+            self.waves_boundary[item] =  input_struct[item]
+        
     def set_vegetation(self):
         """_summary_
         """        
@@ -281,7 +446,6 @@ def set_tide(self, zs0, optional_par_input = {}):
 
         # TODO check that zs0file is at least as long as end time of simulation
 
-        
     def load_model_setup(self,path):
         """_summary_
 
@@ -291,181 +455,339 @@ def load_model_setup(self,path):
         ## todo
         pass    
 
-    def write_model(self, path, figure=True):
-        """_summary_
-
-        Args:
-            path (_type_): _description_
-            figure (bool, optional): _description_. Defaults to True.
-        """        
-        self.model_path = path
-        path_params = os.path.join(path,'params.txt')
-        
-        assert os.path.exists(path), '{} does not exist'.format(path)
+    def _write_boun_U_file(self, path, boun_U_dict):
+        """
+        Writes the boundary conditon file that is required for ts_nonh models
         
+        Inputs:
+            self:
+            path (string)     : Path to where the file should be written
+            boun_U_dict (dict): Dictionary that contains the data needed to make the boun_U.bcf
+            file_name (string): Name of the boun_U file. This shouldn't need to change but just in case
         
-        current_date    = datetime.today().strftime('%Y-%m-%d %HH:%mm')
-        user            =  os.path.basename(os.path.expanduser('~'))
+        Below is an example of what the boun_U_dict should contain
+        boun_U_dict = {"make_file": "Boolean",
+                       "file_name": "boun_U.bcf",
+                       "dimension": "scalar or vector",
+                       "variable_dict": {
+                           "t" : "time array",
+                           "U" : "U-velocity data",
+                           "V" : "V-Velocity data",
+                           "W" : "W-Velocity data",
+                           "dU": "dU data",
+                           "dV": "dV data",
+                           "q" : "q data",
+                           "dq": "dq data"
+                       }         
+            }
+
+        Info:
+            make_file (string)  : Used to determine if the boun_U should be created
+            file_name (string)  : Name of the boun_U.bcf file
+            variable_dict (dict): Dictionary of variable names that xBeach expects and the associated data.
+                                  NOTE: Not all of the variables have to be provided the above is just an example 
+                                  of what could happen.
+
+        """
         
-        tabnumber = 20
+        variable_dict = boun_U_dict["variable_dict"]
+
+        # Make a list of the allowed variables names
+        allowed_variable_names = ['z','zs','t', 'u', 'v', 'w','du', 'dv', 'q', 'dq']
+
+        # Get the variable names
+        variable_names = list(boun_U_dict["variable_dict"].keys())
+
+        # Convert them to lower case
+        lowercase_variables = [item.lower() for item in variable_names]
+
+        # Check that all the variables are in the name
+        mask_list = [item in allowed_variable_names for item in lowercase_variables]
+
+        # Check if there any input variables that aren't allowed
+        if not all(mask_list):
+            # Apply the mask to the inputs and get the input vars that aren't allowed
+            not_allowed_vars = [item for item, mask in zip(variable_names, mask_list) if not mask]
+
+            raise ValueError("Input variable(s): {} are not allowed. \
+                             Allowed variables are: {}".format(not_allowed_vars, allowed_variable_names))
         
-        ## waves boundary
-        if self.wbctype=='parametric':
-            if 'Wave boundary condition parameters' in self.input_par:
-                self.input_par['Wave boundary condition parameters']['bcfile'] = 'jonswap.txt'
-            else:
-               self.input_par['Wave boundary condition parameters'] = {}
-               self.input_par['Wave boundary condition parameters']['bcfile'] = 'jonswap.txt'
-            required_par = ['Hm0','Tp','mainang','gammajsp','s','fnyq']
-            with open(os.path.join(path,'jonswap.txt'),'w') as f:
-                for par in required_par:
-                    f.write('{}\t= {}\n'.format(par,self.waves_boundary[par]).expandtabs(tabnumber))
+        # Now that the variables are checked generate the file
+        file_path =  os.path.join(path, boun_U_dict["file_name"])
+
+        # Loop over the data and stack it together
+        data = np.column_stack([variable_dict[key] for key in variable_dict.keys()])
+
+        string_variables = " ".join(variable_names)
+        num_variables = len(variable_names)
+
+        # Write the header and the data to a file
+        with open(file_path, 'w') as file:
+            file.write("{}\n".format(boun_U_dict["dimension"]))
+            file.write("{}\n".format(num_variables))
+            file.write("{}\n".format(string_variables))
+            np.savetxt(file, data, delimiter=' ', fmt='%10.5f')
+
+        print("Data written to {}".format(file_path))
+
+    def _write_jonswap_file(self, path, tab_number, file_name = "jonswap.txt"):
+        """
+        Write the jonswap file
+
+        Inputs:
+            self: The current object
+            path (string)     : Path that the file should be written into
+            tab_number (int)  : Length of the tab used to seperate data in non-table files
+            file_name (string): Name of the jonswap file
+        """
+
+        # TODO: Add other boundary conditions that use the jonswap.txt file
+        write_table_dict = {
+            'parametric': False,
+            'jonstable' : True
+        }
+
+        # Check if the  jonswap should be a table or a single entry of values
+        try:
+            write_table = write_table_dict[self.wbctype]
+        except KeyError as error:
+            raise KeyError("Input wbctype: {} doesn't currently support writing a jonswap file. \
+                           The conditons that are implemented are: {}".format(self.wbctype, write_table.keys()))
+
+        # Store the name of the boundary condition file
+        self.waves_boundary["bcfile"] = file_name
+
+        # Open the jonswap file and write the data...
+        with open(os.path.join(path, file_name), 'w') as f:
+            # Writing if the data isn't a table
+            if not write_table:
+                for param in self.required_wbc_params:
+                    f.write('{}\t= {}\n'.format(param, self.waves_boundary[param]).expandtabs(tab_number))
+            
+            # Writing if the data is a table
+            elif write_table:
+                #TODO: Think of a more elegant way to do this that is more future proof
+                # Get number of entries under the first key
+                num_vals = len(self.waves_boundary['Hm0'])
                 
-        elif self.wbctype=='jonstable':
-            if 'Wave boundary condition parameters' in self.input_par:
-                self.input_par['Wave boundary condition parameters']['bcfile'] = 'jonstable.txt'
-            else:
-               self.input_par['Wave boundary condition parameters'] = {}
-               self.input_par['Wave boundary condition parameters']['bcfile'] = 'jonstable.txt'                
-            required_par = ['Hm0','Tp','mainang','gammajsp','s','duration','dtbc']
-            with open(os.path.join(path,'jonstable.txt'),'w') as f:
-                for ii in range(len(self.waves_boundary['Hm0'])):
-                    for par in required_par:
-                        f.write('{} '.format(self.waves_boundary[par][ii]))
+                # Loop over each row of the table...
+                for i in range(num_vals):
+                    # Write the param vals into each column
+                    for param in self.required_wbc_params:
+                        f.write('{} '.format(self.waves_boundary[param][i]))
+                    
+                    # Set up the next row
                     f.write('\n')
+    
+    def _write_wbc_file(self, path):
+        """
+        Wrapper for the functions that write the files that are needed for the wave boundary conditons
+        """ 
+
+        tab_number = 20
         
+        # Modes that require the boun_U_dict file
+        if self.wbctype == "ts_nonh":
+            boun_U_dict = self.required_wbc_params["boun_U_dict"]
+
+            # Check if the file should be created...
+            if boun_U_dict["make_file"]:
+                # If True make the file
+                self._write_boun_U_file(path, boun_U_dict)
+
+        # wbctypes that require the jonswap.txt file
+        elif self.wbctype == "parametric" or self.wbctype == "jonstable":
+            self._write_jonswap_file(path, tab_number, file_name = "jonswap.txt")
+
+        else:
+            raise Warning("Writing the files for wbctype: {} is not implemented".format(self.wbctype))
+    
+    @staticmethod
+    def _write_params_metadata(file, file_name, current_date, user):
+        """
+        Write the Meta data of the params file
+        """
+        ## Write the meta data
+        file.write('%% XBeach model: {} \n'.format(file_name))
+        file.write('%% Params created on {} \n'.format(current_date))
+        file.write('%% Params created by {} \n'.format(user))
+        file.write('\n')
+
+    @staticmethod
+    def _write_params_general_data(file, wavemodel, wbctype, tab_number):
+        """
+        Write the general data into the params file
+        """
+
+        ## general
+        file.write('%% General \n')
+        file.write('\n')
+        if wavemodel is not None:
+            file.write('wavemodel\t= {}\n'.format(wavemodel).expandtabs(tab_number))
+
+        if wbctype is not None:
+            file.write('wbctype\t= {}\n'.format(wbctype).expandtabs(tab_number))
+        file.write('\n')
+
+    def _write_params_grid_data(self, file, tab_number):
+        """
+        TODO: Check if this needs to be a internal module. 
+        For the time being this is going to be the only one that stays inside of the class"""
+        ## grid
+        file.write('%% Grid \n')
+        file.write('\n')
+        file.write('vardx\t= {}\n'.format(self.vardx).expandtabs(tab_number))
+        file.write('posdwn\t= {}\n'.format(self.posdwn).expandtabs(tab_number))
+        file.write('nx\t= {}\n'.format(self.nx).expandtabs(tab_number))
+        file.write('ny\t= {}\n'.format(self.ny).expandtabs(tab_number))
+        file.write('xori\t= {}\n'.format(self.xori).expandtabs(tab_number))
+        file.write('yori\t= {}\n'.format(self.yori).expandtabs(tab_number))
+        file.write('alfa\t= {}\n'.format(self.alfa).expandtabs(tab_number)) 
+        file.write('xfile\t= x.grd\n'.expandtabs(tab_number))
+
+        # Check that the model has a y-grid (ie. that's its 2d)
+        if not self.ygr is None:
+            file.write('yfile\t= y.grd\n'.expandtabs(tab_number))
+
+        file.write('depfile\t= bed.dep\n'.expandtabs(tab_number))
+        file.write('thetamin\t= {}\n'.format(self.thetamin).expandtabs(tab_number))
+        file.write('thetamax\t= {}\n'.format(self.thetamax).expandtabs(tab_number))
+        file.write('thetanaut\t= {}\n'.format(self.thetanaut).expandtabs(tab_number))
+        file.write('dtheta\t= {}\n'.format(self.dtheta).expandtabs(tab_number))
+        file.write('dtheta_s\t= {}\n'.format(self.dtheta).expandtabs(tab_number))
+        file.write('\n')
+
+    def _write_params_tide_data(self, file, tab_number):
+        """
+        Write the tide data to the file
+        """
+
+        file.write('%% Tide boundary conditions \n')
+        file.write('\n')     
+
+        if self.zs0type == 'par':
+            file.write('zs0\t= {}\n'.format())    
+
+        elif self.zs0type == 'list':
+            for item in self.tide_boundary:
+                if item[0] != '_':
+                    file.write('{}\t= {}\n'.format(item, self.tide_boundary[item]).expandtabs(tab_number))
+       
+        file.write('\n')
+
+    def _write_params_input_vars(self, file, tab_number):
+        """
+        Write the input variables? into the param file
+        # TODO: Check what this is doing """
+
+        for par_category in self.input_par:
+            ## skip category starting with _
+            if par_category[0]=='_':
+                continue
+            
+            ## write meta
+            file.write('%% {} \n'.format(par_category))
+            file.write('\n')
+
+            for par in self.input_par[par_category]:
+                file.write('{}\t= {}\n'.format(par,self.input_par[par_category][par]).expandtabs(tab_number))
+            file.write('\n')
+    
+    def _write_params_output_vars(self, file, tab_number):
+        """
+        Write the variables that should be output by the xBeach model into the params file"""
         
-        ## create params
+        ## write output variables
+        if '_Output' in self.input_par:
+            file.write('%% Output variables \n')
+            file.write('\n')
+            for par in self.input_par['_Output']:
+                dummy = self.input_par['_Output'][par]
+                file.write('{}\t= {}\n'.format(par,len(dummy)).expandtabs(tab_number))
+
+                if not isinstance(dummy, list):
+                    raise TypeError("Expected a list for {}".format(par))
+
+                for item in dummy:
+                    file.write('{}\n'.format(item))
+                file.write('\n')
+
+    def _write_params_file(self, path_params, current_date, user, tab_number):
+
+        """
+        Write the params file. Acts as a wrapper for other functions that actually do the writing
+        """
+
+        ## Open and create the file
         with open(path_params,'w') as f:
-            ## meta data
-            f.write('%% XBeach model: {} \n'.format(self.fname))
-            f.write('%% Params created on {} \n'.format(current_date))
-            f.write('%% Params created by {} \n'.format(user))
-            f.write('\n')
-
-            ## general
-            f.write('%% General \n')
-            f.write('\n')
-            if self.wavemodel!=None:
-                f.write('wavemodel\t= {}\n'.format(self.wavemodel).expandtabs(tabnumber))
-            if self.wbctype!=None:
-                f.write('wbctype\t= {}\n'.format(self.wbctype).expandtabs(tabnumber))
-            f.write('\n')
             
-            ## grid
-            f.write('%% Grid \n')
-            f.write('\n')
-            f.write('vardx\t= {}\n'.format(self.vardx).expandtabs(tabnumber))
-            f.write('posdwn\t= {}\n'.format(self.posdwn).expandtabs(tabnumber))
-            f.write('nx\t= {}\n'.format(self.nx).expandtabs(tabnumber))
-            f.write('ny\t= {}\n'.format(self.ny).expandtabs(tabnumber))
-            f.write('xori\t= {}\n'.format(self.xori).expandtabs(tabnumber))
-            f.write('yori\t= {}\n'.format(self.yori).expandtabs(tabnumber))
-            f.write('alfa\t= {}\n'.format(self.alfa).expandtabs(tabnumber)) 
-            f.write('xfile\t= x.grd\n'.expandtabs(tabnumber))
-            if not self.ygr is None:
-                f.write('yfile\t= y.grd\n'.expandtabs(tabnumber))
-            f.write('depfile\t= bed.dep\n'.expandtabs(tabnumber))
-            f.write('thetamin\t= {}\n'.format(self.thetamin).expandtabs(tabnumber))
-            f.write('thetamax\t= {}\n'.format(self.thetamax).expandtabs(tabnumber))
-            f.write('thetanaut\t= {}\n'.format(self.thetanaut).expandtabs(tabnumber))
-            f.write('dtheta\t= {}\n'.format(self.dtheta).expandtabs(tabnumber))
-            f.write('dtheta_s\t= {}\n'.format(self.dtheta).expandtabs(tabnumber))
-            f.write('\n')
+            # TODO: Move these functions into a util file to make this class smaller
 
-            ## tide 
-            if self.zs0type != None:
-                f.write('%% Tide boundary conditions \n')
-                f.write('\n')        
-                if self.zs0type == 'par':
-                    f.write('zs0\t= {}\n'.format())    
-                elif self.zs0type == 'list':
-                    for item in self.tide_boundary:
-                        if item[0] != '_':
-                            f.write('{}\t= {}\n'.format(item, self.tide_boundary[item]).expandtabs(tabnumber))
-                f.write('\n')
+            # Write the metadata at the top of the file
+            self._write_params_metadata(f, self.file_name, current_date, user)
 
-                
+            # Write the general data
+            self._write_params_general_data(f, self.wavemodel, self.wbctype, tab_number)
             
+            self._write_params_grid_data(f, tab_number)
+
+            ## tide 
+            if self.zs0type is not None:
+                self._write_params_tide_data(f, tab_number)
+
             ## write input vars
-            for par_category in self.input_par:
-                ## skip category starting with _
-                if par_category[0]=='_':
-                    continue
-                
-                ## write meta
-                f.write('%% {} \n'.format(par_category))
-                f.write('\n')
-                for par in self.input_par[par_category]:
-                    f.write('{}\t= {}\n'.format(par,self.input_par[par_category][par]).expandtabs(tabnumber))
-                f.write('\n')
-
-
-            ## write output variables
-            if '_Output' in self.input_par:
-                f.write('%% Output variables \n')
-                f.write('\n')
-                for par in self.input_par['_Output']:
-                    dummy = self.input_par['_Output'][par]
-                    f.write('{}\t= {}\n'.format(par,len(dummy)).expandtabs(tabnumber))
-                    assert type(dummy)==list, 'expected a list for {}'.format(par)
-                    for item in dummy:
-                        f.write('{}\n'.format(item))
-                    f.write('\n')
-    
-        ## write grid x
-        with open(os.path.join(path,'x.grd'),'w') as f:
-            xgr = np.atleast_2d(self.xgr)
-            for ii in range(self.ny+1):
-                for jj in range(self.nx+1):
-                    f.write('{:.3f} '.format(xgr[ii,jj]))
-                f.write('\n')
+            self._write_params_input_vars(f, tab_number)
 
-        if not self.ygr is None:
-            ## write grid y
-            with open(os.path.join(path,'y.grd'),'w') as f:
-                for ii in range(self.ny+1):
-                    for jj in range(self.nx+1):
-                        f.write('{:.3f} '.format(self.ygr[ii,jj]))
-                    f.write('\n')
+            # Write the output vars
+            self._write_params_output_vars(f, tab_number)
 
-       ## write dep
-        with open(os.path.join(path,'bed.dep'),'w') as f:
-            zgr = np.atleast_2d(self.zgr)
-            for ii in range(self.ny+1):
-                for jj in range(self.nx+1):
-                    f.write('{:.3f} '.format(zgr[ii,jj]))
-                f.write('\n')             
-                
-        ## write ne-layer
-        if self.struct != None:
-            nebed = np.atleast_2d(self.nebed)
-            with open(os.path.join(path,'ne_bed.dep'),'w') as f:
-                for ii in range(self.ny+1):
-                    for jj in range(self.nx+1):
-                        f.write('{} '.format(nebed[ii,jj]))
-                    f.write('\n')   
+    def write_model(self, path, figure=True):
+        """
+        Wrapper for functions that write the input files for the model
 
-        ## write bottom friction layer        
-        if self.friction_layer != None:
-            friction = np.atleast_2d(self.friction)
-            with open(os.path.join(path,'friction.dep'),'w') as f:
-                for ii in range(self.ny+1):
-                    for jj in range(self.nx+1):
-                        f.write('{:.3f} '.format(friction[ii,jj]))
-                    f.write('\n')  
-
-        ## write wave bottom friction layer            
-        if self.wavefriction_layer != None:
-            wavefriction = np.atleast_2d(self.wavefriction)
-            with open(os.path.join(path,'wavefriction.dep'),'w') as f:
-                for ii in range(self.ny+1):
-                    for jj in range(self.nx+1):
-                        f.write('{} '.format(wavefriction[ii,jj]))
-                    f.write('\n')   
+        Args:
+            path (string): _description_
+            figure (bool, optional): _description_. Defaults to True.
+        """        
+        self.model_path = path
+        path_params = os.path.join(path,'params.txt')
+        
+        # Raise an error if the file isn't found
+        if not os.path.exists(path):
+            raise FileExistsError('{} does not exist'.format(path))
+        
+        current_date    = datetime.today().strftime('%Y-%m-%d %HH:%mm')
+        user            =  os.path.basename(os.path.expanduser('~'))
+        
+        tab_number = 20
+        
+        # Write the wave boundary condition files
+        self._write_wbc_file(path)
+        
+        # Write the params file
+        self._write_params_file(path_params, current_date, user, tab_number)
+    
+        # Do a loop for the other files
+        file_arr_dict = {"x.grd": self.xgr,
+                         "y.grd": self.ygr, 
+                         "bed.dep": self.zgr,
+                         "ne_bed.dep": self.nebed,
+                         "friction.dep": self.friction,
+                         "wavefriction.dep": self.wavefriction
+                         } 
+        
+        # Loop over the dict...
+        for key, value in file_arr_dict.items():
+            # Check that the value isn't none
+            if value is not None:
+                # Treat the arr as at least 2d, this allows the 1d models to be written with the 2d func
+                value = np.atleast_2d(value)
+                
+                # Write the file
+                dummy_path = os.path.join(path, key)
+                write_2d_arr_2_file(value, dummy_path)        
 
         ## write tide boundary condition
-         
         if self.zs0type == 'list':
             with open(os.path.join(path,'tide.txt'), 'w') as f:
                 for ir in range(self.tide_boundary['_tidelen']):
@@ -593,7 +915,7 @@ def _plotdomain(self,save_path=None):
             plt.colorbar()
             plt.title('World coordinates - output')
 
-        plt.suptitle(self.fname)
+        plt.suptitle(self.file_name)
 
         if self.struct == 1:
             if not self.fast1D == True:

From 2c940bdced0ae10773d6f7c9c2230618256a5b2f Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Thu, 27 Jun 2024 09:34:03 -0500
Subject: [PATCH 2/8] Updated the params file output to largely match the order
 of the xBlog file and added params to the JSON

---
 docs/source/xbeach-setup-1D.ipynb             |   2 +-
 docs/source/xbeach-setup-2D.ipynb             |   2 +-
 examples/xbeach-setup-1D.ipynb                |  27 ++-
 examples/xbeach-setup-2D.ipynb                | 135 ++++++++-------
 .../__pycache__/doc_utilts.cpython-312.pyc    | Bin 0 -> 1497 bytes
 xbTools/doc_utilities/doc_utilts.py           |  42 +++++
 xbTools/par.json                              | 152 +++++++++++------
 xbTools/xbeachtools.py                        | 156 ++++++++++++------
 8 files changed, 347 insertions(+), 169 deletions(-)
 create mode 100644 xbTools/doc_utilities/__pycache__/doc_utilts.cpython-312.pyc
 create mode 100644 xbTools/doc_utilities/doc_utilts.py

diff --git a/docs/source/xbeach-setup-1D.ipynb b/docs/source/xbeach-setup-1D.ipynb
index c9f1fdd..259fb10 100644
--- a/docs/source/xbeach-setup-1D.ipynb
+++ b/docs/source/xbeach-setup-1D.ipynb
@@ -316,7 +316,7 @@
     "\n",
     "xb_setup.set_params({'Wavemodel':'surfbeat',\n",
     "                     'morphology':0,\n",
-    "                     'befriccoef':0.01,\n",
+    "                     'bedfriccoef':0.01,\n",
     "                     'tstop':3600,\n",
     "                     'zs0':0,\n",
     "                     'nglobalvar':['zb','zs','H'],\n",
diff --git a/docs/source/xbeach-setup-2D.ipynb b/docs/source/xbeach-setup-2D.ipynb
index 7d8c590..3881efa 100644
--- a/docs/source/xbeach-setup-2D.ipynb
+++ b/docs/source/xbeach-setup-2D.ipynb
@@ -549,7 +549,7 @@
     "\n",
     "xb_setup.set_params({'Wavemodel'    :   'surfbeat',\n",
     "                     'morphology'   :   0,\n",
-    "                     'befriccoef'   :   0.01,\n",
+    "                     'bedfriccoef'   :   0.01,\n",
     "                     'tstop'        :   3600,\n",
     "                     'zs0'          :   0,\n",
     "                     'nglobalvar'   :   ['zb', 'zs', 'H'],\n",
diff --git a/examples/xbeach-setup-1D.ipynb b/examples/xbeach-setup-1D.ipynb
index e0b7bb2..ccd6935 100644
--- a/examples/xbeach-setup-1D.ipynb
+++ b/examples/xbeach-setup-1D.ipynb
@@ -52,7 +52,18 @@
    "execution_count": 2,
    "id": "37d3f161",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\ERDC\\xbeach-toolbox\\xbTools\\xbeachtools.py:903: SyntaxWarning: invalid escape sequence '\\T'\n",
+      "  ax.text(-thetamin_uv[0], -thetamin_uv[1], '$\\Theta_{min}$ = '+f'{self.thetamin:.2f}', ha = 'left', va = 'center')\n",
+      "c:\\ERDC\\xbeach-toolbox\\xbTools\\xbeachtools.py:904: SyntaxWarning: invalid escape sequence '\\T'\n",
+      "  ax.text(-thetamax_uv[0], -thetamax_uv[1], '$\\Theta_{max}$ = '+f'{self.thetamax:.2f}', ha = 'left', va = 'center')\n"
+     ]
+    }
+   ],
    "source": [
     "## import xbeach tools\n",
     "#sys.path.append(os.path.abspath(os.path.join('..' )))\n",
@@ -90,7 +101,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -155,7 +166,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -194,7 +205,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -244,7 +255,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -323,7 +334,7 @@
     "\n",
     "xb_setup.set_params({'wavemodel':'surfbeat',\n",
     "                     'morphology':0,\n",
-    "                     'befriccoef':0.01,\n",
+    "                     'bedfriccoef':0.01,\n",
     "                     'tstop':3600,\n",
     "                     'zs0':0,\n",
     "                     'nglobalvar':['zb','zs','H'],\n",
@@ -355,7 +366,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x800 with 2 Axes>"
       ]
@@ -388,7 +399,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,
diff --git a/examples/xbeach-setup-2D.ipynb b/examples/xbeach-setup-2D.ipynb
index cdf4927..0339748 100644
--- a/examples/xbeach-setup-2D.ipynb
+++ b/examples/xbeach-setup-2D.ipynb
@@ -12,17 +12,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "**no xbTools installation found in environment, adding parent path of notebook to see if it works\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# import default modules\n",
     "import numpy as np\n",
@@ -51,7 +43,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -73,30 +65,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "D:\\Users\\bemc\\AppData\\Local\\Temp\\ipykernel_11248\\3489134793.py:25: MatplotlibDeprecationWarning: Axes3D(fig) adding itself to the figure is deprecated since 3.4. Pass the keyword argument auto_add_to_figure=False and use fig.add_axes(ax) to suppress this warning. The default value of auto_add_to_figure will change to False in mpl3.5 and True values will no longer work in 3.6.  This is consistent with other Axes classes.\n",
-      "  ax      = Axes3D(fig)\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
        "Text(0.5, 0.5, 'y [m]')"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -106,7 +90,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -140,7 +124,7 @@
     "plt.axis('scaled')\n",
     "\n",
     "fig     = plt.figure()\n",
-    "ax      = Axes3D(fig)\n",
+    "ax = fig.add_subplot(projection='3d')\n",
     "surf    = ax.plot_surface(X, Y, bathy, cmap=cm.coolwarm,  linewidth=0, antialiased=False)\n",
     "plt.xlabel('x [m]')\n",
     "plt.ylabel('y [m]')"
@@ -174,12 +158,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -222,7 +206,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -238,13 +222,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "d:\\gitlab_folder\\xbeach-toolbox\\xbTools\\grid\\creation.py:339: RuntimeWarning: overflow encountered in power\n",
+      "c:\\ERDC\\xbeach-toolbox\\xbTools\\grid\\creation.py:350: RuntimeWarning: overflow encountered in power\n",
       "  Lj[1] = cell1 * np.sum(np.power(fj[1],np.arange(1,ni+1,1)) )\n",
-      "d:\\gitlab_folder\\xbeach-toolbox\\xbTools\\grid\\creation.py:340: RuntimeWarning: overflow encountered in scalar multiply\n",
+      "c:\\ERDC\\xbeach-toolbox\\xbTools\\grid\\creation.py:351: RuntimeWarning: overflow encountered in scalar multiply\n",
       "  Lj[2] = cell1 * np.sum(np.power(np.mean(fj),np.arange(1,ni+1,1)) )\n",
-      "d:\\gitlab_folder\\xbeach-toolbox\\xbTools\\grid\\creation.py:340: RuntimeWarning: overflow encountered in power\n",
+      "c:\\ERDC\\xbeach-toolbox\\xbTools\\grid\\creation.py:351: RuntimeWarning: overflow encountered in power\n",
       "  Lj[2] = cell1 * np.sum(np.power(np.mean(fj),np.arange(1,ni+1,1)) )\n",
-      "d:\\gitlab_folder\\xbeach-toolbox\\xbTools\\grid\\creation.py:330: RuntimeWarning: overflow encountered in scalar multiply\n",
+      "c:\\ERDC\\xbeach-toolbox\\xbTools\\grid\\creation.py:341: RuntimeWarning: overflow encountered in scalar multiply\n",
       "  fj[1] = 1.1 * fj[1]\n"
      ]
     },
@@ -254,13 +238,13 @@
        "Text(0, 0.5, 'dy [m]')"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -291,12 +275,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\johnm\\AppData\\Local\\Temp\\ipykernel_2164\\2343223386.py:1: DeprecationWarning: `interp2d` is deprecated in SciPy 1.10 and will be removed in SciPy 1.14.0.\n",
+      "\n",
+      "For legacy code, nearly bug-for-bug compatible replacements are\n",
+      "`RectBivariateSpline` on regular grids, and `bisplrep`/`bisplev` for\n",
+      "scattered 2D data.\n",
+      "\n",
+      "In new code, for regular grids use `RegularGridInterpolator` instead.\n",
+      "For scattered data, prefer `LinearNDInterpolator` or\n",
+      "`CloughTocher2DInterpolator`.\n",
+      "\n",
+      "For more details see\n",
+      "`https://scipy.github.io/devdocs/notebooks/interp_transition_guide.html`\n",
+      "\n",
+      "  f = interpolate.interp2d(x, y, bathy, kind='linear')\n",
+      "C:\\Users\\johnm\\AppData\\Local\\Temp\\ipykernel_2164\\2343223386.py:3: DeprecationWarning: `interp2d` is deprecated in SciPy 1.10 and will be removed in SciPy 1.14.0.\n",
+      "\n",
+      "For legacy code, nearly bug-for-bug compatible replacements are\n",
+      "`RectBivariateSpline` on regular grids, and `bisplrep`/`bisplev` for\n",
+      "scattered 2D data.\n",
+      "\n",
+      "In new code, for regular grids use `RegularGridInterpolator` instead.\n",
+      "For scattered data, prefer `LinearNDInterpolator` or\n",
+      "`CloughTocher2DInterpolator`.\n",
+      "\n",
+      "For more details see\n",
+      "`https://scipy.github.io/devdocs/notebooks/interp_transition_guide.html`\n",
+      "\n",
+      "  zgr = f(xgr,ygr)\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -333,21 +351,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "no convergence\n",
-      "Artificial slope of 1:10\n",
-      "Hm0,shoal = 9.008451731585167\n",
-      "d start = 19.977837324773713\n",
-      "Hm0,shoal/d profile = 1.451507604860271\n",
-      "Hm0,shoal/d slope = 0.45092226876900976\n",
-      "n profile = 0.5248467628414396\n",
-      "n slope = 0.7776515191101054\n"
+      "Artificial slope of 1:50\n",
+      "Hm0,shoal = 8.5714772110995\n",
+      "d start = 28.572742030201947\n",
+      "Hm0,shoal/d profile = 1.3810990753466756\n",
+      "Hm0,shoal/d slope = 0.29998791162707733\n",
+      "n profile = 0.963619723035612\n",
+      "n slope = 0.8429281423665087\n"
      ]
     },
     {
@@ -356,13 +373,13 @@
        "Text(0, 0.5, 'z [m]')"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUIAAAHFCAYAAACHGPD8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABbZ0lEQVR4nO2de3wU1fn/P2dmL7kYFhIgMRAubfMTlJuiIngB5SaClPpVRDRqpSpyMwqi1FbQlyaKLWCl2moRLIhYLyjayiVesAjIrVSgfr18RblGqMZNgJDszjy/P3ZndmZ3drNJ9pbs83695pXJmWfOnNkkn5xznnOeRxARgWEYJo2Rkt0AhmGYZMNCyDBM2sNCyDBM2sNCyDBM2sNCyDBM2sNCyDBM2sNCyDBM2sNCyDBM2sNCyDBM2sNCyMSEIUOGYMiQIQl95qlTpzBv3jx8+OGHCX1uMPF4dyEE5s2bF9Hmiy++wKxZs9C/f3+0bdsWubm5uPjii/Haa6+F2M6bNw9CCP3IyspC586dMXLkSDz99NOoqamJafsbIpr3A4Bly5ZBCIFvvvkmru2xxbV2hokjp06dwsMPPwwACRfhVGD9+vX4+9//jpKSElxwwQXwer145ZVXcN111+Hhhx/GQw89FHLP2rVr4XK5UF9fjyNHjuC9997D7Nmz8eSTT+Ltt99G3759E9L2LVu2oHPnzgl5VjSwEDJRUVtbi4yMDAghkt0Uxs+ECRMwdepU089k1KhR+O9//4snnngC999/P5xOp+me/v37o3379qY6pk2bhsGDB2Ps2LH44osvQu6JFUSE06dPIzMzExdddFFcntFUeGjcTI4fP4477rgDRUVFcDqd6NChAy6++GJUVFSY7CoqKjB06FC0adMGWVlZuPjii/Hee++ZbL766iv88pe/RHFxMbKystCpUydcffXV2LNnj25DRMjPz8fUqVP1MkVR0K5dO0iShO+++04vX7BgAWw2G3788UcAwI4dOzBhwgR069YNmZmZ6NatG2644QZ8++23pnZow5H169fjtttuQ4cOHZCVlYW6ujoQEebPn4+uXbsiIyMD5513Ht59992oPy8iwjPPPIN+/fohMzMT7dq1w7XXXouvv/5at1m1ahWEEFi8eLHp3rlz50KWZWzYsAHffPMNOnToAAB4+OGH9SHfrbfeqtt/+eWXmDhxIjp27Ain04mePXvij3/8o6nODz/8EEIIvPzyy3jwwQdRWFiINm3aYNiwYfj8889D2h7tu1dXV2PWrFno3r07HA4HOnXqhNLSUpw8eTLE7vbbb0deXh7OOOMMXHnllfjiiy+i+izbt29v+Y/pwgsvxKlTp/DDDz9EVU/fvn3x4IMP4sCBA3jllVcatH/rrbfQp08fOJ1O/OQnP8FTTz2lD72NCCEwbdo0/OlPf0LPnj3hdDrx4osv6teCh8Zbt27FxRdfjIyMDBQWFmLOnDnweDxRvUOzIaZZjBw5kjp06EDPPfccffjhh/Tmm2/SQw89RKtWrdJtli9fTkIIGjduHL3xxhv09ttv05gxY0iWZaqoqNDtNm7cSDNnzqTXXnuNNm7cSKtXr6Zx48ZRZmYm/e///q9uN2HCBPp//+//6d9v3bqVAFBmZia99NJLevmoUaPowgsv1L9/9dVX6aGHHqLVq1fTxo0badWqVTR48GDq0KEDHT9+XLdbunQpAaBOnTrRHXfcQe+++y699tpr5PV6ae7cuQSAJk2aRO+++y4999xz1KlTJyooKKDBgwc3+HndfvvtZLfbaebMmbR27VpauXIl9ejRg/Lz86myslK3mzx5MjkcDtq+fTsREb333nskSRL95je/ISKi06dP09q1a/W2bNmyhbZs2UJfffUVERHt27ePXC4X9e7dm/7617/S+vXraebMmSRJEs2bN09/zgcffEAAqFu3bnTjjTfS3//+d3r55ZepS5cuVFxcTF6vV7eN9t1PnjxJ/fr1o/bt29OCBQuooqKCnnrqKXK5XHTFFVeQqqpERKSqKl1++eXkdDrpscceo/Xr19PcuXPpJz/5CQGguXPnNvh5WjFkyBDq0KGDZduNP2cj//u//6u/WyTeffddkiSJhgwZQqtXr6ZXX32VBgwYQN26daNgOdF+h/r06UMrV66k999/n/bu3atfM77fvn37KCsri84++2x6+eWX6a233qKRI0dSly5dCADt37+/SZ9FtLAQNpMzzjiDSktLw14/efIk5ebm0tVXX20qVxSF+vbtaxKqYLxeL9XX11NxcTHdc889evlf/vIXAkAHDhwgIqJHH32UevToQWPHjqVf/vKXRERUX19P2dnZ9Otf/zpi/SdOnKDs7Gx66qmn9HJNCG+++WaTfVVVFWVkZNAvfvELU/nHH39MABoUwi1bthAA+v3vf28qP3jwIGVmZtLs2bP1stOnT9O5555L3bt3p//85z+Un59PgwcPNv1xHz9+PKxgjBw5kjp37kxut9tUPm3aNMrIyKAffviBiAJCeNVVV5ns/va3vxEA2rJlS6Pfvby8nCRJ0kVc47XXXiMA9I9//IOIfKICwPTZExE99thjTRbC559/3rLOhoSwtraWANCoUaMi1n/BBRdQUVER1dXV6WU1NTWUl5dnKYQul0v/rIOvGd/v+uuvp8zMTNM/Q6/XSz169EiIEPLQuJlceOGFWLZsGR599FFs3bo1pCu/efNm/PDDD7jlllvg9Xr1Q1VVXHnlldi+fbs+XPJ6vSgrK8PZZ58Nh8MBm80Gh8OBL7/8Ep999ple57BhwwBAH35v2LABw4cPx7Bhw7BhwwYAvsnokydP6rYAcOLECdx///342c9+BpvNBpvNhjPOOAMnT5401a/xP//zP6bvt2zZgtOnT+PGG280lQ8aNAhdu3Zt8LN65513IITATTfdZPosCgoK0LdvX5P31+l04m9/+xu+//57nHfeeSAivPzyy5BlucHnnD59Gu+99x5+8YtfICsry/Ssq666CqdPn8bWrVtN94wdO9b0fZ8+fQBAnzZozLu/88476NWrF/r162d69siRIyGE0N/zgw8+AICQOidOnNjgO1rx7rvvYurUqbj22msxffr0Rt1LUYQlPXnyJHbs2IFx48bB4XDo5WeccQauvvpqy3uuuOIKtGvXrsG6P/jgAwwdOhT5+fl6mSzLuP7666NoffNhIWwmr7zyCm655Rb85S9/wcCBA5Gbm4ubb74ZlZWVAKDP2V177bWw2+2m44knngAR6XM59957L377299i3LhxePvtt/HJJ59g+/bt6Nu3L2pra/Vndu3aFT/96U9RUVGBU6dOYcuWLboQHjp0CJ9//jkqKiqQmZmJQYMG6fdNnDgRixcvxq9+9SusW7cO27Ztw/bt29GhQwdT/Rpnnnmm6fvvv/8eAFBQUBBia1UWzHfffafPcQZ/Flu3bsV///tfk/3PfvYzXHrppboABbcnHN9//z28Xi+efvrpkOdcddVVABDyrLy8PNP3msNA+1wa8+7fffcdPv3005Bn5+TkgIj0Z3///few2Wwhz47mswxm3bp1uOaaazB8+HC89NJLjXZqaYJfWFgY1qaqqkr/+QVjVQaE/g6F4/vvv2/y71UsYK9xM2nfvj0WLVqERYsW4cCBA1izZg0eeOABHDt2DGvXrtU9dE8//XRYT5n2S7RixQrcfPPNKCsrM13/73//i7Zt25rKhg4dirfeegsbN26EqqoYMmQIcnJyUFhYiA0bNqCiogKXXnqp/gftdrvxzjvvYO7cuXjggQf0eurq6sJOqgf/MWl/sJrIG6msrES3bt3CfEo+tMn9f/7zn5aeyeCyv/zlL/j73/+OCy+8EIsXL8b111+PAQMGRHwGALRr1w6yLKOkpMTkVDLSvXv3Busx0ph3b9++PTIzM/HCCy9Y1qX9TuTl5cHr9eL77783iaHVMyKxbt06jBs3DoMHD8brr79u6q1Fy5o1awBEXobUrl07CCFMDjmNcG2OVpDz8vLCfrYJIa4D7zRl3Lhx1KFDByLyzZ+0bduW7rrrrgbvy83NpTvvvNNU9s4771jOv2lzWCNGjKBLLrlELy8pKaErrriCbDYbzZ8/Xy93u90EgMrLy031LF68mADQLbfcopdpc4TBc1w//PBDs+YIN23aRADolVdeiWhHRPTpp59SZmYm3XzzzVRXV0f9+/enrl27muabqqurCYBpblFj2LBh1LdvX9NclhXaHOGrr75qKt+/fz8BoKVLlxJR49790UcfpaysLPr6668jPjsWc4Tr1q2jjIwMGjZsGNXW1oa1izRHuHv3bnK5XNStW7cGP6/GzhFOnTrVsp7g90v2HCH3CJuB2+3G5ZdfjokTJ6JHjx7IycnB9u3bsXbtWlxzzTUAfPMnTz/9NG655Rb88MMPuPbaa9GxY0ccP34c//73v3H8+HE8++yzAIAxY8Zg2bJl6NGjB/r06YOdO3fiySeftFx4esUVV+hLXLRFxYBv/vCWW27RzzXatGmDyy67DE8++STat2+Pbt26YePGjViyZElIbzMc7dq1w6xZs/Doo4/iV7/6Fa677jocPHgQ8+bNi2oIc/HFF+OOO+7AL3/5S+zYsQOXXXYZsrOzcfToUWzatAm9e/fGXXfdhZMnT2L8+PHo3r07nnnmGTgcDvztb3/Deeedh1/+8pd48803AQA5OTno2rUr3nrrLQwdOhS5ubn6uz311FO45JJLcOmll+Kuu+5Ct27dUFNTg6+++gpvv/023n///ajeuSnvXlpaitdffx2XXXYZ7rnnHvTp0weqquLAgQNYv349Zs6ciQEDBmDEiBG47LLLMHv2bJw8eRLnn38+Pv74YyxfvjyqNm3atAnjxo1DQUEBfv3rX2P37t2m62effTbatGljKtu5cydcLhc8Ho++oHr58uXo2LEj3n777QZ7k4888ghGjx6NkSNH4u6774aiKHjyySdxxhlnRL1cx4rf/OY3WLNmDa644go89NBDyMrKwh//+MeQ5UZxI64y28o5ffo0TZ48mfr06UNt2rShzMxMOuuss2ju3Ll08uRJk+3GjRtp9OjRlJubS3a7nTp16kSjR4829USqqqpo0qRJ1LFjR8rKyqJLLrmE/vnPf9LgwYMte1vnnnsuAaCPP/5YLzt8+DABoLy8PH2ZhsahQ4fof/7nf6hdu3aUk5NDV155Je3du5e6du0aVY+QyLfko7y8nIqKisjhcFCfPn3o7bffDttGK1544QUaMGAAZWdnU2ZmJv30pz+lm2++mXbs2EFERDfddBNlZWXRvn37TPe9+uqrBIAWLlyol1VUVNC5555LTqczpGe7f/9+uu2226hTp05kt9upQ4cONGjQIHr00Ud1m2h7hI199xMnTtBvfvMbOuuss8jhcOhLee655x5Tr+fHH3+k2267jdq2bUtZWVk0fPhwfSlLQz1CrZcX7vjggw/C2jqdTjrzzDNpxIgR9NRTT1F1dXXEZxlZvXo19e7dmxwOB3Xp0oUef/xxmjFjBrVr185kh0b0CIl8veuLLrqInE4nFRQU0H333UfPPfdcQnqEwt8ohmGYJuHxeNCvXz906tQJ69evT3ZzmgQPjRmGaRSTJk3C8OHDceaZZ6KyshJ/+tOf8Nlnn+Gpp55KdtOaDAshwzCNoqamBrNmzcLx48dht9tx3nnn4R//+IdpTrqlwUNjhmHSHl5QzTBM2sNCyDBM2sNCyDBM2sPOkihRVRVHjhxBTk4OBydlmCRDRKipqUFhYSEkqfn9ORbCKDly5AiKioqS3QyGYQwcPHgwJiH/WQijJCcnBwBwCa6CIzNHLxcZGZbnyAhsVSLjudOun6uOQEgp1Rk49zqN5YH/dooj0BNVDedep7E80AQl8CiohnPFaV1ORntHYDGBaguck1MNGDkM57L14gMhyPrc8E9cSKrBxnCzFLCXLOoxdgQkvSy0LuO9svBdF7oNmesU5vcILpdg0Q6Le8Odm14vCnur55qfqYaUCYOt8T6jLQDIFnWb6/Pbmd5ZhV1SYRMKZKhwSF7YJS/sQoVdKHq57P/eCS/swgtZECR/uQ0KZKHq9UogOIQCp/BCEoROssAZkhOS/9NSQVBI1c9VqKg5oeKs/kf0v8vmwkIYJdpw2AY7bCKgNkKyPocUUBuSDUIoG4TQZjOcG+Ls2Q1CaA/8tQt74M/IKIpkOBfGraKGc2EQORiE0GhvFEUYhBD2GAmhZDw32IQRQtGgEFoIRrRCGHQtUUJoFp34CGH4ZzRWCH3lctB1nxBKkKHCKQnYJQG7UGAXAnYhDEIokCEIdkF+IRSQhYAdgCyEQQhVOAQhQ0iQBKGNLHCGJEHyuzBUqFD8TfAJYYBYTVOxs4RhmLSHhZBhmLSHhZBhmLSHhZBhmLSHhZBhmLQnqUL40Ucf4eqrr0ZhYSGEEHrkYSvuvPNOCCGwaNEiU3ldXR2mT5+O9u3bIzs7G2PHjsWhQ4dMNlVVVSgpKYHL5YLL5UJJSYme9JxhGCapQnjy5En07dsXixcvjmj35ptv4pNPPrHMsFVaWorVq1dj1apV2LRpE06cOIExY8ZAURTdZuLEidi9ezfWrl2LtWvXYvfu3SgpKYn5+zAM0zJJ6jrCUaNGYdSoURFtDh8+jGnTpmHdunUYPXq06Zrb7caSJUuwfPlyPRbaihUrUFRUhIqKCowcORKfffYZ1q5di61bt+oZ0J5//nkMHDgQn3/+Oc4666z4vBzDMC2GlJ4jVFUVJSUluO+++3DOOeeEXN+5cyc8Hg9GjBihlxUWFqJXr17YvHkzAF9ibpfLZUoDedFFF8Hlcuk2VtTV1aG6utp0MAzTOklpIXziiSdgs9kwY8YMy+uVlZVwOBxo166dqTw/P1/Ph1pZWYmOHTuG3NuxY8eIOVPLy8v1OUWXy8X7jBmmFZOyQrhz50489dRTWLZsWaO30RCR6R6r+4NtgpkzZw7cbrd+HDx4sFFtYBim5ZCyQvjPf/4Tx44dQ5cuXWCz2WCz2fDtt99i5syZ6NatGwCgoKAA9fX1qKqqMt177Ngx5Ofn6zbfffddSP3Hjx/XbaxwOp1o06aN6WAYpnWSskJYUlKCTz/9FLt379aPwsJC3HfffVi3bh0AoH///rDb7diwYYN+39GjR7F3714MGjQIADBw4EC43W5s27ZNt/nkk0/gdrt1G4Zh0pukeo1PnDiBr776Sv9+//792L17N3Jzc9GlSxfk5eWZ7O12OwoKCnRPr8vlwqRJkzBz5kzk5eUhNzcXs2bNQu/evXUvcs+ePXHllVfi9ttvx5///GcAwB133IExY8awx5hhGABJFsIdO3bg8ssv17+/9957AQC33HILli1bFlUdCxcuhM1mw/jx41FbW4uhQ4di2bJlkOVAKKuXXnoJM2bM0L3LY8eObXDtIsMw6QOn84yS6upquFwuDMHP4cgKzBeKzHCBWQ3xCDPDBGZ1GuIRGgOzZjQcmFVxRhGYNUysQVNg1jA2psCsHI+Q4xEarhsDszr1wKyKfhgDs2YIT0hgVntIYFYVDqEgwx+YtUgPzGqMR2gOzFpdo6LwrENwu90xmb9P2TlChmGYRMFCyDBM2sOh+hmGaTIqYpfRUYFA0AxAwuAeIcMwaQ8LIcMwaQ8LIcMwaQ8LIcMwaQ87S5ikQ2QMkBH72fKm1BluXWGkOlX/e0iCTOepiNyMdikkYDP4SFSSoILg8Z9L/rWCEgj1kKFAQgbqAX8uZBUCIAkwrCX0OUpkKILggQcKqZCEFLKGMNCG2H6u3CNkGCbtYSFkGCbtYSFkGCbtYSFkGCbtYWcJExvCzV0bJtWNThEYJrujCUBurD4WexmCgy2EI5zTg0jExbGTKjTk5FFJAEKC5P85KuTrU9klL+zwZZD0kAwZKjIkD2RJhQJ/QAfhhYRAlkkVElSSfNcJ8FA9VOELrhCwIf9XNeaOEoB7hAzDMCyEDMMwLIQMw6Q9LIQMw6Q97Cxh4kpjd40Y58FFAx4Ssrge7fN0J0gj2tZgXWHqMO04gfbc8LtPVBJ6mXauQoREqfZdl0IiTxttzXUFbBUSEXeXGO+zvA4JKgF1qg12oUASBLtQoKoCHtiQJddBJQlOyQO7UFBPMhyA32Fi8/28CICh7Qpk/1fNUSJDIdXkKAk8n3eWMAzDxBQWQoZh0h4WQoZh0h4WQoZh0h4WQib5kAgc0ZiTMO9SiUeTEvAMIyoJ3XlidQ3wOUE0Z4vRVvXv6jCVQYTcb7Q11Q/r69p9CoQvTJb/urE+u1BM9gpJUCHgIRkKBOpUO37wnoEaNRM1agZOUyB/rJZaVQbpBwAo5AuzpYXf8rVRc/JQzB0lAAshwzAMCyHDMAwLIcMwaQ8LIcMwaQ8LIRMjRJjDAIU5okBzXjTkwBCC9CNyfb5Dc1JodUdyWgBmh0U8ieg8iZHDRCEBxeCICb4efJ8S5r0lQZCh+r4KFRJ8u0zkoB+ucWeMDDW4GkO7jedkcpQYy2MJCyHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPCyETXxrpFAlHtE4QyyYYnSGNdHZEcqKEc95EcrZEiyRID4MVHA7LKhxXuOdHs8PE6DBRDTtIrO4LdphEk8A+OExYMMadKzIIHhJ+J0loQncVBIV3ljAMw8QeFkKGYdIeFkKGYdIeFkKGYdIezlnCMAjNYaJN71vlEwEAiFCnhVUOkoZyfzSG4OcZ6zU6JEzlIMvyaDDmOLF6DwlaGK3ArpKQNouAjfGrkeAdKD7nSWhCd6PzhHeWMAzDxJikCuFHH32Eq6++GoWFhRBC4M0339SveTwe3H///ejduzeys7NRWFiIm2++GUeOHDHVUVdXh+nTp6N9+/bIzs7G2LFjcejQIZNNVVUVSkpK4HK54HK5UFJSgh9//DEBb8gwTEsgqUJ48uRJ9O3bF4sXLw65durUKezatQu//e1vsWvXLrzxxhv44osvMHbsWJNdaWkpVq9ejVWrVmHTpk04ceIExowZA0UJRM6dOHEidu/ejbVr12Lt2rXYvXs3SkpK4v5+DMO0DJI6Rzhq1CiMGjXK8prL5cKGDRtMZU8//TQuvPBCHDhwAF26dIHb7caSJUuwfPlyDBs2DACwYsUKFBUVoaKiAiNHjsRnn32GtWvXYuvWrRgwYAAA4Pnnn8fAgQPx+eef46yzzorvSzIMk/K0qDlCt9sNIQTatm0LANi5cyc8Hg9GjBih2xQWFqJXr17YvHkzAGDLli1wuVy6CALARRddBJfLpdtYUVdXh+rqatPBpAaRdpgYd5EEh9pSLXaYaDbhCL7PdE2vw+KaxU6UWOw4saIpjhLjPXLYe6zrBXy7UXxJ3gUUSJCFCrtQkCXVI0uugwyCU/IgS6pHtlSHtvIp5Mi1yJLqkCHq9efIIEhQYRdeSL4aoUCYwm8BAeeIgjTPWXL69Gk88MADmDhxItq0aQMAqKyshMPhQLt27Uy2+fn5qKys1G06duwYUl/Hjh11GyvKy8v1OUWXy4WioqIYvg3DMKlEixBCj8eDCRMmQFVVPPPMMw3aExGECPz3NZ6Hswlmzpw5cLvd+nHw4MGmNZ5hmJQn5YXQ4/Fg/Pjx2L9/PzZs2KD3BgGgoKAA9fX1qKqqMt1z7Ngx5Ofn6zbfffddSL3Hjx/XbaxwOp1o06aN6WAYpnWS0kKoieCXX36JiooK5OXlma73798fdrvd5FQ5evQo9u7di0GDBgEABg4cCLfbjW3btuk2n3zyCdxut27DMEx6k1Sv8YkTJ/DVV1/p3+/fvx+7d+9Gbm4uCgsLce2112LXrl145513oCiKPqeXm5sLh8MBl8uFSZMmYebMmcjLy0Nubi5mzZqF3r17617knj174sorr8Ttt9+OP//5zwCAO+64A2PGjGGPMRNC8A6TcE4Zq50WpIezCt1dAn+Z1c4UY12RdqJoIbJCd7RIDYa6MtIcR4kM8ofo8ucRgQw7FCgkwS4USEJFhvDoeUzsQkG2VAdJqHAIJZDUXaiQQcgQnkDDDLtYPKQadpcEHCUaSiQPVxNIqhDu2LEDl19+uf79vffeCwC45ZZbMG/ePKxZswYA0K9fP9N9H3zwAYYMGQIAWLhwIWw2G8aPH4/a2loMHToUy5YtgyzLuv1LL72EGTNm6N7lsWPHWq5dZBgmPRFEMZbWVkp1dTVcLheG4OdwZAXmC0VmRuA8I3CODKd+SpmOwLnTrp+rTpvhPCDc3gzZUG4IoOkwBMh0Bs69hnM18CgohnPVbih3wtLeaKM6DD0ae+CcnIaeh8NwHnaSJXCvkMKdw3Bu6ImEsdd6KMbemiyFlgndDmHv1XpBwX6zEDuLZ0pBdRifaxVUNfg83PIWY1DW4GvG51ntNY5m+Uxze4Tada3cLhQ4JS8yJA+ckidij9AuvHp5cI9QC86aLTzoICs4Q/j+PoJ7hCoIP1Yr+H89v4Pb7Y7J/H1KzxEyDMMkAhZChmHSHg7DxbQKgp0cZozhm4LCbfmHxBJZD5HD1W8cIls5MYy7SMI5Qoz3BYfwCnawxCqUVzjCDYsjobVRFf4dJiRBJQmKkGCHB3b/UBgwh+HShsV24YVdBGICSPpOFYF6IniECrv/EzcOi2PtKPE9m2EYJs1hIWQYJu1hIWQYJu1hIWQYJu1hZwnDWNDQDhNfKC8fVjtMTM6UBnKZqBAhjpZgB4uVvZUTJRrHitVOlOA2WBGcW0SrC1ChQIIKAQ/JUFSBU3D4Qmz5w3PlSKchCxVtZcAuavX6fDbkd5IY2wM9yXvwDhPteizhHiHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPO0uYFocW7ipciKym1NXoHSYWzw63w6ShkFxWThSrnSWmsiCHSUMOkMbsTgkX1kuBCHGY2CRFr/+0asdp2PWE74Av3JYEwgmRgSypHjVKBjL8uUzayifRQT4BB/nqkKFChQwZ5EvyTgS70N7FH3ghTjFiuEfIMEzaw0LIMEzaw0LIMEzaw3OETHwRYc5jgDmXcGCxsUakSDT6fF6Di4/DL6w2huYPrstqHjNSSP7gSDTRhO4Prleb24u0WDvWBOYtA+ey/0dgFwrsktdvJ+mLq7WoNHbDEmoFvvzIprphHZ4/uDwWcI+QYZi0h4WQYZi0h4WQYZi0h4WQSQ7CeFDgSDIqBFQIEAGRlqypFH7CUw2aDFVJRLaPcM3KRo8MbTHp6guCEGTvtzPX4Y/8HMWzG4NqISkyCE7JAxmqns4zHIG5USQk2IL+3DjVyzAM02JgIWQYJu1hIWQYJu1hIWRSCiEChxEiETiAmK0i0+bvtLobIpKd1VxgsK3RxsreOJ9ntAtbZjH/Z3xWNGWKxZyjNocYjoav++Zag+0UfQ5Tggey5X2KxdyncY9xrNcQAiyEDMMwLIQMwzC8xY5psVgPUcMnc7eyCxduK5hI4bcst9NFEZIr2vqjpbEhuZqauyQSUpgFLnWqXf9ByOTbaucha/lRIPmHxxR26YwS49Ex9wgZhkl7WAgZhkl7WAiZlELb0RGnQMRRE80Ok3A7Rqw8x1be40jPDraz3FnSxB0mjSWanS8akiD90LD2Aouod7XE22MMsBAyDMOwEDIMw7AQMimLcRF1op8ZjV2saMzQsyl1RSqLFHzBuBhas7ca5mpYebwVkuBRw3uHrRZQa2VGz3C8gi1osBAyDJP2sBAyLQMyHHGgoVBZ0dhZOkWaGJJLc9YYyyztonCYRGqP0c5qq10kGtpmFw2nyR4Sot+IVfrOWK8hBFgIGYZhWAiZlkdw8IWmdBAC84/RLdVpyjKahmjsfY3ptUZTFt0zmycRkXqXKkmoJznqtilxDNDKQsgwTNqTVCH86KOPcPXVV6OwsBBCCLz55pum60SEefPmobCwEJmZmRgyZAj27dtnsqmrq8P06dPRvn17ZGdnY+zYsTh06JDJpqqqCiUlJXC5XHC5XCgpKcGPP/4Y57dLNyjMEc2tInA09enGMF1BvT2tJ9WYcFvNJZqQXA3ZN/qZsc6X2gDB+5QBQA7TV5OECjno98Hqfivi7TEGkiyEJ0+eRN++fbF48WLL6/Pnz8eCBQuwePFibN++HQUFBRg+fDhqamp0m9LSUqxevRqrVq3Cpk2bcOLECYwZMwaKEsiZOnHiROzevRtr167F2rVrsXv3bpSUlMT9/RiGaRkkNfrMqFGjMGrUKMtrRIRFixbhwQcfxDXXXAMAePHFF5Gfn4+VK1fizjvvhNvtxpIlS7B8+XIMGzYMALBixQoUFRWhoqICI0eOxGeffYa1a9di69atGDBgAADg+eefx8CBA/H555/jrLPOSszLMi0SqygyGlZRZ6Kut4FINI1J0B5NEvh4Ijfj2VoyJ6PnONK7xMNjDKTwHOH+/ftRWVmJESNG6GVOpxODBw/G5s2bAQA7d+6Ex+Mx2RQWFqJXr166zZYtW+ByuXQRBICLLroILpdLt7Girq4O1dXVpoNhmNZJygphZWUlACA/P99Unp+fr1+rrKyEw+FAu3btItp07NgxpP6OHTvqNlaUl5frc4oulwtFRUXNeh8mOpKxmyRSO5p6rxHjmsCmEinoQktDC9evzSdG2q2i3xOvBaR+UlYINYQInnCmkLJggm2s7BuqZ86cOXC73fpx8ODBRracaS6pEonGinhvi0sVonVoWKFEsfRGNgSL9T2PTOWJImWFsKCgAABCem3Hjh3Te4kFBQWor69HVVVVRJvvvvsupP7jx4+H9DaNOJ1OtGnTxnQwDNM6SVkh7N69OwoKCrBhwwa9rL6+Hhs3bsSgQYMAAP3794fdbjfZHD16FHv37tVtBg4cCLfbjW3btuk2n3zyCdxut27DMBqxWMaSTjTGSaNA6E4RFVLYrXXGJThW/dF4LKdJqtf4xIkT+Oqrr/Tv9+/fj927dyM3NxddunRBaWkpysrKUFxcjOLiYpSVlSErKwsTJ04EALhcLkyaNAkzZ85EXl4ecnNzMWvWLPTu3Vv3Ivfs2RNXXnklbr/9dvz5z38GANxxxx0YM2YMe4xbEMZ5t6Z4aRuuX6u76XZWeUeCPbrN8TS3RBSSIAnfUjaVJEAoDdwRIFjw4uUxBpIshDt27MDll1+uf3/vvfcCAG655RYsW7YMs2fPRm1tLaZMmYKqqioMGDAA69evR05Ojn7PwoULYbPZMH78eNTW1mLo0KFYtmwZZDmQM/Wll17CjBkzdO/y2LFjw65dZFoA2h9EDDpuqSZMyV4KEytkoTY4R2jcvqdAwA6fSCZ6fhAABFEqTkWnHtXV1XC5XBiCn8ORFZgvFJkZgfOMwDkynPopZToC5067fq46bYbzgHB7M2RDueGXxRH4y1ecgXOv4VwNPAqK4Vy1G8qdsLQ32qgOQ6/GbujROA3/px2GcynMr5FBrITBxig8wvj3IsLYGOvRyg1lmngIi/uFhV2ojdk2uL7gtXxCWD9Tu9dYJlnUIYLC2Qefm77332dlH/IVweVq6D2W9fns5BCb0PtlwzVJEGRBkOA/9381YhcK7JIXAJAhvMiS6pAheZAhPCi0VUH27zqxi4AQ2oWKDKEiQwjdY6z1CFUANTUq+p19DG63Oybz9yk7R8gwDJMoOK8x0yrQ+yDR5jpu5PAzXjtMgmkNw2Ij2s4RqxzK2vXQPciJ/wxYCJmkY5yciTbhOhN7otkqF+38XaS5TgWSb/5Q+Ooz2jVUf7wCMPDQmGEikAq7XMIRPD8Yja31tfjHdwnnONHmFY3IoBBBjKfHGOAeIZNqGEWnlQ0TY0Uyho7Bz4wkntEHWtW22hGA0CFyIuEeIcMwaQ/3CBmGMdFQ2K+G0Hp6EhpePC1DhV2okMIsCo13sAUN7hEyKUuqRKJpKTRXwOKNVf4T35pBgiNontAqIk08ZzJZCJnE0YxsS6kciSYRtKRlNcH7tRsKQebzHId6jKMJzxUreGjMMBGIZm1gY9YPpspWvmhoqjdZ8wTbhQJZqHq+EkmocPp3lNiFF3bh9QdiEFAjfCzx9hgD3CNkGIbhHiHDtDaSNYzW1gNqPUG75PWd+3uDdqEgQ3iQIfl6hA6hQIEEj38YbTUUTkRvEGAhZJJEvMNqtSRa0vxfQ/iCMPhEz3g4hFc/zxD1uliqJOCBZPkZqISYRBiKBhZCpsWRaqGzItFckYu1JzhW9YXbOwzAJIC++UDF1AuUoOrCWE8yJEFwkG+pTfDnpSIx83c8R8gwrZREbJ2L5tlyUDuCv1dJNOghjvebsBAyDJP2sBAyLQ4RFPiUaT7NSdKuYcxBYoo+TRIUElD9X40BGNQUkaDUaAXDpDgSKGE7NxLpPIn18FkNErpIyZqiSfeZKFKnJQzTwgkOsZ8qxLJNjdntofUKVQi9V6iJYfgMdsn5/FgIGSYNiZU4WoXcMm6p03qIKgRUSFBJMg2HE7mNLhIshAzDpD0shEyLQIjAkQrtaAxW84vNXl8YJntdItGGvoqhVxgyD+ifG/QNjbVz0aj5wUQsAuIF1QyTAjQ33H68iSbfcrCNAgGQBBUqICTIUOEhGTJskAVBhYAcob5EwkLIxIhw3STrPx5e/hIfIuYmaWSvMdLukUgoQYnbJUgAqVAgQQJBEb5eofYr40vunlxYCBkmxsRa5FPREx2MCgkStCTxqt4b9F0jn+iR/xoJnxhCgkQU8j9UBiXcicJzhAzDpD3cI2RaPUbnhta7am6vLdV7acnaZ6yF4vItk/EFYNB7h8I3bPbABgcp8JAtZN9xMApEQtYWshAy8cX4O9zI0U5zxSrW0aUTSaK9wAqJmGyz0/CQ7POWC9Uvgr6vHsiQheqLOkMq7CKQ7D2kTRCJ282TkKcwTIqTiKU5waKbiJ0oTam/oRwjJluDY8T4PvoiapL8ofglf1h+yX9N8u89NksQ7yxhmBigBWRI1Z5eomko2bpVZrmGrjfGkWEKsEB+8UNgTSEHXWAYhkkReI6QYQw0ZigZqdeZ6s6UeOFL5SmHvL8k1LC9Ty0yjQzF1NtM5DCZe4RMq0AgYekt4ko8BTQ4GELM6g2qS48wYxA+TdR884VCb4sSw3Y0BxZCJrUQFDiS2YwUnmeM1z7jhkSp4flGnzPEKrm7XXitnwlJ7wUmMxINCyHDMDHHJIZkDsoaCMIQnx5qU2AhZBgm7WEhZJICkdCPptISl8o0de1gop0vjVlLCJiH1VZLYiIt01FIChkWJ3o9IQshExsozNHCiSZXSbJD9FuJVkPrA5tqGw1Wc40KzENl0/P1OcJQQUwULIRMwohFL7ClEY0jI2LorBbU2wXCz/UFh/QKXkyd7EROKS2EXq8Xv/nNb9C9e3dkZmbiJz/5CR555BGoauADJSLMmzcPhYWFyMzMxJAhQ7Bv3z5TPXV1dZg+fTrat2+P7OxsjB07FocOHUr06zBMUki2I8Jq6KsR7EhJFslvQQSeeOIJ/OlPf8LixYvx2WefYf78+XjyySfx9NNP6zbz58/HggULsHjxYmzfvh0FBQUYPnw4ampqdJvS0lKsXr0aq1atwqZNm3DixAmMGTMGiqIk47UYhkkxUnpnyZYtW/Dzn/8co0ePBgB069YNL7/8Mnbs2AHA1xtctGgRHnzwQVxzzTUAgBdffBH5+flYuXIl7rzzTrjdbixZsgTLly/HsGHDAAArVqxAUVERKioqMHLkyOS8XNpg7AnEaJiXhA5OsnOlxAo1jhFdjMFZI6EtqjZGnVG19YeGqNW8s8TPJZdcgvfeew9ffPEFAODf//43Nm3ahKuuugoAsH//flRWVmLEiBH6PU6nE4MHD8bmzZsBADt37oTH4zHZFBYWolevXroNw8SCWHmwoxWqeAx5m7LTI9j5YRXOy8ohE9hdEhg6J2sYn9I9wvvvvx9utxs9evSALMtQFAWPPfYYbrjhBgBAZWUlACA/P990X35+Pr799lvdxuFwoF27diE22v1W1NXVoa6uTv++uro6Ju/ENIDxD6GFOQpSgWiSLMWCpvTYGgrBzztLwvDKK69gxYoVWLlyJXbt2oUXX3wRv/vd7/Diiy+a7ETQuIWIQsqCacimvLwcLpdLP4qKipr+IgwTREvyBkezvCaanpwWl9AqFBd7jSNw33334YEHHsCECRPQu3dvlJSU4J577kF5eTkAoKCgAABCenbHjh3Te4kFBQWor69HVVVVWBsr5syZA7fbrR8HDx6M5asxDJNCpLQQnjp1CpIUNP8gy/ryme7du6OgoAAbNmzQr9fX12Pjxo0YNGgQAKB///6w2+0mm6NHj2Lv3r26jRVOpxNt2rQxHQzTlMXTsd79kuzlMA0RjcMkGBWNS/oea1J6jvDqq6/GY489hi5duuCcc87Bv/71LyxYsAC33XYbAN+QuLS0FGVlZSguLkZxcTHKysqQlZWFiRMnAgBcLhcmTZqEmTNnIi8vD7m5uZg1axZ69+6te5GZJBNFXpOWtI0uXVFIQIqg0eGG2ME5jiX//GMic5aktBA+/fTT+O1vf4spU6bg2LFjKCwsxJ133omHHnpIt5k9ezZqa2sxZcoUVFVVYcCAAVi/fj1ycnJ0m4ULF8Jms2H8+PGora3F0KFDsWzZMsiynIzXYlo58dhL3BQnSFMTtMcShSRIIrBeV3OyqHpWu0CO42QiiIj/1UZBdXU1XC4XhuDncGQFhskiMyNwnhE4R4ZTP6VMR+DcadfPVafNcB4QZW+GbCg3bENyBP7dKs7AuddwrgYeBcVwrtoN5U5Y2httVAcZygPn5DT8YTkM5+F6AsZywx+ysYcnJOO5wVxSDfYIsTfVYVWvnrozcK8smYUh2CY43afWIwm+brIJvsdgI8E8LA6OJRju3NgTinRP8LNC7dRG2QGB5S/mNqiG80C5rNelQhIEWRAkqLALRbez+4UwQ/LoQmgXCrKkOmRJdciQPMiW6pAjTiNbqoddqHq9dkGW3umaGhX9zj4Gt9sdk2mrqHqEubm5japUCIFdu3aha9euTWoUwzBMIolKCH/88UcsWrQILperQVsiwpQpU3j7WroRblyRAvP6VkNKq95iY2hpc5ZWQ+t4rjlUIAHk6yVqu1mMaw+11J5aWs9kE/Uc4YQJE9CxY8eobKdPn97kBjFMrGgt2+JiTTy32UWDKQpNUHJ3BRLsTfA6N5eohNAY7SUajAEPGEYnCu9wskjEAueWtIgaMAtmLBwvKkmQDY4TbW+x5iiRk+jYSX6flGEYJsk0afnM4cOH8fHHH+PYsWMhvcUZM2bEpGEMYwzgGu2cXHPn7lrD3F+yMXq0ZaFCgu+rz5Ps0wsZpF+3Cy9kw3BYJQE5jLc4XjRaCJcuXYrJkyfD4XAgLy/PtF9XCMFCyJhJ4eFwc4kYWdrijzhRopVMcZSgQoYaIoKS/zAut3EIL+xCgUMoPrskzls2WggfeughPPTQQ5gzZ07I9jeGSRYtrSfXmrESQW3toIYM33W78MIuvD4xFGTqGSa0zY294dSpU5gwYQKLIBMXiAJHMokmaVNrorlLWLT7jQvCjSIo+YfGmtDZhQJZqHAIBXb/Qppk0ui3nzRpEl599dV4tIVhGCYpNHpoXF5ejjFjxmDt2rXo3bs37Ha76fqCBQti1rhURa2t1c/D/ScRYc6NhLvX+EPxRnWH0T5WE3Fhku0Y2mDqLzkS+B9de3ALnnNs7jxeKjpJgjH2BmX4h73Ct9Bac57YhReyUJO6dAZoghCWlZVh3bp1OOusswAgxFnCMI2lKd7hRMG/0o1HEzajCNqF71+6DBWyQEAEoVo6SRKds6TRQrhgwQK88MILuPXWW+PQHIZpGpqYpoqQavk4kj3PmMwINMYeoeZAAeB3kii6wyTZ84O+NjUSp9OJiy++OB5tYZgWSXMDr0YbaFUlkfJBWTUCUW9Uf68vIIKyv0xbOgMgqUtnfO1qJHfffbcprzDDMExLp9FD423btuH999/HO++8g3POOSfEWfLGG2/ErHFM66Wx84LG5TSpNm+XKsPyZAdTCCaweDqwswSAyUkCJHePsUajhbBt27Z6MnWG0Qk3ZEuRObvmkigPbaLDZcUbbViszQXK/kXTxjWF4UjpUP1Lly6NRzuYtMAoli3zDztRpIqzJVb4PMmaCHr1nSepAm8PYVIXEoHD6jIJ/UhlWkIb40Vgu52qi6Ddv5tEGxInO6cxEKUQnnfeeSF5gSNxySWX4PDhw01uFMMwTCKJami8e/du/Pvf/446d8nu3btRV1fXrIYxrYRWHH2mNZCI+Uffkhlq0npGlQA5Ab83Uc8RDh06FNEmvOMdJkyySOVdKkzqEpUQ7t+/v9EVd+7cudH3MAz3INOTRHqIrYhKCDktJ5NKJGPdnrajo6UuYwFSZxlOKqwbDCb57hqGYZgk06ScJQwTU5IwHOZp7MSgkoAqBBQSkOFL3ekhm+/nTACEmhK9sVRoA8MwrRDF/19NIV8i93qSoZIEhQQUkuCBrF8Dog8+EQ+4R8i0CqxitZJVYRCpMGeWDnhIhl0ACggSJIB8QX5TZb6w0T3CW2+9FR999FE82sKkE2Q4ojFvIbtImFAUSFBIOwQ8ZIOHbL6eISS956jZJoNGP7WmpgYjRoxAcXExysrKeAcJwzAtnkYL4euvv47Dhw9j2rRpePXVV9GtWzeMGjUKr732GjweTzzayLQAjNnnUiUTHRMeNY5eKYUkPaudAgmqv+fnIdnfG5RRr5/bfPOFZAvMKSLxAWib1A/Ny8vD3XffjX/961/Ytm0bfvazn6GkpASFhYW455578OWXX8a6nUxroJHD4XiiCXVLivqcKJRmfB7aZ6mJoVH8jIcKyT9kFvAgIIzGn4WSwBX1zRqQHz16FOvXr8f69eshyzKuuuoq7Nu3D2effTYWLlwYqzYyaUqq9yzDiSgLqw9fz04yfPUJo6ILpOwvs/k8yBCoJzkpbW2019jj8WDNmjVYunQp1q9fjz59+uCee+7BjTfeiJycHADAqlWrcNddd+Gee+6JeYOZFoZRFGLtoeXteCmJtnZQJQkQKhSSoYIgQSB41aBKEur957I/cKvPYRKIV5iIjHaNFsIzzzwTqqrihhtuwLZt29CvX78Qm5EjR6Jt27YxaB7DMEz8abQQLly4ENdddx0yMjLC2rRr165JgRoYprlYRZ8xDlVlXjeYEBSS9B6dJFTffJ+/hyjBf438y2UIUKBCEZLuKJGF7+emiMQEY2i0EJaUlMSjHQwDgMNotQZ8ThB/cAW/99gYi9A3ZPYlclJIAMInjYp/HtEnfhJkKAlrM2+xYxgmJqgkTNvlPKrP8aF5kDWniXZdgW97nUK+cl9Af2EK3Z8ozzELIdPiSKQnOZW91qmKSkL3CBvXK2piqImb6t9zrC2lqde8yJD9QtlCls8kgsOHD+Omm25CXl4esrKy0K9fP+zcuVO/TkSYN28eCgsLkZmZiSFDhmDfvn2mOurq6jB9+nS0b98e2dnZGDt2LA4dOpToV2EYJkVJaSGsqqrCxRdfDLvdjnfffRf/+c9/8Pvf/97kkZ4/fz4WLFiAxYsXY/v27SgoKMDw4cNRU1Oj25SWlmL16tVYtWoVNm3ahBMnTmDMmDFQlMTNQTDhSad9xK19AbdCFktkgoa7ke/XdqQEeo2JIKWjzzzxxBMoKioy5VLu1q2bfk5EWLRoER588EE96fyLL76I/Px8rFy5EnfeeSfcbjeWLFmC5cuXY9iwYQCAFStWoKioCBUVFRg5cmRC34lJLsmIbt2SUZsYQl/LYWx5Lag+KchOIV/cQiWBDpOU7hGuWbMG559/Pq677jp07NgR5557Lp5//nn9+v79+1FZWYkRI0boZU6nE4MHD8bmzZsBADt37oTH4zHZFBYWolevXroNkwyE4Wg+Vj3KdOllphpN3aKnGmITJjrXcUoL4ddff41nn30WxcXFWLduHSZPnowZM2bgr3/9KwCgsrISAJCfn2+6Lz8/X79WWVkJh8OBdu3ahbWxoq6uDtXV1aaDiQCFOWJWf+Rk70xqofXywgmapO8gCUX170BJ5BRCSg+NVVXF+eefj7KyMgDAueeei3379uHZZ5/FzTffrNsFpw8logZTijZkU15ejocffrgZrWcYpqWQ0j3CM888E2effbaprGfPnjhw4AAAoKCgAABCenbHjh3Te4kFBQWor69HVVVVWBsr5syZA7fbrR8HDx5s9vukPSkUfaY1kWrOl0jtMc4PWs0hGofVxqU28SalhfDiiy/G559/bir74osv9PSi3bt3R0FBATZs2KBfr6+vx8aNGzFo0CAAQP/+/WG32002R48exd69e3UbK5xOJ9q0aWM6GEYj2rnHSHH/WrsHORzaLpNwaRKCo1YngpQeGt9zzz0YNGgQysrKMH78eGzbtg3PPfccnnvuOQC+IXFpaSnKyspQXFysR83OysrCxIkTAQAulwuTJk3CzJkzkZeXh9zcXMyaNQu9e/fWvchM/DAuRm505rg4Rpdp7d7jZOYwVoPmBRWSIPm31ElC9UWZgWo5R6gYnCWKP+tdIkhpIbzggguwevVqzJkzB4888gi6d++ORYsW4cYbb9RtZs+ejdraWkyZMgVVVVUYMGAA1q9fr4cEA3yBImw2G8aPH4/a2loMHToUy5YtgywnJ/YZExviuS9Z68k1ZulIaxfXWCCDdIH2hd2yGh5LsGt7kRM0aBVEvIEoGqqrq+FyuTAEP4dN2PVyKTNTPxeZgYg8whidJ8Opn1KmI3DuDNSjOm2G84BAezNkQ7lhD6bDMJfiDJx7Dedq4FFQDOeq3VDuhKW90UZ1kKE8cE7OwC8xyWF+jYzhCCWDjfH32yAcRhthKjfWo/qvh9Zt7AVp90uGOrXrwdeCywPN1MrN95vqCLpHCDKVBeoIbYd2Hvx98L1W1y3LYGWnhpRZ1W20ky3tQoe0sul5KiRB8KoyMuV62IWi29qFAlmoyJLq4ZQ8+vxghuSB5I9DKEOFJFRkCE/gkLxoK9WHrD2sqVHR7+xjcLvdMZm2Suk5QoaJBake6bqppOr8oiaIVmhhtpQo1gsmMvU7CyGTWjTTs9xSHdOp4DgJntsLbxe5ncEiGDz8NSZ00tYMKgZxBBAUrCGqZjWLlJ4jZJh4E00S+JaOSpJp2BtLrMLoRwp+69s9Qr7PmwIOE7tAQuMPBsM9QqbF0dq3zjXU40p2z7GpGAMqaL1PLZmTlvwdMA+J9ax4cf5PxULIMEzaw0LIJJ+WOrGXANRGhqNqSuL2WPcwg6PJGDH27IKXxsi65zs+w/hIsBAyaUUynRKpMJyP9t2bk+Td8rlBAt3QnGUiEjaZn8cwySDWvcBm1qUJZEPzj6ng3U0W0XqVzfeYg7Kq/vwl4eoL3n+cqN0x7DVmYkM4cYjRL3JTturxTo/4Eynxui+wauOHuVa7TeIN9wgZhkl7WAgZhkkY2jDZF3ShgYXZCXSasBAyiSONoky3xrnEaBZla55fq3dvjEfbODxOREguFkImZYlndrtY1psKopfs50ci2GESSVAjJX2KJyyETHyJ4xrBlhxMIRHClcriqHmDGwqzlah3YCFkGCbtYSFkGCZuNCWwqgTSl+XwOkImLWlu1Gmr++MZyTodSVYKgHjCPUImrWnpkWyi3oOc4ITpvmc27nOVfdmMA99HcKo0ZU91JFgIGSYKWqpTJpWIFI3aiCzUhAdeYCFkGCbtYSFkUgBhOKKglS3KTuVlLrFAC80fTDKG6+FInZYwDNMq8A1sW5a0tKzWMkwYonV6hJvri+ccoC9BUYzj+0UKFZaEBCzhdosEt1MWKmSQZbnxeqIj0PDyGSYmhFtREfbv1Wgfzd9tY+0Nt7SkgadKolUuT2kKkUJ8xRruETIMk/awEDJME0n0GsREBneIlJIzWlRIkPxBFCRBsAsFdqHoCeCdkidQBjXqlKPxiEbDQ2MmYTQlynSi0YSmOUJAJJq9g0VrhyQIKkSzc3jEK69xNNglBRIIdskLu1CQIXwCKEP1C6EXDqHA4S8zIkNNyBCZhZBhmJgiQdW9xr7dIoQMf+8v0Av0wi68kAX5vhp2lehfEzhXykLIxBfjUK6xv9gNOEias4c4Fj0/Jjq0nqCv5+fVe4CSUH09PpMY+n4ectDXeMNzhAzDpD0shAxjgeYIiccawHiT6JzA4QjeLywJ0ttm7A1a7StORHh+U9sS+jQm/RAUOBKBRUTseIb8byyp0o5YE7xdLpbzfEZRjJdA8hwhk1o0YeE0wzQX7hEyaU1r7aElk+B9xo11eCRjnzILIcMwaQ8LIdPi4CCpySUWu1tUkpqUzyRepE5LGIZJGZQ4TxekkggCLIRMmhGrOcHoc4VECJeVAonhm0skL244j7EKCQoJX68wivdPxKJqFkKGYdIeXj7DxIRkd2y0OcOmBnPQeomc7jM8KklRBW+wWiAdfJ8KCQoI9pi1rnm0qB5heXk5hBAoLS3Vy4gI8+bNQ2FhITIzMzFkyBDs27fPdF9dXR2mT5+O9u3bIzs7G2PHjsWhQ4cS3Hom0bTmMFkthUiRphs7DxnP3SYtRgi3b9+O5557Dn369DGVz58/HwsWLMDixYuxfft2FBQUYPjw4aipqdFtSktLsXr1aqxatQqbNm3CiRMnMGbMGCiKkujXYBgmBWkRQnjixAnceOONeP7559GuXTu9nIiwaNEiPPjgg7jmmmvQq1cvvPjiizh16hRWrlwJAHC73ViyZAl+//vfY9iwYTj33HOxYsUK7NmzBxUVFcl6JSZFaa1Lc6LNGBerzHJ6QFaDo0OlhvdtW12XRPwdJi1CCKdOnYrRo0dj2LBhpvL9+/ejsrISI0aM0MucTicGDx6MzZs3AwB27twJj8djsiksLESvXr10Gyvq6upQXV1tOpjmIUTgCG+ERmX2bCqtVfCA5CRvsqKhfcbR7iDhwKwAVq1ahV27dmH79u0h1yorKwEA+fn5pvL8/Hx8++23uo3D4TD1JDUb7X4rysvL8fDDDze3+QzDtABSukd48OBB3H333VixYgUyMjLC2omgLgYRhZQF05DNnDlz4Ha79ePgwYONazzTomnNjg/tvRLZc9R2ktSTDR6S9XIFEjwkQ/FfD15onago1SkthDt37sSxY8fQv39/2Gw22Gw2bNy4EX/4wx9gs9n0nmBwz+7YsWP6tYKCAtTX16OqqiqsjRVOpxNt2rQxHQzDtE5SWgiHDh2KPXv2YPfu3fpx/vnn48Ybb8Tu3bvxk5/8BAUFBdiwYYN+T319PTZu3IhBgwYBAPr37w+73W6yOXr0KPbu3avbMAyT3qT0HGFOTg569eplKsvOzkZeXp5eXlpairKyMhQXF6O4uBhlZWXIysrCxIkTAQAulwuTJk3CzJkzkZeXh9zcXMyaNQu9e/cOcb4wTDD6OkT/EK25C7fjSbySw8cii54CAZAED6BnrwP8Xmq/V1jLYKdAJHyhdUoLYTTMnj0btbW1mDJlCqqqqjBgwACsX78eOTk5us3ChQths9kwfvx41NbWYujQoVi2bBlkWY5QM8Mw6YIgaq2LCGJLdXU1XC4XhuDnsInA/yspM1M/F5kBh44wOncynPopZToC585AParTZjgPCLQ3QzaUB2YyFIchfLkzcO41nKuBR0ExnKuGf7eKE5b2RhvVYVgLZg+ckzOwayDs8jNDD0VI1uUIUy5M9xqTIoeWabaShZ1kUaf2VZbIslwE3avXj8D14Gv66wgylUlB9wbfIwkytdHq3HivXhb0tWF7NayduQ6fnTHDnzHXiFU7ZRAkocIuqf5k7b6E7hnGJO7+PCVaubYVz6HbeaGQhGypDhnCgwzhRYZQkCECPUWNEzUqzjv7O7jd7pjM36f0HCHDMEwiYCFkGCbtYSFkWhxWu1Ma3LGSAkRat9ecdYuptN5RC6QgW0Sg0YbFsvANn2VB8JBvSsgqYk0iYSFkGCbtYSFkGCbtafHLZ5gWSuqM5hJGpLV4zVn/l6htaNEgB7VF206nQECBgIdskISKemGDQ3gBAPUkQyI7HFBChsiJCLgAcI+QYRiGhZBhGIaHxkzq0szhM+cfSeyw2WqBN+AbHkskQRW+nCd2KFBJgioE7EKBBzZABSAB2ZI3qM4EtT0xj2EYhkldWAgZhkl7WAgZhkl7eI6QYZpJU3Mix3r+Ltr6rAIzRLS3sLMKuOCzjW6HiDF4gyx8u0yCd6MkaukMwD1ChmEYFkKGYRgWQoZh0h4WQoaJA0QiEOY/DNFGnDEGT40UlDXY3lQmGj931xRUSL7E7kFBXWUt2GtQwFg9Eg2066pu40sSz1vsGIZhEgILIcMwaQ8LIcMwaQ8LIcM0kcZGlY4UoToe91nOH0ZZFhxOy2enhthHmsOTg+YbJcM8oQwVGcJjms+Uo6w3HrAQMgyT9rAQMgyT9rAQMgyT9rAQMgyT9rAQMmlJPNN/NiW9ZjSOF6NN8NdYoDszghZDR3cvQRYUEnQh+H5JqP6D/M9SA+VQTYvHHVDDCpQaY18KCyHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPCyHDNAFqxGS9lSMkUmSaWDlArOppat2RdpUYo1M3FCXbLhTYheJri3/HTHB0agmqL9l7mKbG2lHieybDMEyaw0LIMEzaw0LIMEzaw0LIMEzaw0LIMI1AhQgbFiua8PyNfl5Tdqk0MmxXYJeKTw4USyeLFHV7AiH4A7tHJOELwa/V4xBeOIUHGcKDDFHvc5gI1bDTJHFh+gEWQoZhGBZChmEYFkKGYdKelBbC8vJyXHDBBcjJyUHHjh0xbtw4fP755yYbIsK8efNQWFiIzMxMDBkyBPv27TPZ1NXVYfr06Wjfvj2ys7MxduxYHDp0KJGvwjBMCpPSQrhx40ZMnToVW7duxYYNG+D1ejFixAicPHlSt5k/fz4WLFiAxYsXY/v27SgoKMDw4cNRU1Oj25SWlmL16tVYtWoVNm3ahBMnTmDMmDFQFCUZr8UwJqJxQERygEQTkktzUjQXq50juiMFkr6LRvGX2SWvvpPELhS/00SFXSi+sF1C1cN3abtLtHoSiS2hT2ska9euNX2/dOlSdOzYETt37sRll10GIsKiRYvw4IMP4pprrgEAvPjii8jPz8fKlStx5513wu12Y8mSJVi+fDmGDRsGAFixYgWKiopQUVGBkSNHJvy9GIZJLVK6RxiM2+0GAOTm5gIA9u/fj8rKSowYMUK3cTqdGDx4MDZv3gwA2LlzJzwej8mmsLAQvXr10m2sqKurQ3V1telgGKZ10mKEkIhw77334pJLLkGvXr0AAJWVlQCA/Px8k21+fr5+rbKyEg6HA+3atQtrY0V5eTlcLpd+FBUVxfJ1GIZJIVqMEE6bNg2ffvopXn755ZBrQgRH9qCQsmAaspkzZw7cbrd+HDx4sGkNZxgm5WkRQjh9+nSsWbMGH3zwATp37qyXFxQUAEBIz+7YsWN6L7GgoAD19fWoqqoKa2OF0+lEmzZtTAcTAUFhDgSOFkykXSOR8o0E3xNpZ0q0xCNfSUNIQcnajbs+NIcH4HN0KNCcJ0J3pNiFAgVCd4goQc4bbSeKDJ/jxC7C5yuJBykthESEadOm4Y033sD777+P7t27m653794dBQUF2LBhg15WX1+PjRs3YtCgQQCA/v37w263m2yOHj2KvXv36jYMw6Q3Ke01njp1KlauXIm33noLOTk5es/P5XIhMzMTQgiUlpairKwMxcXFKC4uRllZGbKysjBx4kTddtKkSZg5cyby8vKQm5uLWbNmoXfv3roXmWGY9CalhfDZZ58FAAwZMsRUvnTpUtx6660AgNmzZ6O2thZTpkxBVVUVBgwYgPXr1yMnJ0e3X7hwIWw2G8aPH4/a2loMHToUy5YtgyzLiXoVhmFSGEHUmKDj6Ut1dTVcLheG4OewCbteLmVm6uciMyNwnhE4R4ZTP6VMR+DcGahHddoM5wGB9mbIhvLATIbiCMwPKc7AuddwrgYeBcVwrtoN5U5Y2httVAcZygPn5AzMG5Ec5tfIMI1l8k1JZGkDw4JdYbARpvJQW8lvKyzuN1Xvv67ZawuERchXmK6H3A8KyYtsrMt4n35PUL5gY1ulIBvJ6hoatg+2NdejWtqY7zfnNpaCw/Fr+YiD5gjtUuB3weYPxy8LVQ/Nr92fITx6WYbkgV144RAK7MILOxQ4hAIJKvLkWmQJbYG1DwXa3ChwokbF+ed8B7fbHZP5+5TuETItiDDz9iKMyJlJ3f/FmkOioVwcsXxeop6lEU4EG32/Ie+ISgKy/s/EF4JL0XOU+Ow8JPucJ0KBDNXvMFGRLdXDnujPIKFPYxiGSUFYCBmGSXtYCBmGSXtYCBmGSXvYWcLEhLC7FY2T3ibHifW5CDdJnuCdKdpaikg7NSPZJNrJ0hDBO0Pihc9DTLpDBPA5RVS/Q8wDG6BC9yorkHw5UoTPEy0LFRlCSWi+EoB7hAzDMCyEDMMwLIQMw6Q9LIQMw6Q97CxhYkM0Tg6TU8F6+1x0jpPQ7XSxQgubFY+6WxpSMx0WwfdL/kTvgQTwqn9HScDO7t+FkugeGvcIGYZJe1gIGYZJe1gIGYZJe1gIGYZJe9hZ0gQ4BqEfR2N3K4TZZWIgvOMk1MaqrKk7UFqikyRSDMNUQoYvkbuW6B3wOVLChfuSkpDfhnuEDMOkPSyEDMOkPSyEDMOkPSyEDMOkPewsYWJD2DBczbg3DIGk6cbdKY2rI6QJYZI3Rb4n/LWmOi6iuS9VnSLh2qVAACTBA+gOExUCCgnYJd8OE8mf2F1GYsKFBcM9QoZh0h4WQoZh0h4WQoZh0h4WQoZh0h52ljCxIZr5e6N3gQw3mE4DNsJwwVi98NsYy1Q19BH6v3nDJL7uZqGggjBIQU4Uq9BUwTZGgssi3R/p+Y0JiRXJtimOlkj5ThrKhaKQ74cgG3aVyH7niBFZqHAIBRlCgR0EWQBKmKbGY+cJ9wgZhkl7WAgZhkl7WAgZhkl7WAgZhkl72FnSBNTaWv083H+SsKk6DIS71/hD8UZ1h9E+VjPJ1vWohjaY5rIbHZIrQGCnSIzDYEXpEGFSh0QndtfgHiHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPCyHDMGkPCyHDMGlPWgnhM888g+7duyMjIwP9+/fHP//5z2Q3iWGYFCBthPCVV15BaWkpHnzwQfzrX//CpZdeilGjRuHAgQPJbhrDMEkmbYRwwYIFmDRpEn71q1+hZ8+eWLRoEYqKivDss88mu2kMwySZtBDC+vp67Ny5EyNGjDCVjxgxAps3b7a8p66uDtXV1aaDYZjWSVoI4X//+18oioL8/HxTeX5+PiorKy3vKS8vh8vl0o+ioqJENJVhmCSQFkKoIYIS0RJRSJnGnDlz4Ha79ePgwYOJaCLDMEkgLcJwtW/fHrIsh/T+jh07FtJL1HA6nXA6nYloHsMwSSYteoQOhwP9+/fHhg0bTOUbNmzAoEGDktQqhmFShbToEQLAvffei5KSEpx//vkYOHAgnnvuORw4cACTJ09OdtMYhkkyaSOE119/Pb7//ns88sgjOHr0KHr16oV//OMf6Nq1a7KbxjBMkkkbIQSAKVOmYMqUKU26l/yJcL3wmGLUSyTr50KVLM9hiGJPhmStpAQuqN5AUH5VDtTp9QTOVSlQp2Jw8qiGc1O5of3GHLGq4YIC63JSjOWBm1Wvof2misKE6g+bs4Asy42h+k1h+0022kmorcn3pZVJhjYH20nmnMTB9VBQORnarVWhWuQ1tsp1LAky5fPVcyVb3Bf81ZSuOYyNVQ7kwDU15Fla3mjNXrORhXW579z3VQupL4QKSRBkQVCE4stZLAiyUPX6ZaFCESokoUIRCkh44RUKvMILVShQhQJICiBU2CQV9cKc11h7umr4FE6c8JWSMT92M0grIWwONTU1AIBN+If5Qm2Yc4Zh4k5NTQ1cLlez6xEUK0lt5aiqiiNHjiAnJyfskpumUl1djaKiIhw8eBBt2rSJad2JprW8C79HahH8HkSEmpoaFBYWQpKa7/PlHmGUSJKEzp07x/UZbdq0adG/rEZay7vwe6QWxveIRU9QIy2WzzAMw0SChZBhmLSHhTAFcDqdmDt3bqvYydJa3oXfI7WI93uws4RhmLSHe4QMw6Q9LIQMw6Q9LIQMw6Q9LIQMw6Q9LIQJ5JtvvsGkSZPQvXt3ZGZm4qc//Snmzp2L+vp6k92BAwdw9dVXIzs7G+3bt8eMGTNCbPbs2YPBgwcjMzMTnTp1wiOPPBKzfZdNJZWzBJaXl+OCCy5ATk4OOnbsiHHjxuHzzz832RAR5s2bh8LCQmRmZmLIkCHYt2+fyaaurg7Tp09H+/btkZ2djbFjx+LQoUOJfBUT5eXlEEKgtLRUL2tJ73H48GHcdNNNyMvLQ1ZWFvr164edO3fq1xP2LsQkjHfffZduvfVWWrduHf3f//0fvfXWW9SxY0eaOXOmbuP1eqlXr150+eWX065du2jDhg1UWFhI06ZN023cbjfl5+fThAkTaM+ePfT6669TTk4O/e53v0vGaxER0apVq8hut9Pzzz9P//nPf+juu++m7Oxs+vbbb5PWJiMjR46kpUuX0t69e2n37t00evRo6tKlC504cUK3efzxxyknJ4def/112rNnD11//fV05plnUnV1tW4zefJk6tSpE23YsIF27dpFl19+OfXt25e8Xm/C32nbtm3UrVs36tOnD919990t7j1++OEH6tq1K9166630ySef0P79+6miooK++uqrhL8LC2GSmT9/PnXv3l3//h//+AdJkkSHDx/Wy15++WVyOp3kdruJiOiZZ54hl8tFp0+f1m3Ky8upsLCQVFVNXOMNXHjhhTR58mRTWY8ePeiBBx5ISnsa4tixYwSANm7cSEREqqpSQUEBPf7447rN6dOnyeVy0Z/+9CciIvrxxx/JbrfTqlWrdJvDhw+TJEm0du3ahLa/pqaGiouLacOGDTR48GBdCFvSe9x///10ySWXhL2eyHfhoXGScbvdyM3N1b/fsmULevXqhcLCQr1s5MiRqKur04cMW7ZsweDBg02LS0eOHIkjR47gm2++SVjbNZqSJTDZuN1uANA/+/3796OystL0Dk6nE4MHD9bfYefOnfB4PCabwsJC9OrVK+HvOXXqVIwePRrDhg0zlbek91izZg3OP/98XHfddejYsSPOPfdcPP/880l5FxbCJPJ///d/ePrpp01RsisrK0PyqLRr1w4Oh0PPuWJlo30fLitfPGlKlsBkQkS49957cckll6BXr14AAp9bpHeorKyEw+FAu3btwtokglWrVmHXrl0oLy8PudaS3uPrr7/Gs88+i+LiYqxbtw6TJ0/GjBkz8Ne//lVvp9aucO2M1buwEMaAefPmQQgR8dixY4fpniNHjuDKK6/Eddddh1/96lema1Zhvigo455VRr5w9yaKxmQJTCbTpk3Dp59+ipdffjnkWlPeIZHvefDgQdx9991YsWIFMjIywtql+nsAvtB25513HsrKynDuuefizjvvxO23345nn33WZJeId2EhjAHTpk3DZ599FvHQeh6ATwQvv/xyPXeKkYKCgpD/ZFVVVfB4PPp/RiubY8eOAQj975kImpIlMFlMnz4da9aswQcffGAKq1ZQUAAgtEdtfIeCggLU19ejqqoqrE282blzJ44dO4b+/fvDZrPBZrNh48aN+MMf/gCbzRZ2ZJBq7wEAZ555Js4++2xTWc+ePXHgwAG9nUCC3iXq2UQmJhw6dIiKi4tpwoQJll4tzVly5MgRvWzVqlUhzpK2bdtSXV2dbvP4448n3Vly1113mcp69uyZMs4SVVVp6tSpVFhYSF988YXl9YKCAnriiSf0srq6OsuJ+VdeeUW3OXLkSEKdDNXV1bRnzx7Tcf7559NNN91Ee/bsaTHvQUR0ww03hDhLSktLaeDAgUSU2J8JC2ECOXz4MP3sZz+jK664gg4dOkRHjx7VDw1t+czQoUNp165dVFFRQZ07dzYtn/nxxx8pPz+fbrjhBtqzZw+98cYb1KZNm5RYPrNkyRL6z3/+Q6WlpZSdnU3ffPNN0tpk5K677iKXy0Uffvih6XM/deqUbvP444+Ty+WiN954g/bs2UM33HCD5VKNzp07U0VFBe3atYuuuOKKpC2f0TB6jYlaznts27aNbDYbPfbYY/Tll1/SSy+9RFlZWbRixYqEvwsLYQJZunQpwZe1KOQw8u2339Lo0aMpMzOTcnNzadq0aaalMkREn376KV166aXkdDqpoKCA5s2bl7TeoMYf//hH6tq1KzkcDjrvvPP0pSmpQLjPfenSpbqNqqo0d+5cKigoIKfTSZdddhnt2bPHVE9tbS1NmzaNcnNzKTMzk8aMGUMHDhxI8NuYCRbClvQeb7/9NvXq1YucTif16NGDnnvuOdP1RL0Lh+FiGCbtYWcJwzBpDwshwzBpDwshwzBpDwshwzBpDwshwzBpDwshwzBpDwshwzBpDwsh02r55ptv9KAX/fr1a3Z9Wl1t27Ztdl1MasFCyLR6Kioq8N577zW7nqNHj2LRokXNbxCTcrAQMq2evLw85OXlNbuegoICuFyuGLSISTVYCJkWwfHjx1FQUICysjK97JNPPoHD4cD69esbVdett96KcePGoaysDPn5+Wjbti0efvhheL1e3HfffcjNzUXnzp3xwgsvxPo1mBTFluwGMEw0dOjQAS+88ALGjRuHESNGoEePHrjpppswZcqUkBQB0fD++++jc+fO+Oijj/Dxxx9j0qRJ2LJlCy677DJ88skneOWVVzB58mQMHz4cRUVFcXgjJpXgHiHTYrjqqqtw++2348Ybb8TkyZORkZGBxx9/vEl15ebm4g9/+APOOuss3HbbbTjrrLNw6tQp/PrXv0ZxcTHmzJkDh8OBjz/+OMZvwaQiLIRMi+J3v/sdvF4v/va3v+Gll16KGK4+Eueccw4kKfDrn5+fj969e+vfy7KMvLw8PfI307phIWRaFF9//TWOHDkCVVXx7bffNrkeu91u+l4IYVmmqmqTn8G0HHiOkGkx1NfX48Ybb8T111+PHj16YNKkSdizZ0/K5UVhWh7cI2RaDA8++CDcbjf+8Ic/YPbs2ejZsycmTZqU7GYxrQAWQqZF8OGHH2LRokVYvnw52rRpA0mSsHz5cmzatCkk/SPDNBYeGjMtgiFDhsDj8ZjKunTpgh9//LHRdS1btiyk7MMPPwwp++abbxpdN9MyYSFkWj2DBg1Cv379sHnz5mbVc8YZZ8Dr9TbZU82kLiyETKulc+fO+PLLLwEATqez2fXt3r0bgG9pDdO64Cx2DMOkPewsYRgm7WEhZBgm7WEhZBgm7WEhZBgm7WEhZBgm7WEhZBgm7WEhZBgm7WEhZBgm7WEhZBgm7fn/8or1i43WipAAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -372,7 +389,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -410,7 +427,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -419,13 +436,13 @@
        "Text(0.5, 1.0, 'lateral extended 2D grid')"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -456,7 +473,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -468,7 +485,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x800 with 5 Axes>"
       ]
@@ -478,7 +495,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -488,7 +505,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -498,7 +515,7 @@
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 3 Axes>"
       ]
@@ -524,7 +541,7 @@
     "\n",
     "xb_setup.set_params({'Wavemodel'    :   'surfbeat',\n",
     "                     'morphology'   :   0,\n",
-    "                     'befriccoef'   :   0.01,\n",
+    "                     'bedfriccoef'   :   0.01,\n",
     "                     'tstop'        :   3600,\n",
     "                     'zs0'          :   0,\n",
     "                     'nglobalvar'   :   ['zb', 'zs', 'H'],\n",
@@ -548,7 +565,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -562,7 +579,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "D:\\Users\\bemc\\AppData\\Local\\Temp\\ipykernel_11248\\1464800397.py:1: FionaDeprecationWarning: This function will be removed in version 2.0. Please use CRS.from_epsg() instead.\n",
+      "C:\\Users\\johnm\\AppData\\Local\\Temp\\ipykernel_2164\\1464800397.py:1: FionaDeprecationWarning: This function will be removed in version 2.0. Please use CRS.from_epsg() instead.\n",
       "  visualize_mesh.write_mesh_to_shp(xgr, ygr, os.path.join('xb-2D','shape/grid.shp'),0)\n"
      ]
     }
@@ -588,7 +605,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,
diff --git a/xbTools/doc_utilities/__pycache__/doc_utilts.cpython-312.pyc b/xbTools/doc_utilities/__pycache__/doc_utilts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..864d4e82b68a0be4a0b345a7548fb843705ef54e
GIT binary patch
literal 1497
zcmZ8hL2nyH6rR~#JGRqANpYZ1il#~(<hJC9id99Rv_a(%L<lOfT&*^{<9OZmt~E0&
zVrz|j=%GhfNTg9(B}Y&$`~>b?T;+n6OC(OYwYVprcr#wxZJ#u=@6F76^X7f;+rQ@K
zatOrlMpa}W^sh9=q9w}UCMf&JL1pA%NAqwQtFKnp9Q_e0>rUD+9^ta#q`*qGwBk&A
zHMbG^wr~TV6A_Ra^_rv+IBvB?EZ-qNF;`IH1a{b<zTmlYdDW(klN;p+vOzkG@$EQ5
z^*8tB84yQ1NmdV$qd(WbM@6IkYmR{Yz^NlIuLi7P2_k9~@~|Ari0ArL*{)BT7PA_B
zRqP2;bv>#))#UokQ1Ft{WjI0iM2T?0Tz_}6C^xntu-qiP7KENdb|?W)0<ou8Du<y_
zC=|%~*N}GGAfOj<obu`+7oZq21eb3i!_s=Ga(C;_dS!2iT6XO-5d_{&um|QgXuJZ2
zGehBeu5jtp5`4AUiZ70yYmT03%BQj{M3sYo3{w}qTtM>|d)M}_Ke_&N>zCF3;??7P
ze|DvBtPEfu*<;|PF@fPrFrWzlhC}pR>u3=c6F8y?2yJMmj_zoY-cEsLM4E&pGQej9
z%`H`ljVUBN+~HJpN`ej_S5DP*f(etE3~^zI2~<n>s9#L68CZ+cpzn%WoE~8l&--D+
zY*J>M+}-tgoSW(#l0p(Q!ZOnJQc|pG5=q_Id$27BzXcPNEQ1#Ey*s_nA3x}BoGo2`
zW*@H{K76rM>~5Yd=6gTCSS)nE`FlS9_{ZLNy>`#*&o1|kWhTk>RyotKpt|}PlzlWU
zp_mlCE+6`i)a66pkqAZjB=K@4T1OKSX(e^V?XflbMp}LD?G<UABugg=q#ZqyaB1z1
zf@=$C!-+-eJn$8N85JP|YP*71a>H?Lp-ygoyM4Dr)-7MMAWR781;Im-Fi?d6YH*vm
zO`uFbT0ux`aNu;zNy$4EEyk=k6B|L3`mq-9*l1dSvr!LRA7)4f=o3I{vB4n2q7lzl
z0}lvps&iS{JEm_nXq=UYO=%~pOqk0;PkSM=ONA-Vv8%BD2@HN4rY?Ftk3PKeZ0qR$
z!TqDkLFKm_f3!}oeD&w@>7|YCz1L~9xU`>pl6(5a(b~b<>E#=z3pcy>&Svv{Bd_o;
z;`2?2Q%uJ*rYV_gvX8)KAIM2!rFu<W`a4n{syBz3+wj8-J-WsUa7Y5fWnwRNjPWZ?
d!^R+o@P&U+_CF(oKON+=_}bw83wTL|_#b5OcHsa3

literal 0
HcmV?d00001

diff --git a/xbTools/doc_utilities/doc_utilts.py b/xbTools/doc_utilities/doc_utilts.py
new file mode 100644
index 0000000..2da124a
--- /dev/null
+++ b/xbTools/doc_utilities/doc_utilts.py
@@ -0,0 +1,42 @@
+"""
+Functions to help modify and write documents
+"""
+
+# Standard imports
+import json
+import os
+
+def format_header_line(text):
+    """
+    Used to format the header line the in params.txt file
+    
+    inputs:
+        text: string
+            The text should be put in the header
+    """
+    return f"%%% {text.ljust(71)} %%%"
+
+def format_subsection_header(text, length = 78):
+    """
+    Format the subsection headers in the text file
+    """
+    string = f"%%% {text}"
+
+    num_perc_signs = length - len(string)
+
+    perc_signs = "%" * num_perc_signs
+    return f"{string} {perc_signs}"
+
+def get_json(folder_path, file_name):
+    """
+    Reads a json and returns it as a dict
+    NOTE: Can be used to look at the json in script so you can see the inputs
+    """
+
+    ## Open the json file
+    json_file         = open(os.path.join(folder_path, file_name),'r')
+
+    # Read the json file and store it as a python dict
+    json_dict = json.loads(json_file.read())
+
+    return json_dict
\ No newline at end of file
diff --git a/xbTools/par.json b/xbTools/par.json
index f7b7d16..cb163f0 100644
--- a/xbTools/par.json
+++ b/xbTools/par.json
@@ -1,9 +1,6 @@
 {
-    "_General": [
-        "wavemodel",
-        "wbctype"
-    ],
     "Physical processes": [
+        "wavemodel",
         "sedtrans",
         "morphology",
         "vegetation",
@@ -13,22 +10,13 @@
         "viscosity",
         "swrunup",
         "swave",
+        "lwave",
         "snells",
         "single_dir",
         "setbathy",
         "gwflow",
         "avalanching",
-        "cyclic",
-        "nonhq3d"
-    ],
-    "Initial conditions": [
-        "zs0",
-        "zsinitfile",
-        "hotstartflow"
-    ],
-    "Model time": [
-        "tstop",
-        "CFL"
+        "cyclic"
     ],
     "Grid parameters": [
         "thetamin",
@@ -38,38 +26,114 @@
         "thetanaut",
         "posdwn"
     ],
+    "Model time": [
+        "CFL",
+        "dtset",
+        "tstop",
+        "maxdtfac"
+    ],
+    "Physical constants": [
+        "rho",
+        "g",
+        "depthscale"
+    ],
+    "Initial conditions": [
+        "zsinitfile",
+        "hotstartflow"
+    ],
+    "Wave boundary condition parameters": [
+        "Hrms",
+        "Tlong",
+        "Trep",
+        "dir0",
+        "instat",
+        "lateralwave",
+        "m",
+        "taper",
+        "Tm01",
+        "wbctype"
+    ],
     "Flow boundary condition parameters": [
         "front",
         "back",
         "left",
-        "right"
+        "right",
+        "ARC",
+        "order",
+        "highcomp",
+        "freewave",
+        "epsi",
+        "tidetype"
+    ],
+    "Tide boundary conditions": [
+        "zs0",
+        "zs0file",
+        "tideloc",
+        "paulrevere"
+    ],
+    "Discharge boundary conditions": [
+        "disch_loc_file",
+        "disch_timeseries_file",
+        "ndischarge",
+        "ntdischarge",
+        "beta"
     ],
     "Flow parameters": [
-        "tidetype",
-        "epsi",
         "bedfriction",
+        "bedfricfile",
         "bedfriccoef",
+        "maxcf",
+        "mincf",
+        "nuh",
         "nuhfac",
-        "bedfricfile"
+        "smag"
+    ],
+    "Coriolis force parameters": [
+        "wearth",
+        "lat"
+    ],
+    "Non-hydrostatic correction parameters": [
+        "solver",
+        "solver_maxit",
+        "solver_acc",
+        "solver_urelax",
+        "kdmin",
+        "Topt",
+        "nonhq3d",
+        "nhbreaker",
+        "nhlay",
+        "dispc",
+        "breakviscfac",
+        "maxbrsteep",
+        "reformsteep"
+    ],
+    "Bed composition parameters": [
+        "ngd",
+        "nd",
+        "D50",
+        "D90"
+    ],
+    "Output": [
+        "outputformat",
+        "tintg",
+        "tintm",
+        "tstart",
+        "tintp",
+        "tintc",
+        "nrugdepth",
+        "outputprecision",
+        "timings"
+    ],
+    "_Output": [
+        "nglobalvar",
+        "nmeanvar",
+        "npointvar",
+        "npoints"
     ],
     "Flow numerics parameters": [
         "eps",
         "eps_sd"
     ],
-    "Tide boundary conditions": [
-        "zs0file",
-        "tideloc",
-        "paulrevere"
-    ],
-    "Wave boundary condition parameters": [
-        "Hrms",
-        "Tlong",
-        "Trep",
-        "dir0",
-        "m",
-        "taper",
-        "Tm01"
-    ],
     "Wave-spectrum boundary condition parameters": [
         "rt",
         "Tm01switch",
@@ -113,10 +177,6 @@
         "rhos",
         "ngd"
     ],
-    "Bed composition parameters": [
-        "D50",
-        "D90"
-    ],
     "Bed update numerics parameters": [
         "nTrepavaltime"
     ],
@@ -139,21 +199,7 @@
         "dryslp",
         "fixedavaltime"
     ],
-    "Output": [
-        "outputformat",
-        "tintg",
-        "tintm",
-        "tstart",
-        "tintp",
-        "tintc",
-        "nrugdepth",
-        "outputprecision",
-        "timings"
-    ],
-    "_Output": [
-        "nglobalvar",
-        "nmeanvar",
-        "npointvar",
-        "npoints"
+    "par":[
+        "This will store parameters that are missing from all the other sections"
     ]
 }
\ No newline at end of file
diff --git a/xbTools/xbeachtools.py b/xbTools/xbeachtools.py
index 8a2383b..e465fd5 100644
--- a/xbTools/xbeachtools.py
+++ b/xbTools/xbeachtools.py
@@ -11,7 +11,6 @@
 import numpy as np
 import os
 from datetime import datetime
-import json
 import matplotlib.pyplot as plt
 
 # import rotate grid from geometry
@@ -21,6 +20,9 @@
 # Dictionary functions
 from xbTools.general.file_utils import write_2d_arr_2_file
 
+# Document Functions
+from xbTools.doc_utilities.doc_utilts import format_subsection_header, format_header_line, get_json
+
 class XBeachModelSetup():
     '''
     XBeach model setup class
@@ -53,9 +55,10 @@ def __str__(self):
         """        
         return self.file_name
     
-    def set_params(self,input_par_dict):
+
+    def set_params(self,input_par_dict, json_file_name = "par.json"):
         """
-        Sets the wavemodel and any of the parameters in the par.json file (?) for the model
+        Sets the wavemodel and any of the parameters in the par.json file for the model
 
         Args:
             input_par_dict (dict): dict of input param flags and the associated values
@@ -70,28 +73,31 @@ def set_params(self,input_par_dict):
         ## set wbctype
         if 'wbctype' in input_par_dict:
             self.wbctype = input_par_dict['wbctype'] 
+        
+        # Get the json file that contains all of the parameters in ther proper subsection so that the self.input_par
+        # can be put under the right headers
+        folder_path = os.path.dirname(__file__)
 
-        ## load parameters and categories
-        # Open the par.json file in read mode
-        f           = open(os.path.join(os.path.dirname(__file__), 'par.json'),'r')
+        # Add store it in the class
+        self.json_param_dict = get_json(folder_path, file_name = json_file_name)
 
-        # Read the json file and store it as a python dict
-        par_dict    = json.loads(f.read())
-        
         ## create input dict
         self.input_par = {}
 
         # Init 'par' key as a nested dict
         self.input_par['par'] = {}
 
+        # Init flag to track if parameters aren't found in the JSON
+        not_found_params = False
+
         ## loop over input parameters 
         for input_par in input_par_dict:
             value_added = False
 
             ## loop over categories from the par.json file
-            for par_category in par_dict:
+            for par_category in self.json_param_dict:
                 ## if input parameter is in category, add parameter
-                if input_par in par_dict[par_category]:
+                if input_par in self.json_param_dict[par_category]:
                     ## create category if not exist
                     if not par_category in self.input_par:
                         self.input_par[par_category] = {}
@@ -103,7 +109,13 @@ def set_params(self,input_par_dict):
             if not value_added:
                 # Add all parameters that don't match a key in the par.json file to this new dict
                 self.input_par['par'][input_par] = input_par_dict[input_par]
-            
+
+                not_found_params = True
+        
+        # Print out the params that weren't found. This will help catch typo errors
+        if not_found_params:
+            print(f"The following params were not found in the JSON: \n{self.input_par['par']}")
+
     def set_grid(self,xgr,ygr,zgr, posdwn=1, xori=0, yori=0,alfa=0, thetamin=-90, thetamax = 90, thetanaut = 0, dtheta=10, dtheta_s=10):
         """_summary_
 
@@ -150,11 +162,13 @@ def set_grid(self,xgr,ygr,zgr, posdwn=1, xori=0, yori=0,alfa=0, thetamin=-90, th
             self.ny = 0
         else:
             self.fast1D = False 
+        
+        # TODO: Store the grid data in a dictionary
+
         ## set values
         self.posdwn = posdwn
         self.xori   = xori
         self.yori   = yori
-        self.yori   = yori
         self.thetamin   = thetamin
         self.thetamax   = thetamax
         self.thetanaut  = thetanaut
@@ -253,6 +267,7 @@ def _get_wbctype_required_params(wbctype):
         """
 
         # Using False to note that the required parameters haven't been included here yet
+        # TODO: Update the ts_nonh required parameters to make it more general
         wbctype_options = {'swan'        : False,
                           'vardens'      : False,
                            'off'         : False,
@@ -260,7 +275,7 @@ def _get_wbctype_required_params(wbctype):
                            'resuse'      : False, 
                            'ts_1'        : False, 
                            'ts_2'        : False, 
-                           'ts_nonh'     : ["boun_U_dict"],
+                           'ts_nonh'     : ["make_file", "file_name", "dimension", "variable_dict"],
                            'parametric': ['Hm0','Tp','mainang','gammajsp','s','fnyq']
                            }
 
@@ -314,6 +329,7 @@ def _get_instat_required_params(instat_type):
         """
 
         # Using False to note that the required parameters haven't been included here yet
+        # TODO: Update the ts_nonh required parameters to make it more general
         instat_type_options = {
                                 'bichrom'     : False,
                                 'ts_1'        : False, 
@@ -322,7 +338,7 @@ def _get_instat_required_params(instat_type):
                                 'swan'        : False,
                                 'vardens'     : False,
                                 'resuse'      : False, 
-                                'ts_nonh'     : ["boun_U_dict"],
+                                'ts_nonh'     : ["make_file", "file_name", "dimension", "variable_dict"],
                                 'off'         : False,
                                 'stat_table'  : ['Hm0','Tp','mainang','gammajsp','s','duration','dtbc'],
                                 'jonstable '  : ['Hm0','Tp','mainang','gammajsp','s','fnyq']
@@ -339,7 +355,7 @@ def _get_instat_required_params(instat_type):
         
         return required_params
 
-    def set_waves(self, wbctype, input_struct, instat_bc = False):
+    def set_waves(self, wbctype, input_struct, instat_bc = False, num_deci_dig = 5):
         """
 
         Gets the required inputs for the selected boundary condition and stores the values in a dict for 
@@ -367,6 +383,8 @@ def set_waves(self, wbctype, input_struct, instat_bc = False):
         elif instat_bc:
             # Use the instat conditions
             required_par = self._get_instat_required_params(wbctype)
+        else: 
+            TypeError("instat_bc should be a boolean. Type is: {}".format(type(instat_bc)))
 
         # Store the required parameters for later usage
         self.required_wbc_params = required_par
@@ -382,7 +400,7 @@ def set_waves(self, wbctype, input_struct, instat_bc = False):
             
             # If param is in input string add it to waves_boundary dict for later output
             self.waves_boundary[item] =  input_struct[item]
-        
+            
     def set_vegetation(self):
         """_summary_
         """        
@@ -455,7 +473,7 @@ def load_model_setup(self,path):
         ## todo
         pass    
 
-    def _write_boun_U_file(self, path, boun_U_dict):
+    def _write_boun_U_file(self, path, boun_U_dict, num_dec_dig):
         """
         Writes the boundary conditon file that is required for ts_nonh models
         
@@ -478,6 +496,7 @@ def _write_boun_U_file(self, path, boun_U_dict):
                            "dV": "dV data",
                            "q" : "q data",
                            "dq": "dq data"
+                           "zs": "surface pertubation data" 
                        }         
             }
 
@@ -526,7 +545,7 @@ def _write_boun_U_file(self, path, boun_U_dict):
             file.write("{}\n".format(boun_U_dict["dimension"]))
             file.write("{}\n".format(num_variables))
             file.write("{}\n".format(string_variables))
-            np.savetxt(file, data, delimiter=' ', fmt='%10.5f')
+            np.savetxt(file, data, delimiter=' ', fmt=f'%10.{num_dec_dig}f')
 
         print("Data written to {}".format(file_path))
 
@@ -579,7 +598,7 @@ def _write_jonswap_file(self, path, tab_number, file_name = "jonswap.txt"):
                     # Set up the next row
                     f.write('\n')
     
-    def _write_wbc_file(self, path):
+    def _write_wbc_file(self, path, num_dec_dig):
         """
         Wrapper for the functions that write the files that are needed for the wave boundary conditons
         """ 
@@ -588,12 +607,14 @@ def _write_wbc_file(self, path):
         
         # Modes that require the boun_U_dict file
         if self.wbctype == "ts_nonh":
-            boun_U_dict = self.required_wbc_params["boun_U_dict"]
-
+            boun_U_dict = self.waves_boundary
+            
             # Check if the file should be created...
+            # The first index should be "make_file"
+            # TODO: Update the required parameters to be a 
             if boun_U_dict["make_file"]:
                 # If True make the file
-                self._write_boun_U_file(path, boun_U_dict)
+                self._write_boun_U_file(path, boun_U_dict, num_dec_dig)
 
         # wbctypes that require the jonswap.txt file
         elif self.wbctype == "parametric" or self.wbctype == "jonstable":
@@ -603,24 +624,40 @@ def _write_wbc_file(self, path):
             raise Warning("Writing the files for wbctype: {} is not implemented".format(self.wbctype))
     
     @staticmethod
-    def _write_params_metadata(file, file_name, current_date, user):
+    def _write_params_metadata(file, current_date, user):
         """
         Write the Meta data of the params file
         """
-        ## Write the meta data
-        file.write('%% XBeach model: {} \n'.format(file_name))
-        file.write('%% Params created on {} \n'.format(current_date))
-        file.write('%% Params created by {} \n'.format(user))
-        file.write('\n')
+        # Def a function to format the header lines 
+
+        
+        function_name = "_write_params_metadata"
+
+        header = [
+        "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%",
+        format_header_line("XBeach parameter settings input file"),
+        format_header_line(""),
+        format_header_line(f"date:     {current_date}"),
+        format_header_line(f"Params created by {user}"),
+        format_header_line(f"function: {function_name}"),
+        "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\n",
+        ]
+        
+        # Make the list into a string and add the newline values
+        header = "\n".join(header)
+
+        # Write the metadata
+        file.write(header)
 
     @staticmethod
     def _write_params_general_data(file, wavemodel, wbctype, tab_number):
         """
         Write the general data into the params file
+
+        TODO: WaveHello - In the process of deprecating this function
         """
 
         ## general
-        file.write('%% General \n')
         file.write('\n')
         if wavemodel is not None:
             file.write('wavemodel\t= {}\n'.format(wavemodel).expandtabs(tab_number))
@@ -633,8 +670,11 @@ def _write_params_grid_data(self, file, tab_number):
         """
         TODO: Check if this needs to be a internal module. 
         For the time being this is going to be the only one that stays inside of the class"""
+
+        # TODO: Once the grid data is stored in a dictionary update this to follow the format of the other parameters
+
         ## grid
-        file.write('%% Grid \n')
+        file.write(f"{format_subsection_header("Grid parameters")}\n" )
         file.write('\n')
         file.write('vardx\t= {}\n'.format(self.vardx).expandtabs(tab_number))
         file.write('posdwn\t= {}\n'.format(self.posdwn).expandtabs(tab_number))
@@ -661,8 +701,7 @@ def _write_params_tide_data(self, file, tab_number):
         """
         Write the tide data to the file
         """
-
-        file.write('%% Tide boundary conditions \n')
+        file.write(f"{format_subsection_header("Tide Boundary Conditions")}\n" )
         file.write('\n')     
 
         if self.zs0type == 'par':
@@ -677,20 +716,41 @@ def _write_params_tide_data(self, file, tab_number):
 
     def _write_params_input_vars(self, file, tab_number):
         """
-        Write the input variables? into the param file
-        # TODO: Check what this is doing """
+        Writes the input parameters (self.input_par) to the params.txt file in the specified file
+
+        Inputs:
+            self: Current instance of class
+            file: File that the param data should be written to
+            tab_number: Number of tabs that should follow a parameter in the file
+
+        """
+
+        # Create a new ordered dictionary based on the order of json file
+        # This way the order follows the JSON file
+        # The JSON file can be put in the same order of the xBlog file making comparing the sections easier
+        ordered_param_dict = {k: self.input_par[k] for k in self.json_param_dict if k in self.input_par}
 
-        for par_category in self.input_par:
-            ## skip category starting with _
+        if "wbctype" not in ordered_param_dict["Wave boundary condition parameters"].keys():
+            print(("\nWARNING: Include the wbctype in the set_params function. "
+                   "In the process of moving away from printing the "
+                   "wbctype at the top of the params.txt file"
+                ))
+        
+        # Loop over the parameter categories in the input dict...
+        for par_category in ordered_param_dict:
+            ## skip category starting with _. The name of the category is set in the JSON file
             if par_category[0]=='_':
                 continue
             
             ## write meta
-            file.write('%% {} \n'.format(par_category))
+            # Write the header of the category the parameter is in
+            file.write(f"{format_subsection_header(par_category)}\n" )
             file.write('\n')
 
-            for par in self.input_par[par_category]:
-                file.write('{}\t= {}\n'.format(par,self.input_par[par_category][par]).expandtabs(tab_number))
+            # Go through all of the inputs in the category write those values
+            for par in ordered_param_dict[par_category]:
+                file.write('{}\t= {}\n'.format(par,ordered_param_dict[par_category][par]).expandtabs(tab_number))
+
             file.write('\n')
     
     def _write_params_output_vars(self, file, tab_number):
@@ -699,7 +759,7 @@ def _write_params_output_vars(self, file, tab_number):
         
         ## write output variables
         if '_Output' in self.input_par:
-            file.write('%% Output variables \n')
+            file.write(f"{format_subsection_header("Output variables")}\n" )
             file.write('\n')
             for par in self.input_par['_Output']:
                 dummy = self.input_par['_Output'][par]
@@ -724,10 +784,12 @@ def _write_params_file(self, path_params, current_date, user, tab_number):
             # TODO: Move these functions into a util file to make this class smaller
 
             # Write the metadata at the top of the file
-            self._write_params_metadata(f, self.file_name, current_date, user)
+            self._write_params_metadata(f, current_date, user)
 
             # Write the general data
-            self._write_params_general_data(f, self.wavemodel, self.wbctype, tab_number)
+            # 
+            # NOTE: WaveHello - Commented out because the data is being written under the correct subheader now
+            # self._write_params_general_data(f, self.wavemodel, self.wbctype, tab_number)
             
             self._write_params_grid_data(f, tab_number)
 
@@ -741,13 +803,13 @@ def _write_params_file(self, path_params, current_date, user, tab_number):
             # Write the output vars
             self._write_params_output_vars(f, tab_number)
 
-    def write_model(self, path, figure=True):
+    def write_model(self, path, figure=False, num_dec_dig = 5):
         """
         Wrapper for functions that write the input files for the model
 
         Args:
-            path (string): _description_
-            figure (bool, optional): _description_. Defaults to True.
+            path (string): Path to where the xBeach data is written to
+            figure (bool, optional): _description_. Defaults to False.
         """        
         self.model_path = path
         path_params = os.path.join(path,'params.txt')
@@ -762,7 +824,7 @@ def write_model(self, path, figure=True):
         tab_number = 20
         
         # Write the wave boundary condition files
-        self._write_wbc_file(path)
+        self._write_wbc_file(path, num_dec_dig)
         
         # Write the params file
         self._write_params_file(path_params, current_date, user, tab_number)

From 96860830bce7fc87b13488943fbece19223516a6 Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Wed, 10 Jul 2024 14:17:21 -0500
Subject: [PATCH 3/8] Added file utils and formatted some functions.

---
 xbTools/doc_utilities/doc_utilts.py | 42 -----------------------------
 xbTools/general/executing_runs.py   | 25 ++++++++++++-----
 xbTools/general/file_utils.py       | 37 +++++++++++++++++++++++++
 xbTools/xbeachpost.py               |  8 +++---
 xbTools/xbeachtools.py              | 30 ++++++++++++++++-----
 5 files changed, 83 insertions(+), 59 deletions(-)
 delete mode 100644 xbTools/doc_utilities/doc_utilts.py

diff --git a/xbTools/doc_utilities/doc_utilts.py b/xbTools/doc_utilities/doc_utilts.py
deleted file mode 100644
index 2da124a..0000000
--- a/xbTools/doc_utilities/doc_utilts.py
+++ /dev/null
@@ -1,42 +0,0 @@
-"""
-Functions to help modify and write documents
-"""
-
-# Standard imports
-import json
-import os
-
-def format_header_line(text):
-    """
-    Used to format the header line the in params.txt file
-    
-    inputs:
-        text: string
-            The text should be put in the header
-    """
-    return f"%%% {text.ljust(71)} %%%"
-
-def format_subsection_header(text, length = 78):
-    """
-    Format the subsection headers in the text file
-    """
-    string = f"%%% {text}"
-
-    num_perc_signs = length - len(string)
-
-    perc_signs = "%" * num_perc_signs
-    return f"{string} {perc_signs}"
-
-def get_json(folder_path, file_name):
-    """
-    Reads a json and returns it as a dict
-    NOTE: Can be used to look at the json in script so you can see the inputs
-    """
-
-    ## Open the json file
-    json_file         = open(os.path.join(folder_path, file_name),'r')
-
-    # Read the json file and store it as a python dict
-    json_dict = json.loads(json_file.read())
-
-    return json_dict
\ No newline at end of file
diff --git a/xbTools/general/executing_runs.py b/xbTools/general/executing_runs.py
index 05a3d4d..edfd8f8 100644
--- a/xbTools/general/executing_runs.py
+++ b/xbTools/general/executing_runs.py
@@ -96,13 +96,13 @@ def generate_batch_script(model_folder, exe_path, batch_file_name = "run_model.b
 
     if batch_file_folder is None:
         # Make the batch file path
-        batch_file_path = os.path.join(model_folder, batch_file_name)
+        batch_script_path = os.path.join(model_folder, batch_file_name)
     
     else:
         # Make the include_cd statement true, because for the batch file to be saved in a different directory than the model it will have to cd into
         # that directory
         include_cd = True
-        batch_file_path = os.path.join(batch_file_folder)
+        batch_script_path = os.path.join(batch_file_folder)
 
     # init empty string to possibly hold the change directory statement
     cd_str = ""
@@ -114,11 +114,11 @@ def generate_batch_script(model_folder, exe_path, batch_file_name = "run_model.b
     batch_str = cd_str + "call \"{}\"".format(exe_path)
 
     # Create the file and open it in write mode
-    with open(batch_file_path, "w") as f:
+    with open(batch_script_path, "w") as f:
         # write the string to the batch file
         f.write(batch_str)
 
-def run_batch_script(batch_script_path):
+def run_batch_script(batch_script_path, flag_print_Blog = False):
     # TODO: Need to test this some more. There are some troubles when the permissions 
     """
     Run a batch script given a path
@@ -137,13 +137,24 @@ def run_batch_script(batch_script_path):
     '''
     """
 
-    # Run the batch file
+    # Set the working directory to where the batch file is located
+    working_directory = os.path.dirname(batch_script_path)
+
     try:
-        subprocess.run(batch_script_path, check=True, shell=True)
+        # Execute the batch file, capturing both stdout and stderr
+        result = subprocess.run(batch_script_path, check=True, shell=True, cwd=working_directory, capture_output=True, text=True)
+        
+        # Print success message and output
         print(f"Batch file '{batch_script_path}' executed successfully.")
+
+        if flag_print_Blog:
+            print("Output:")
+            print(result.stdout)
     except subprocess.CalledProcessError as e:
-        # If not succcessful catch the error and print to the python script
+        # Print error message and captured stderr
         print(f"An error occurred while executing the batch file: {e}")
+        print("Error output:")
+        print(e.stderr)
 
 if __name__ == "__main__":
     pass
diff --git a/xbTools/general/file_utils.py b/xbTools/general/file_utils.py
index dd68474..6d7d59f 100644
--- a/xbTools/general/file_utils.py
+++ b/xbTools/general/file_utils.py
@@ -2,6 +2,10 @@
 Functions that help you output or work with files
 """
 
+# Standard imports
+import json
+import os
+
 def write_2d_arr_2_file(arr, file_path, decimal_digits=3):
     """
     Writes a 2d array into a file with each row of the 2d array written as a row in the file.
@@ -22,4 +26,37 @@ def write_2d_arr_2_file(arr, file_path, decimal_digits=3):
             formatted_row = ' '.join(format_str.format(value) for value in row)
             file.write(formatted_row + '\n')
 
+def format_header_line(text):
+    """
+    Used to format the header line the in params.txt file
+    
+    inputs:
+        text: string
+            The text should be put in the header
+    """
+    return f"%%% {text.ljust(71)} %%%"
+
+def format_subsection_header(text, length = 78):
+    """
+    Format the subsection headers in the text file
+    """
+    string = f"%%% {text}"
+
+    num_perc_signs = length - len(string)
+
+    perc_signs = "%" * num_perc_signs
+    return f"{string} {perc_signs}"
+
+def get_json(folder_path, file_name):
+    """
+    Reads a json and returns it as a dict
+    NOTE: Can be used to look at the json in script so you can see the inputs
+    """
+
+    ## Open the json file
+    json_file         = open(os.path.join(folder_path, file_name),'r')
+
+    # Read the json file and store it as a python dict
+    json_dict = json.loads(json_file.read())
 
+    return json_dict
\ No newline at end of file
diff --git a/xbTools/xbeachpost.py b/xbTools/xbeachpost.py
index b555694..6a78bb3 100644
--- a/xbTools/xbeachpost.py
+++ b/xbTools/xbeachpost.py
@@ -667,7 +667,7 @@ def _fig_map_var(self, dat, label, figsize=None, figax = None, **kwargs):
 
         return fig, ax
 
-    def fig_map_var(self, var, label=None, it=np.inf, figsize=None, figax=None, **kwargs):
+    def fig_map_var(self, var,  label=None, it=np.inf, time_unit = "sec", figsize=None, figax=None, **kwargs):
         """_summary_
 
         Args:
@@ -727,9 +727,11 @@ def fig_map_var(self, var, label=None, it=np.inf, figsize=None, figax=None, **kw
 
 
         fig, ax = self._fig_map_var(data, label, figsize, figax=figax, **kwargs)
-            
+        
+        print(time_unit)
+        # time_unit = "sec"
         if self.globalstarttime is None:
-            ax.set_title('{:.1f}Hr'.format(self.var['globaltime'][it] ))
+            ax.set_title('{:.1f} {}'.format(self.var['globaltime'][it], time_unit))
         else:
             ax.set_title('{}'.format(self.var['globaltime'][it]))
 
diff --git a/xbTools/xbeachtools.py b/xbTools/xbeachtools.py
index e465fd5..de57f64 100644
--- a/xbTools/xbeachtools.py
+++ b/xbTools/xbeachtools.py
@@ -18,10 +18,9 @@
 from .general.deg2uv import deg2uv
 
 # Dictionary functions
-from xbTools.general.file_utils import write_2d_arr_2_file
+from xbTools.general.file_utils import (write_2d_arr_2_file, format_subsection_header, 
+                                       format_header_line, get_json)
 
-# Document Functions
-from xbTools.doc_utilities.doc_utilts import format_subsection_header, format_header_line, get_json
 
 class XBeachModelSetup():
     '''
@@ -44,7 +43,6 @@ def __init__(self,file_name):
         self.wavefriction = None
         self.friction = None
         self.nebed = None
-
         self.struct = None
         
     def __str__(self):
@@ -55,7 +53,6 @@ def __str__(self):
         """        
         return self.file_name
     
-
     def set_params(self,input_par_dict, json_file_name = "par.json"):
         """
         Sets the wavemodel and any of the parameters in the par.json file for the model
@@ -355,7 +352,7 @@ def _get_instat_required_params(instat_type):
         
         return required_params
 
-    def set_waves(self, wbctype, input_struct, instat_bc = False, num_deci_dig = 5):
+    def set_waves(self, wbctype, input_struct, instat_bc = False):
         """
 
         Gets the required inputs for the selected boundary condition and stores the values in a dict for 
@@ -463,6 +460,22 @@ def set_tide(self, zs0, optional_par_input = {}):
         self.zs0 =  zs0
 
         # TODO check that zs0file is at least as long as end time of simulation
+    
+    @staticmethod
+    def write_zsinitfile(init_surface_elev, model_dir, file_name = "zsinitfile.txt", decimal_digits = 5):
+        """
+        Write the initial water surface elevation file  "zsinitfile"
+        """
+        
+        # Construct the file path
+        zs_init_file_path = os.path.join(model_dir, file_name)
+
+        # Convert the data to be a least 2d, so that the writer function can work
+        init_surface_elev = np.atleast_2d(init_surface_elev)
+
+        # Write the file to the specified path
+        write_2d_arr_2_file(init_surface_elev, zs_init_file_path, decimal_digits)
+        
 
     def load_model_setup(self,path):
         """_summary_
@@ -620,6 +633,9 @@ def _write_wbc_file(self, path, num_dec_dig):
         elif self.wbctype == "parametric" or self.wbctype == "jonstable":
             self._write_jonswap_file(path, tab_number, file_name = "jonswap.txt")
 
+        elif self.wbctype == "off":
+            # Don't need to do anything here
+            pass
         else:
             raise Warning("Writing the files for wbctype: {} is not implemented".format(self.wbctype))
     
@@ -814,7 +830,7 @@ def write_model(self, path, figure=False, num_dec_dig = 5):
         self.model_path = path
         path_params = os.path.join(path,'params.txt')
         
-        # Raise an error if the file isn't found
+        # Raise an error if the folder isn't found
         if not os.path.exists(path):
             raise FileExistsError('{} does not exist'.format(path))
         

From c552f7f2d56317991c7bb3a1c4e9dc82079bec95 Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Wed, 17 Jul 2024 19:00:21 -0500
Subject: [PATCH 4/8] removed pycache

---
 .../__pycache__/doc_utilts.cpython-312.pyc       | Bin 1497 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 xbTools/doc_utilities/__pycache__/doc_utilts.cpython-312.pyc

diff --git a/xbTools/doc_utilities/__pycache__/doc_utilts.cpython-312.pyc b/xbTools/doc_utilities/__pycache__/doc_utilts.cpython-312.pyc
deleted file mode 100644
index 864d4e82b68a0be4a0b345a7548fb843705ef54e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1497
zcmZ8hL2nyH6rR~#JGRqANpYZ1il#~(<hJC9id99Rv_a(%L<lOfT&*^{<9OZmt~E0&
zVrz|j=%GhfNTg9(B}Y&$`~>b?T;+n6OC(OYwYVprcr#wxZJ#u=@6F76^X7f;+rQ@K
zatOrlMpa}W^sh9=q9w}UCMf&JL1pA%NAqwQtFKnp9Q_e0>rUD+9^ta#q`*qGwBk&A
zHMbG^wr~TV6A_Ra^_rv+IBvB?EZ-qNF;`IH1a{b<zTmlYdDW(klN;p+vOzkG@$EQ5
z^*8tB84yQ1NmdV$qd(WbM@6IkYmR{Yz^NlIuLi7P2_k9~@~|Ari0ArL*{)BT7PA_B
zRqP2;bv>#))#UokQ1Ft{WjI0iM2T?0Tz_}6C^xntu-qiP7KENdb|?W)0<ou8Du<y_
zC=|%~*N}GGAfOj<obu`+7oZq21eb3i!_s=Ga(C;_dS!2iT6XO-5d_{&um|QgXuJZ2
zGehBeu5jtp5`4AUiZ70yYmT03%BQj{M3sYo3{w}qTtM>|d)M}_Ke_&N>zCF3;??7P
ze|DvBtPEfu*<;|PF@fPrFrWzlhC}pR>u3=c6F8y?2yJMmj_zoY-cEsLM4E&pGQej9
z%`H`ljVUBN+~HJpN`ej_S5DP*f(etE3~^zI2~<n>s9#L68CZ+cpzn%WoE~8l&--D+
zY*J>M+}-tgoSW(#l0p(Q!ZOnJQc|pG5=q_Id$27BzXcPNEQ1#Ey*s_nA3x}BoGo2`
zW*@H{K76rM>~5Yd=6gTCSS)nE`FlS9_{ZLNy>`#*&o1|kWhTk>RyotKpt|}PlzlWU
zp_mlCE+6`i)a66pkqAZjB=K@4T1OKSX(e^V?XflbMp}LD?G<UABugg=q#ZqyaB1z1
zf@=$C!-+-eJn$8N85JP|YP*71a>H?Lp-ygoyM4Dr)-7MMAWR781;Im-Fi?d6YH*vm
zO`uFbT0ux`aNu;zNy$4EEyk=k6B|L3`mq-9*l1dSvr!LRA7)4f=o3I{vB4n2q7lzl
z0}lvps&iS{JEm_nXq=UYO=%~pOqk0;PkSM=ONA-Vv8%BD2@HN4rY?Ftk3PKeZ0qR$
z!TqDkLFKm_f3!}oeD&w@>7|YCz1L~9xU`>pl6(5a(b~b<>E#=z3pcy>&Svv{Bd_o;
z;`2?2Q%uJ*rYV_gvX8)KAIM2!rFu<W`a4n{syBz3+wj8-J-WsUa7Y5fWnwRNjPWZ?
d!^R+o@P&U+_CF(oKON+=_}bw83wTL|_#b5OcHsa3


From 625d116d5ca4d3907d20c612965ede8bf6e53c85 Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Wed, 17 Jul 2024 19:02:48 -0500
Subject: [PATCH 5/8] Removed write params general data. Another function does
 this job now

---
 xbTools/general/executing_runs.py |  3 ---
 xbTools/xbeachtools.py            | 20 --------------------
 2 files changed, 23 deletions(-)

diff --git a/xbTools/general/executing_runs.py b/xbTools/general/executing_runs.py
index edfd8f8..69b59ea 100644
--- a/xbTools/general/executing_runs.py
+++ b/xbTools/general/executing_runs.py
@@ -119,7 +119,6 @@ def generate_batch_script(model_folder, exe_path, batch_file_name = "run_model.b
         f.write(batch_str)
 
 def run_batch_script(batch_script_path, flag_print_Blog = False):
-    # TODO: Need to test this some more. There are some troubles when the permissions 
     """
     Run a batch script given a path
     
@@ -132,8 +131,6 @@ def run_batch_script(batch_script_path, flag_print_Blog = False):
     -------
     None.
 
-    TODO: There's some trouble that when this is imported it tends to not work. When it is directly in the .ipynb file it works fine.
-    TODO: Note sure what's going on with it
     '''
     """
 
diff --git a/xbTools/xbeachtools.py b/xbTools/xbeachtools.py
index de57f64..851e755 100644
--- a/xbTools/xbeachtools.py
+++ b/xbTools/xbeachtools.py
@@ -665,23 +665,6 @@ def _write_params_metadata(file, current_date, user):
         # Write the metadata
         file.write(header)
 
-    @staticmethod
-    def _write_params_general_data(file, wavemodel, wbctype, tab_number):
-        """
-        Write the general data into the params file
-
-        TODO: WaveHello - In the process of deprecating this function
-        """
-
-        ## general
-        file.write('\n')
-        if wavemodel is not None:
-            file.write('wavemodel\t= {}\n'.format(wavemodel).expandtabs(tab_number))
-
-        if wbctype is not None:
-            file.write('wbctype\t= {}\n'.format(wbctype).expandtabs(tab_number))
-        file.write('\n')
-
     def _write_params_grid_data(self, file, tab_number):
         """
         TODO: Check if this needs to be a internal module. 
@@ -803,9 +786,6 @@ def _write_params_file(self, path_params, current_date, user, tab_number):
             self._write_params_metadata(f, current_date, user)
 
             # Write the general data
-            # 
-            # NOTE: WaveHello - Commented out because the data is being written under the correct subheader now
-            # self._write_params_general_data(f, self.wavemodel, self.wbctype, tab_number)
             
             self._write_params_grid_data(f, tab_number)
 

From 82bcc596ed867895093bd0ba73f9741418b53866 Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Wed, 17 Jul 2024 19:04:39 -0500
Subject: [PATCH 6/8] Removed tracking WaveHello Notes

---
 notes.md | 60 --------------------------------------------------------
 1 file changed, 60 deletions(-)
 delete mode 100644 notes.md

diff --git a/notes.md b/notes.md
deleted file mode 100644
index b817aaf..0000000
--- a/notes.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Notes on xBeach-ToolBox
-
-## Folders
-
-### General
-
-1) deg2uv.py
-
-This script contains one function that converts degrees to u,v vectors and the reverse
-
-Functions:
-    * deg2uv - converts degrees to u, v vectors
-    * uv2deg - converts u, v vectors to degrees
-
-2) executing_runs.py
-   * xb_run_script_win     - Create batch script to run simulations. (Not sure exactly what this is doing. Especially what the N parameter does)
-   * generate_batch_script - generates a batch script for a xbeach model
-   * run_batch_script      - Runs a batch script. current not working all the way
-  
-3) geometry.py
-   * rotate                - rotates a vecotor through the origin that is set by the user
-   * rotate_grid           - Rotates a grid
-   * grid_world2local      - Figures out the rotation of a grid and then returns it in local coordinates
-   * samples_to_local_grid - shifts a vector and then rotates it
-   * in_polygon            - Checks whether a set of coordinates are in a polygon
-   * get_points_in_polygon - Returns True for points in polygon and Returns False for points outside of the polygon - May replace in_polygon in the future
-   * path_distance         - Computes the distance along a polyline
-   * 
-
-4) visualize_mesh.py
-   * plot_mesh                - Plot the mesh based on the meshgrid regular grid - **Uses **kwargs to feed inputs into the plotting functions. This is a good idea**
-   * write_mesh_to_shp        - Convert mesh to shapefile
-   * grid_parameter_to_shape  - Saves a paramter defined at a grid point to a shapefile
-  
-5) wave_functions
-   * dispersion                - Computes the wave nuber given a radial frequency and water depth
-   * wavecelerity              - Computes the group velocity and wave celerity ratio
-   * directional_spread_kuik   - Determine mean wave direction and directional spreading
-   * celertiry_ratio_equals_09 - Function to find water depth for which the n ratio equal 0.9
-   * offshore_depth            - Compute the required offshore depth to correctly force the waves
-
-### grid
-
-6) creation.py
-   * xgrid                 - Compute spatially varying grid based on the local wave length
-   * ygrid                 - function to setup a basic ygrid array
-   * grid_transition       - Function for grid transition from one cell to the other. (Still not sure what this means)
-
-7) extension.py
-   * lateral_extend        - Extend the model domain at both laterial sides with n number of cells
-   * seaward_extend        - Compute the seaward extend of the bathymery based on an artificial  slope and required offshore depth
-
-8) grid_check.py
-   * diff                  - Computes the difference in subsequent items
-   * smoothness            - Perform grid checks based on D3D-quickin procedure for smoothness in m and n-direction and stores figures
-   * aspect_ratio          - Perform grid checks based on D3D-quickin procedure
-   * orthogonality         - Perform grid checks based on D3D-quickin procedure for orthogonality and stores figures
-
-9) refinement.py
-   * grid_refine_grid      - refines the grid with the factor xfactor in xdirection and yfactor in y direction
\ No newline at end of file

From 6a1d1f25584a248f7e2f7d02484f09db9b28ad9e Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Wed, 17 Jul 2024 19:08:14 -0500
Subject: [PATCH 7/8] Now ignoring .pyc files

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 70a892b..0b5a952 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,5 @@
 /.idea
 /examples/xb-2D/
 
+# Don't track pyc files
+*.pyc

From 15f50fa8f2685aa8dd96034b6b5c4252d6f6108a Mon Sep 17 00:00:00 2001
From: Jonathan Moore <jonathanm@vt.edu>
Date: Mon, 29 Jul 2024 09:23:52 -0500
Subject: [PATCH 8/8] Using comma in bcf file

---
 xbTools/xbeachtools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/xbTools/xbeachtools.py b/xbTools/xbeachtools.py
index 851e755..6cf08c6 100644
--- a/xbTools/xbeachtools.py
+++ b/xbTools/xbeachtools.py
@@ -550,7 +550,7 @@ def _write_boun_U_file(self, path, boun_U_dict, num_dec_dig):
         # Loop over the data and stack it together
         data = np.column_stack([variable_dict[key] for key in variable_dict.keys()])
 
-        string_variables = " ".join(variable_names)
+        string_variables = ",".join(variable_names)
         num_variables = len(variable_names)
 
         # Write the header and the data to a file