Modules

schimpy.base_io module

This module is a simple common base for text file IO. @outhor: Kijin Nam, knam@water.ca.gov

class schimpy.base_io.BaseIO(logger=None)

Bases: object

Common IO routines to handle text inputs

Attributes:

linecounter

property linecounter

schimpy.batch_metrics module

Create metrics plots in batch mode

schimpy.batch_metrics.generate_metricsplots(main_inputfile)

Create metrics plots in batch mode.

MAIN_INPUTFILE: Path to the main input YAML file.

schimpy.bctide module

This class will read in a yaml file which defines SCHISM boundary and generate bctides.in. It supports all type of elevation, velocity, salinity, temperature and tracer boundaries. At the end of this script, there is a synthetic example which demonstrates the format of bctide YAML file.

schimpy.bctide.load_boundary(fn)

schimpy.bound_linear module

schimpy.bound_linear.bound_linear(z, z_low, z_high, val_low, val_high)

schimpy.cencoos_download module

schimpy.cencoos_download.cencoos_schism_opendap(lat_lo, lon_lo, lat_hi, lon_hi, file_base, to_cache, from_cache)

Download cencoos opendap data for all time based on a bounding set of lat/lon file_base : str prefix for files to_cache : bool whether to stash data in numpy arrays to make it easier next time from_cache : use cache rather than download)

The strategy for this download may change with time. When the script was originally written, blocking the query in time was very inefficient

schimpy.cencoos_download.merc_to_latlon(x, y)

schimpy.cencoos_download.time_block_report(message, told): This routine is for reporting incremental timing of parts of the script

schimpy.check_mesh_skewness module

Calculate skewness of elements form gr3 file

schimpy.check_mesh_skewness.calculate_skewness(mesh, normalize=True, mask_tri=False)

Calculate skewness of elements

Parameters:

mesh: schism_mesh
normalize: bool, optional: Normalize skewness if True.
mask_tri: bool, optional: If true, mask skewness of triangular elements with zero

schimpy.check_mesh_skewness.create_arg_parser(): Create an argument parser

schimpy.check_mesh_skewness.main(): main function

schimpy.check_mesh_skewness.write_prop(fpath, data): Write a prop file with a prop vector

schimpy.clip_dems module

schimpy.clip_dems.bounding_coords(image)

schimpy.clip_dems.clip_dem(xlo, xhi, demlist='dem.txt', outformat='AAIGrid', hshift=False, prefix='clipped', verbose=False)

schimpy.combine_consume module

schimpy.combine_consume.appears_done(wdir, fb, exten, firstblock, lastblock): Decide if entire file block already appears to have been combined based on existence of combined file. Date not checked

schimpy.combine_consume.archive_blocks(ar_file, tbase, blocks_per_day=1, ndxmin=1, ndxmax=None)

schimpy.combine_consume.combine(wdir, blocks, fbase, combine_exe, consume=True, assume_done=True)

schimpy.combine_consume.combine_consume(start, dir, fbase, hotstart, hotstart_only, consume, assume_done, combiner, hot_combiner, sndx, endx, sndx_hot, endx_hot, datefile, blocks_per_day, is_test=False)

schimpy.combine_consume.combine_hotstart(wdir, combine_hotstart_exe, minstep=0, maxstep=99999999, consume=True)

schimpy.combine_consume.detect_min_max_index(wdir, sample_fbase)

schimpy.combine_consume.do_combine(wdir, begin, end, filebase)

schimpy.combine_consume.do_combine_hotstart(wdir, step)

schimpy.combine_consume.failed_incomplete(e)

schimpy.combine_consume.gather_ppf_names(wdir, blocks)

schimpy.combine_consume.prune_ppf_files(wdir, blocks, fbase, list_only=False)

schimpy.combine_consume.setup(wdir, filebase)

schimpy.combine_consume.split(alist, n)

schimpy.combine_consume.touch(fname, times=None)

schimpy.combine_flux module

Command line tool to merge possibly overlapping flux.dat files from hotstart runs

schimpy.combine_flux.combine_flux(infiles, outfile, prefer_last=False): Merge possibly overlapping flux.dat files from hostart runs

schimpy.combine_flux.create_arg_parser()

schimpy.combine_flux.main(): Driver to parse arguments

schimpy.combine_flux.test_combine_flux()

schimpy.contour_smooth module

This module contains tools for a smoother for DEMs (currently tiff format) based on curvature flow The algorithm is based on one by Malladi and Sethian, and results in a simplification of contours while allowing sharp gradients as long as they are persistent. So it is not a cure for pressure gradient errors a la Hannah. The script shows some artefacts of a time when it wasn’t particularly stable and could run out of memory. In particular, the algorithm dumps out intermediate arrays as it goes along and these have to be visualized or saved using the appropriate subcommands or functions. Stability is no longer an issue. it has been good for quite a while. Not so sure about memory. We’ve not tested a big problem yet on a big DEM on 64bit python.

class schimpy.contour_smooth.RasterWrapper(filename)

Bases: object

Methods

write_copy

write_copy(filename, data)

schimpy.contour_smooth.calc_f(t, data, width_shape): Right hand side of the semi-discretized operator (in space) so that it can be integrated in time

schimpy.contour_smooth.contour_smooth(input, scales, max_time, nstep, report_interval, fill_val=2.0, **kwargs): Driver function for smoothing a DEM

schimpy.contour_smooth.contour_smooth2d(dem, scales, max_time, nstep, report_interval)

schimpy.contour_smooth.save_smooth(dumpfile, original, outfile, **kwargs)

schimpy.contour_smooth.view_smooth(file0, file1, levels, vmin, vmax, **kwargs): View the dumped files to graphically explore smoothing progress

schimpy.convert_linestrings module

Command line tool to convert SCHISM line strings in YAML to Shapefile and vice versa

schimpy.convert_linestrings.convert_linestrings_main(input, output): Function for converting line string files.

schimpy.convert_mesh module

Mesh converter

schimpy.convert_mesh.convert_mesh(input, output, crs): Converts mesh files to a new format (e.g., shapefile, gr3, etc.).

schimpy.convert_points module

Command line tool to convert SCHISM points (source and sink) in YAML to Shapefile

schimpy.convert_points.df_to_shp(fpath, df): Convert a DataFrame to a Shapefile.

schimpy.convert_points.main(input, output): Function for converting SCHISM points.

schimpy.convert_points.read_points(fpath): Read points from a YAML file.

schimpy.convert_points.write_points(fpath, df): Write points to a Shapefile.

schimpy.convert_polygons module

Command line tool to convert SCHISM polygons in YAML to Shapefile and vice versa

schimpy.convert_polygons.convert_polys(input, output)

schimpy.convert_sav_class_to_number module

schimpy.convert_sav_class_to_number.create_arg_parse(): Create argument parser Parameters ———-

schimpy.convert_sav_class_to_number.main()

schimpy.convert_sav_class_to_number.read_density_tiff(fpath_densitiy_tiff)

Read geotiff values for density It is assumed that the projected regular coordinates.

Parameters:

fpath_densitiy_tiff: str: filename for SAV desity diff

Returns:

numpy.ndarray: 3D array containing x’s, y’s, and density. The shape is (n_x, n_y, 3)

schimpy.create_mesh_n_levels module

Create a mesh file with the number of vertical levels as nodal value

schimpy.create_mesh_n_levels.create_arg_parser(): Create an argument parser

schimpy.create_mesh_n_levels.main(): Just a main function

schimpy.create_vgrid_lsc2 module

Create LSC2 vertical grid lsc2.py

The min and max layers can be specified in polygons in yaml or shp with minlayer and maxlayer attributes.

schimpy.create_vgrid_lsc2.create_arg_parser(): Create argument parser for

schimpy.create_vgrid_lsc2.main()

schimpy.create_vgrid_lsc2.plot_vgrid(hgrid_file, vgrid0_file, vgrid_file, vgrid_version, eta, transectfiles)

schimpy.create_vgrid_lsc2.vgrid_gen(hgrid, vgrid_out, vgrid_version, eta, minmaxlayerfile, archive_nlayer='out', nlayer_gr3='nlayer.gr3')

schimpy.cruise module

schimpy.cruise.create_arg_parser()

schimpy.cruise.cruise_xyt(path, station_data, base_time, outfile)

schimpy.cruise.do_depth_plot(station, cruise_data, surrounding_profiles, ax, xlabel, ylabel, add_legend=False)

schimpy.cruise.gen_profile_plot(base_date, cruise_time, survey_file, model_file, station_file, xytfile)

schimpy.cruise.gen_station_xyt(base_date, cruise_time, survey_file, station_file, xytfile)

schimpy.cruise.longitudinal(cruise_data, station_data, ax, context_label=None, add_labels=False, xlabel=None, xmin=None, xmax=None, max_depth=None)

schimpy.cruise.main(base_date, cruise_time, obs_file, model_file, station_file, xytfile)

schimpy.cruise.match_cruise(time, station, x, z, times, data)

schimpy.cruise.model_data_for_longitude(cruise_data, station_data, x, z, times, model_data, base_date)

schimpy.cruise.process_cruise(path)

schimpy.cruise.process_stations(station_file)

schimpy.cruise.process_xyt(path, casts, base_time)

schimpy.cut_mesh module

Functions to cut certain parts in the mesh by cutting lines.

schimpy.cut_mesh.cut_mesh(fpath_gr3_in, lines, fpath_gr3_out, cut_side='left')

Remove elements of a mesh in one side of cutting polyline segments. A mesh is read in from a gr3, and a result mesh is written in another gr3 file.

A user needs to be careful that line segments forms a closed division. Otherwise, all elements would be deleted.

Parameters:

fpath_gr3_in: Filename of the input grid in gr3
lines: array-like: An array of coordinates of line segments specifying the location of cuts
fpath_gr3_out: Filename of the output grid in gr3
cut_side: str, optional: If cut_side is ‘left,’ which is default, the left side of cutting lines when one sees the second point from the first point of a line will be removed. If this value is ‘right,’ the right side will be removed.

schimpy.cut_mesh.read_lines(fpath)

Read coordinates of cutting line segments from a plain text file.

The expected format is:

x1 y1 x2 y2

in each line.

Parameters:

fpath: Name of a file containing coordinates of cutting lines

Returns:

list: List of coordinates of cutting lines

schimpy.cut_mesh.read_lines_from_shapefile(fpath)

Read coordinates of cutting line segments from a ESRI Shapefile containing line features.

Parameters:

fpath: Name of a file containing coordinates of cutting lines

Returns:

list: List of coordinates of cutting lines

schimpy.download_hrrr module

Created on Fri Jan 20 09:07:50 2023 Download NOAA High-Resolution Rapid Refresh (HRRR) Model using AWS bucket service

schimpy.download_hrrr.create_arg_parser(): Create an argument parser return: argparse.ArgumentParser

schimpy.download_hrrr.download_hrr(start_date, rnday, pscr, bbox)

schimpy.download_hrrr.main(): Main function

schimpy.embed_raster module

Embed finer gridded data in coarser, using curvature flow smoothing to reconcile

Main function is called embed_fine

schimpy.embed_raster.create_arg_parser()

schimpy.embed_raster.embed_raster(input_fg, input_bg, output, nsmooth_init=2, nsmooth_final=1, plot=False, max_time_init=3, max_time_final=1, nstep=50, report_interval=1, **kwargs)

Embed a smoother DEM in a coarser

The two inputs and output are filenames. The basic plans is this: 1. Smooth the fine data enough to resample without aliasing or distortion 2. Interpolate/resample the result to the coarser mesh 3. Where the result of 1-2 has good data, replace coarser data 4. Smooth the final grid lightly to remove kinks/discontinuity

The smoothing is done with contour_smooth2d

schimpy.gaussian_quadrature module

Gaussian quadrature in 2D space

class schimpy.gaussian_quadrature.GaussianQuadrature(order)

Bases: object

Abstract base class of GaussianQuadrature

Methods

`average`(vertices, values)	Calculate the average of the value over the domain.
`calculate_quadrature_points_and_weights`()	Calculate quadrature points and weights
`domain_size`(vertices)	Abstract method to calculate the size of the domain
`integrate`(vertices[, values])	Integrate values over a quad element
`jacobian_det`(vertices)	Determinant of Jacobian at quadrature points
`number_of_quadrature_points`()	Get the number of quadrature points
`quadrature_vector`(vertices)	Create a quadrature matrix for quadrature integration Taking a dot product this quadrature matrix and the values at the quadrature points will result in quadrature
`shape`(pts)	Abstract shape function
`shape_derivative`(pts)	Abstract shape derivative function
`values_at_quadrature_points`(values)	Get quadrature points

average(vertices, values)

Calculate the average of the value over the domain.

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (:, 2) or more columns. The values in the first two columns will be used.

Returns:

float: the length of the line

calculate_quadrature_points_and_weights()

Calculate quadrature points and weights

Parameters:

pts: np.ndarray: Coordinates of the nodes

Returns:

ptsreal: quadrature points

domain_size(vertices): Abstract method to calculate the size of the domain

integrate(vertices, values=None)

Integrate values over a quad element

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) with values. The shape needs to be (:, 2)
values: numpy.array, optional: A value vector at vertices If it is not provided, the thrid column will be used as values

Returns:

float: result of integration

jacobian_det(vertices)

Determinant of Jacobian at quadrature points

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (:, 2) or more columns. The values in the first two columns will be used.

Returns:

numpy.array: array of determinant ant quadrature points

number_of_quadrature_points()

Get the number of quadrature points

Returns:

int: Number of quadrature points

quadrature_vector(vertices)

Create a quadrature matrix for quadrature integration Taking a dot product this quadrature matrix and the values at the quadrature points will result in quadrature

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) with values. The shape needs to be (:, 2)

Returns:

numpy.array: two-dimensional matrix of quadrature matrix

shape(pts)

Abstract shape function

Parameters:

pts: np.ndarray: Coordinates of the nodes

shape_derivative(pts)

Abstract shape derivative function

Parameters:

pts: np.ndarray: Coordinates of the nodes

values_at_quadrature_points(values)

Get quadrature points

Parameters:

values: numpy.array: values at quadrature points

Returns:

numpy.array: values of Gaussian quadrature points

class schimpy.gaussian_quadrature.GaussianQuadratureLine2(order)

Bases: GaussianQuadrature

Gaussian quadrature on line with two end points in 2-D space

Methods

`average`(vertices, values)	Integrate values over a quad element
`calculate_quadrature_points_and_weights`()	Calculate quadrature points and weights
`domain_size`(vertices)	Size of domian, which is the length of the line in this case
`integrate`(vertices[, values])	Integrate values over a quad element
`jacobian_det`(vertices)	Determinant of Jacobian at quadrature points, 1-D version
`number_of_quadrature_points`()	Get the number of quadrature points
`quadrature_vector`(vertices)	Create a quadrature matrix for quadrature integration Taking a dot product this quadrature matrix and the values at the quadrature points will result in quadrature
`shape`(pts)	Shape functions Ordering is counter-clockwise direction
`shape_derivative`(pts)	Derivatives of shape functions
`values_at_quadrature_points`(values)	Get quadrature points

average(vertices, values)

Integrate values over a quad element

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) with values. The shape needs to be (-1, 2)
values: numpy.array: The values at vertices

Returns:

averagefloat: result of integration

calculate_quadrature_points_and_weights()

Calculate quadrature points and weights

Parameters:

pts: np.ndarray: Coordinates of the nodes

Returns:

ptsreal: quadrature points

domain_size(vertices)

Size of domian, which is the length of the line in this case

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (2, 2) or more columns. The values in the first two columns will be used.

Returns:

float: the length of the line

jacobian_det(vertices)

Determinant of Jacobian at quadrature points, 1-D version

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (-1, 2) or more columns. The values in the first two columns will be used.

Returns:

numpy.array: array of determinant ant quadrature points

shape(pts)

Shape functions Ordering is counter-clockwise direction

Parameters:

pts: numpy.array: Local coordinates.

Returns:

numpy.array: matrix of shape function value at the given points

shape_derivative(pts)

Derivatives of shape functions

Parameters:

pts: numpy.array: Local coordinates. The dimension is (-1, 2)

Returns:

numpy.array: matrix of shape function derivative wrt xi value at (*, eta)

class schimpy.gaussian_quadrature.GaussianQuadratureQuad4(order)

Bases: GaussianQuadrature

Gaussian Quadrature for a quadrilateral with four nodes

Methods

`average`(vertices, values)	Calculate the average of the value over the domain.
`calculate_quadrature_points_and_weights`()	Calculate quadrature points and weights
`domain_size`(vertices)	Size of domain, which is the area of the quadrilateral in this case.
`integrate`(vertices[, values])	Integrate values over a quad element
`jacobian`(vertices[, local_coord])	Create a Jacobian matrix or matrixes at the given local coordinates
`jacobian_det`(vertices)	Determinant of Jacobian at quadrature points
`number_of_quadrature_points`()	Get the number of quadrature points
`quadrature_vector`(vertices)	Create a quadrature matrix for quadrature integration Taking a dot product this quadrature matrix and the values at the quadrature points will result in quadrature
`shape`(pts)	Shape functions Ordering is counter-clockwise direction
`shape_derivative`(pts)	Derivatives of shape functions
`values_at_quadrature_points`(values)	Get quadrature points

calculate_quadrature_points_and_weights(): Calculate quadrature points and weights

domain_size(vertices)

Size of domain, which is the area of the quadrilateral in this case. The area is calculated with shoelace equation.

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (4, 2) or more columns. The values in the first two columns will be used.

Returns:

ret_size: float: the length of the line

jacobian(vertices, local_coord=None)

Create a Jacobian matrix or matrixes at the given local coordinates

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (4, 2) or more columns. The values in the first two columns will be used.
local_coord: numpy.array: local coordinates where a Jacobian is calculated

Returns:

numpy.array: Jacobian matrix

shape(pts)

Shape functions Ordering is counter-clockwise direction

Parameters:

pts: numpy.array: Local coordinates. The dimension is (-1, 2)

Returns:

numpy.array: matrix of shape function value at (xi, eta)

shape_derivative(pts)

Derivatives of shape functions

Parameters:

pts: numpy.array: Local coordinates. The dimension is (-1, 2)

Returns:

numpy.array: matrix of shape function derivative wrt xi value at (*, eta)

class schimpy.gaussian_quadrature.GaussianQuadratureTri3(order)

Bases: GaussianQuadrature

Gaussian Quadrature for triangles with three nodes

Methods

`average`(vertices, values)	Calculate the average of the value over the domain.
`calculate_quadrature_points_and_weights`()	Calculate quadrature points and weights
`domain_size`(vertices)	Size of domian, which is the area of the quadrilateral in this case.
`integrate`(vertices[, values])	Integrate values over a quad element
`jacobian`(vertices[, local_coord])	Create a Jacobian matrix or matrixes at the given local coordinates
`jacobian_det`(vertices)	Determinant of Jacobian at quadrature points
`number_of_quadrature_points`()	Get the number of quadrature points
`quadrature_vector`(vertices)	Create a quadrature matrix for quadrature integration Taking a dot product this quadrature matrix and the values at the quadrature points will result in quadrature
`shape`(pts)	Shape functions Ordering is counter-clockwise direction
`shape_derivative`(pts)	Derivatives of shape functions
`values_at_quadrature_points`(values)	Get quadrature points

calculate_quadrature_points_and_weights(): Calculate quadrature points and weights

domain_size(vertices)

Size of domian, which is the area of the quadrilateral in this case. The area is calculated with shoelace equation.

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (3, 2) or more columns. The values in the first two columns will be used.

Returns:

float: the length of the line

jacobian(vertices, local_coord=None)

Create a Jacobian matrix or matrixes at the given local coordinates

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) The shape needs to be (4, 2) or more columns. The values in the first two columns will be used.
local_coord: numpy.array: local coordinates where a Jacobian is calculated

Returns:

numpy.array: Jacobian matrix

jacobian_det(vertices)

Determinant of Jacobian at quadrature points

Parameters:

vertices: numpy.array: coordinates of vertices (or nodes) but it is not used

Returns:

numpy.array: array of determinant ant quadrature points

shape(pts)

Shape functions Ordering is counter-clockwise direction

Parameters:

pts: numpy.array: Local coordinates. Not used

Returns:

numpy.array: matrix of shape function value at (xi, eta)

shape_derivative(pts)

Derivatives of shape functions

Parameters:

pts: numpy.array: Local coordinates. Not used

Returns:

numpy.array: matrix of shape function derivative wrt xi value at (*, eta)

schimpy.gen_elev2d module

Generate elev2D.th for a Bay-Delta SCHSIM model using tides at Point Reyes and Monterey.

2015-06-16: Customized

class schimpy.gen_elev2d.BinaryTHWriter(fpath_out, nloc, starttime)

Bases: THWriter

Methods

write_all
write_step

write_all(times, vals)

write_step(iter, time, vals)

class schimpy.gen_elev2d.NetCDFTHWriter(fpath_out, nloc, starttime, dt)

Bases: THWriter

Methods

write_all
write_step

write_all(times, vals)

write_step(iter, time, vals)

class schimpy.gen_elev2d.THWriter(path, size, starttime)

Bases: object

Methods

write_all
write_step

write_all(times, vals)

write_step(iter, time, vals)

schimpy.gen_elev2d.create_arg_parser()

schimpy.gen_elev2d.gen_elev2D(hgrid_fpath, outfile, pt_reyes_fpath, monterey_fpath, start, end, slr)

schimpy.geo_tools module

schimpy.geo_tools.FindMultiPoly(poly_array)

schimpy.geo_tools.Polylen(poly)

schimpy.geo_tools.geometry2coords(geo_obj)

schimpy.geo_tools.geometry2coords_points(geo_obj)

schimpy.geo_tools.ic_to_gpd(fn, crs=None): Read ic yaml file and convert the polygons to geopandas format

schimpy.geo_tools.ll2utm(lonlat, crs=None): lonlat can be numpy arrays. lonlat = np.asarray([lon,lat]) default crs = epsg:26910

schimpy.geo_tools.partition_check(mesh, poly_fn, regions, centering='node', crs=None, allow_overlap=False, allow_incomplete=False)

Check if the schism mesh division by the polygon features in poly_fn is unique and complete. The partition check is based on either node or element, and the function checks:

if there are any orphaned nodes, and
if any nodes/elems were assigned to multiple polygons.

schimpy.geo_tools.project_fun(crs=None)

schimpy.geo_tools.shapely_to_geopandas(features, crs=None, shp_fn=None): Convert shapely features to geopandas and generate shapefiles as needed

schimpy.geo_tools.shp2yaml(shp_fn, yaml_fn=None, crs=None)

Convert a shapefile to yaml file

Parameters:

shp_fnstr: Input shape filename
yaml_fnstr: Output yaml filename
crsstr, optional: Output projection. The default is None.

Returns:

None.

schimpy.geo_tools.utm2ll(utm_xy, crs=None): utm_xy can be numpy arrays. utm_xy = np.asarray([utm_x,utm_y]) default crs = epsg:26910

schimpy.geo_tools.yaml2shp(fn, shp_fn=None, crs=None)

schimpy.gr3 module

Package to read a mesh in GR3 format.

class schimpy.gr3.Gr3IO(logger=None)

Bases: BaseIO

A class that manages I/O of GR3 files

Attributes:

linecounter

Methods

`read`([gr3_fname, mode])	Read in a hgrid.gr3 file.
`write`(mesh, fname[, node_attr, boundary])	Write a GR3 format grid.

read(gr3_fname='hgrid.gr3', mode=0): Read in a hgrid.gr3 file. If mode is 1, it does not read in boundary information.

write(mesh, fname, node_attr=None, boundary=False): Write a GR3 format grid. mesh = SCHISM mesh (schism_mesh) instance fname = output file name node_attr = a list of node attribute boundary = If true, boundary information will be added. Otherwise, it will not be appended.

schimpy.grid_opt module

Routines to perform grid optimization for volumetric consistency with finer DEM

There are two methods:

lsqr without constraint to solve $Ax=b$ (scipy.sparse.linalg.lsqr)

minimize function $1/2*||Ax-b||^2$ using the L-BFGS-B algorithm (scipy.optimize.fmin_l_bfgs_b)

where

x is depth at nodes with respect to a nominal reference surface (which may be greater than sea level in upstream locations).

Regularization:

close to the original values for all nodes: damp

minimize the 1st derivative of node elevation along land boundaries: damp_shoreline

Notes:

The function cal_z_ref only applies to the Bay Delta grid and need to be modified for other grids.

This script create an optimized gr3 file (_opt.gr3) only when one set of optimization parameters is specified.

class schimpy.grid_opt.GridOptimizer(**kwargs)

Bases: object

Grid optimizer class

Methods

`assemble_element_matrix`(areas)	Build a matrix for element optimization
`assemble_face_matrix`(edges)	Build a matrix for face optimization The order of the quadrature is fixed
`build_boundary_equations`(ref_surf_at_nodes)	Build a matrix and vector of land boundary constraints
`build_global_matrix_and_vector`(params, ...)	Build a global matrix and vector for optimization
`calculate_depth_at_element_quad_points`(...)	Calculate depth at quad points
`calculate_depth_at_face_quad_points`(edges, ...)	Calculate depth at quad points
`calculate_edge_lengths`(edges)	Calculate areas of all edges
`calculate_element_areas`()	Calculate areas of all elements
`calculate_element_volumes_w_dem`(depth_at_quads)	Calculate volumes of elements based on DEM
`calculate_face_areas_w_dem`(edges, depth_at_quads)	Calculate area of faces based on DEM
`calculate_max_elevation_in_balls`(elev)	Calculate maximum elevation in a ball from a node
`calculate_reference_surface`(coords)	Define reference water surface at locations specified in nodes based on the assumptions, which only applicable to Bay Delta grid
`calculate_reference_surface_at_face_quadarture_points`(...)	Calculate reference surface at quadrature points
`calculate_reference_surface_maximum`()	Create reference surface elevation at individual nodes
`calculate_total_number_of_quadrature_points`()	Calculate total number of quadrature points of the mesh with the given order
`calculate_values_at_element_quadarture_points`(values)	Calculate values at quadrature points
`calculate_values_at_face_quadarture_points`(...)	Calculate values at quadrature points
`collect_edges`([exclude_land_boundaries])	Collect edges for the optimization
`collect_element_quadrature_points_for_dem`()	Collect all quadrature points to calculate volumes of elements with DEM
`collect_face_quadrature_points_for_dem`(edges)	Collect all quadrature points to calculate areas of faces with DEM
`count_boundary_equations`()	Count how many boundary constraint equations there are
`get_dem_elevation`(list_of_points)	Get elevations from DEM
`integrate_over_edges`(edges, values)	Integrate over edges with the values at nodes
`integrate_over_elements`(values)	Integrate over elements with the values at nodes
`optimize`(params[, solver])	Perform a grid optimization
`select_solver`(solver)	Select solver
`show_parameters`(solver, param)	Show optimization parameters

assemble_element_matrix(areas)

Build a matrix for element optimization

Parameters:

areas: numpy.array: areas of the elements

assemble_face_matrix(edges)

Build a matrix for face optimization The order of the quadrature is fixed

Parameters:

edges: numpy.array: list of edges

Returns:

lil_matrix: matrix for face (edge) optimization

build_boundary_equations(ref_surf_at_nodes)

Build a matrix and vector of land boundary constraints

Returns:

numpy.sparse.lil_matrix: Matrix of land boundary equations
numpy.array: Vector of land boundary equations

build_global_matrix_and_vector(params, mat_elem, mat_face, vec_elem, vec_face, mat_bnd, vec_bnd, depths_at_nodes, solver='L-BFGS-B')

Build a global matrix and vector for optimization

Parameters:

params: dict: Dict of optimization parameters
solver: str, optional: solver name

Returns:

numpy.sparce.lil_matrix

calculate_depth_at_element_quad_points(elev_at_quads, ref_surf_at_nodes)

Calculate depth at quad points

This depth is calculated by subtracting bottom elevation at quadrature points from the reference surface at quadrature points that is calculated by reference elevation at nodes with shape functions.

Parameters:

elev_at_quads: numpy.array: Elevation vector at quadrature points
ref_surf_at_nodes: numpy.array: Reference elevation at nodes

Returns:

numpy.array: Vector of depth at quadrature points

calculate_depth_at_face_quad_points(edges, elev_at_quads, ref_surf_at_nodes)

Calculate depth at quad points

This depth is calculated by subtracting bottom elevation at quadrature points from the reference surface at quadrature points that is calculated by reference elevation at nodes with shape functions.

Parameters:

elev_at_quads: numpy.array: Elevation vector at quadrature points
ref_surf_at_nodes: numpy.array: Reference elevation at nodes

Returns:

numpy.array: Vector of depth at quadrature points

calculate_edge_lengths(edges)

Calculate areas of all edges

Returns:

numpy.array: array of the areas of edges

calculate_element_areas()

Calculate areas of all elements

Returns:

numpy.array: array of the areas of elements

calculate_element_volumes_w_dem(depth_at_quads)

Calculate volumes of elements based on DEM

Parameters:

depth_at_quad: numpy.array: Vector of depth at the quadrature points

Returns:

numpy.array: Volumes of elements

calculate_face_areas_w_dem(edges, depth_at_quads)

Calculate area of faces based on DEM

Parameters:

edges: numpy.array
depth_at_quad: numpy.array: Vector of depth at the quadrature points

Returns:

numpy.array: Areas of faces

calculate_max_elevation_in_balls(elev)

Calculate maximum elevation in a ball from a node

Parameters:

elev: numpy.array: array of elevation at nodes

Returns:

numpy.array: maximum elevation at nodes

calculate_reference_surface(coords)

Define reference water surface at locations specified in nodes based on the assumptions, which only applicable to Bay Delta grid

The surface elevation increases linearly from west (ocean) to east
east of (x_old_river, y_old_river), the elevation increases linearly towards the south

NOTE: This is Bay-Delta Specific. Coordinates for the calculation are hard-wired.

Parameters:

coords: numpy.array: Coordinates to calculate reference surface The dimension of the array is (-1, 2) or more columns. The first two columns are used.

Returns:

numpy.array: Reference water surface for Bay-Delta

calculate_reference_surface_at_face_quadarture_points(ref_surf): Calculate reference surface at quadrature points

calculate_reference_surface_maximum()

Create reference surface elevation at individual nodes

Steps:

derive max elevation within connected elements
compare with the reference calculated by calculate_reference_surface() and use the higher value between the two

Returns:

numpy.array: Vector of reference elevation at nodes

calculate_total_number_of_quadrature_points()

Calculate total number of quadrature points of the mesh with the given order

Returns:

int: Total number of quadrature points of the mesh

calculate_values_at_element_quadarture_points(values)

Calculate values at quadrature points

Parameters:

values: numpy.array: A vector of nodal values

Returns:

numpy.array: A vector of values at quadrature points

calculate_values_at_face_quadarture_points(edges, values)

Calculate values at quadrature points

Parameters:

values: numpy.array: A vector of nodal values

Returns:

numpy.array: A vector of values at quadrature points

collect_edges(exclude_land_boundaries=False)

Collect edges for the optimization

Parameters:

exclude_land_boundaries: bool, optional: Switch to exclude land edges

Returns:

numpy.array: matrix of nodal indices of edges

collect_element_quadrature_points_for_dem()

Collect all quadrature points to calculate volumes of elements with DEM

Returns:

numpy.array: Quadrature points of all elements

collect_face_quadrature_points_for_dem(edges)

Collect all quadrature points to calculate areas of faces with DEM

Parameters:

edges: numpy.array: list of edges containing indices of the two end nodes

Returns:

numpy.array: Quadrature points of faces

count_boundary_equations(): Count how many boundary constraint equations there are

get_dem_elevation(list_of_points)

Get elevations from DEM

Do this once to save time

Parameters:

list_of_points: list of numpy.array: array of coordinate matrices of points to get DEM elevations

Returns:

listnp.ndarray: list of elevation vectors

integrate_over_edges(edges, values)

Integrate over edges with the values at nodes

Parameters:

values: numpy.array: Values at nodes to integrate

Returns:

numpy.array: Vector of integration over each edge

integrate_over_elements(values)

Integrate over elements with the values at nodes

Parameters:

values: numpy.array: Values at nodes to integrate

Returns:

numpy.array: Vector of integration over each element

optimize(params, solver='L-BFGS-B')

Perform a grid optimization

Two solvers are available:

L-BFGS-B (default): minimize function $1/2*||Ax-b||^2$
linear least square solver (Ax=b).

Parameters:

params: dict: Dict of optimization parameters
solver: str, optional: solver name

Returns:

numpy.array: optimized elevation

select_solver(solver)

Select solver

Parameters:

solver: str: Name of a solver for the optimization

show_parameters(solver, param)

Show optimization parameters

Parameters:

solver: str: solver name
param: dict: parameters for the optimization

schimpy.grid_opt.create_arg_parser(): Create argument parser

schimpy.grid_opt.fprime(x, A, b): The gradient of the objective function with respect to the heights. This gradient is a vector the same size as x.

schimpy.grid_opt.grid_opt_with_args(args): Optimize grid with arguments parsed by argparse

schimpy.grid_opt.init_logger()

schimpy.grid_opt.main(): A main function to manage command line run

schimpy.grid_opt.object_func(x, A, b): Objective function for the optimization for L-BFGS-B

schimpy.hotstart_inventory module

schimpy.hotstart_inventory.create_arg_parser()

schimpy.hotstart_inventory.expected_hotstarts(run_start, dt, nday, hot_freq)

Generate expected hotstarts based on run parameters.

Parameters:

run_startdatetime: The start time of the simulation run.
dtint: The time step in seconds.
ndayint: The number of days for the simulation run.
hot_freqpandas.tseries.offsets.DateOffset: The frequency at which hotstarts are generated.

Returns:

pandas.DataFrame: A DataFrame with a DatetimeIndex representing the expected hotstart times and a column “iteration” indicating the corresponding iteration numbers.

Notes

This function calculates the expected hotstart times and their corresponding iteration numbers based on the provided simulation parameters. It does not perform any file inventory or check for existing hotstart files.

schimpy.hotstart_inventory.hotstart_inventory(run_start=None, dt=None, nday=None, workdir='.', paramfile=None, hot_freq=None, expected=False)

Create an inventory of existing hotstarts or expected hotstarts.

Whether the inventory is for existing or expected hotstarts depends on whether the workdir is an outputs directory or a study directory.

Parameters:

run_startstr or pandas.Timestamp, optional: The start time of the simulation run in ISO-like format (e.g., ‘2013-12-03’).
dtint, optional: The time step in seconds of the model. Default is None.
ndayint, optional: The number of days in the simulation run or the maximum to catalog. Default is None.
workdirstr, optional: The working directory, which may be a launch or outputs directory. Default is ‘.’.
paramfilestr, optional: The name of the param.nml file if it is used to infer runtime. Default is None.
hot_freqstr or pandas.tseries.offsets.DateOffset, optional: The hotstart frequency in pandas frequency terms (e.g., ‘5D’). Default is None.
expectedbool, optional: Flag to generate expected hotstarts instead of an inventory of existing files. Default is False.

Returns:

pandas.DataFrame or None: A DataFrame containing the inventory of hotstarts with a DatetimeIndex and a column “iteration”. If no hotstarts are found and expected is False, returns None.

schimpy.hotstart_inventory.hotstart_inventory_exist(start, dt=90, workdir='.', do_print=True)

Check for the existence of hotstart inventory files and generate a DataFrame mapping iterations to corresponding datetime values.

Parameters:

startstr or pandas.Timestamp: The start time as a string or pandas.Timestamp object.
dtint, optional: Time step in seconds between iterations (default is 90).
workdirstr, optional: Directory to search for hotstart files (default is ‘.’).
do_printbool, optional: Whether to print the iterations and corresponding times (default is True).

Returns:

pandas.DataFrame: A DataFrame with datetime as the index and iteration numbers as the column.

Notes

The function searches for hotstart files in the specified workdir directory.
If no files are found in workdir, it searches in the current directory.
The function assumes hotstart files follow the naming pattern “hotstart_000000_<iteration>.nc”.

schimpy.hotstart_inventory.main()

schimpy.hrr3 module

adapted from pyschism, original work of Linlin Cui.

class schimpy.hrr3.AWSGrib2Inventory(start_date: datetime = None, record=1, pscr=None, product='conus')

Bases: object

Attributes:

bucket
files
output_interval
s3
tmpdir

property bucket

property files

property output_interval: timedelta

property s3

property tmpdir

class schimpy.hrr3.HRRR(start_date=None, rnday=None, pscr=None, record=1, bbox=None)

Bases: object

Methods

gen_sflux
modified_latlon

gen_sflux(date, record, pscr)

modified_latlon(grbfile)

schimpy.hrr3.localize_datetime(d)

schimpy.hrr3.nearest_cycle(input_datetime=None, period=6, method='floor')

schimpy.interp_2d module

invdisttree.py: inverse-distance-weighted interpolation using KDTree

class schimpy.interp_2d.Invdisttree(x, nnear=10, leafsize=10)

Bases: object

Inverse-distance-weighted interpolation using KDTree

Methods

`interp`(obs[, ninterp])	Perform interpolation
`weights`(node_xy[, eps, p, weights])	Find the nearest neighbors and assign weights to each neibors

Examples

tree = interp_2d.Invdisttree(obs_xy) # initialize KDTree with observational points tree.weights(node_xy) # calculate weights for each node. values_v = tree.interp(obs.temperature.values) # perform spatial interpolation with the calculated weights from the previous step

interp(obs, ninterp=6)

Perform interpolation

Parameters:

obsnp.ndarray: observational values; nan values are allowed and will be ignored.
ninterppositive int, ninterp<=nnear: The number of nearest points to perform interpolation The default is 6.

Returns:

val_interpnp.ndarray: interpolated values

weights(node_xy, eps=0, p=2, weights=None)

Find the nearest neighbors and assign weights to each neibors

Parameters:

node_xynp.ndarray, shape (n,2): Coordinates of the query points n is the number of query points
epspositive float, optional: approximate nearest, dist <= (1 + eps) * true nearest. The default is 0.
ppositive int, optional: power. The default is 2.
weightsfloat, optional: optional multiplier for weights, same dimension as node_xy The default is None.

Returns:

None.

schimpy.interpolate_structure module

schimpy.interpolate_structure.create_arg_parser()

schimpy.interpolate_structure.ensure_offset(arg)

schimpy.interpolate_structure.interpolate_structure(template_th, output_th, dt=None, int_cols=['install', 'ndup_weir', 'ndup_culvert', 'ndup_pipe'])

Interpolate a dated th “template” for a structure The interpolation adds time detail, maintain data types. Comments are removed and floating precision is hardwired to two digits

The input template file must have a header and time stamps that are neat with respect to dt. This is checked.

Parameters:

template_thstr: Path to the template file
output_thstr: Name of the output file
dtinterval_type: Number of hours between changes, default is 1 hour. Can be any time (string, delta, offset) that can be coerced to offset
int_colslist: List of column names that should be integers. This can be a superset, and it shouldn’t change much if you name your template columns the standard way.

schimpy.interpolate_structure.main()

schimpy.interpolate_structure.test_date_label_correct(fname_th): Make sure that the date column in the file doens’t have comment marker and raise error if it does

schimpy.interpolate_structure.test_template_times(template, dt)

schimpy.laplace_smooth_data module

schimpy.laplace_smooth_data.laplace_smooth_data2(mesh, data, kappa=0.05, dt=1.0, iter_total=150)

Apply Laplacian smoothing to a scalar field on a mesh using explicit diffusion.

This function performs iterative smoothing by updating each node’s value toward the average of its neighbors. It corresponds to forward Euler integration of the diffusion equation.

Parameters:

meshobject: A mesh object with a nodes array and a method get_neighbor_nodes(ndx) returning neighbor node indices for a given node.
datandarray of shape (N,): Initial scalar field values at each mesh node.
kappafloat, optional: Diffusivity coefficient. Controls the rate of smoothing. Default is 0.05.
dtfloat, optional: Timestep used for each smoothing iteration. Default is 1.0.
iter_totalint, optional: Number of smoothing iterations to perform. Default is 150.

Returns:

smooth_datandarray of shape (N,): The smoothed scalar field after iter_total iterations.

schimpy.laplace_smooth_data.laplace_smooth_data2_slow(mesh, data, kappa=0.05, dt=1.0, iter_total=150)

Apply Laplacian smoothing to a scalar field on a mesh using explicit diffusion.

DEPRECATED. Use the version without _slow in the name

This function performs iterative smoothing by updating each node’s value toward the average of its neighbors. It corresponds to forward Euler integration of the diffusion equation.

Parameters:

meshobject: A mesh object with a nodes array and a method get_neighbor_nodes(ndx) returning neighbor node indices for a given node.
datandarray of shape (N,): Initial scalar field values at each mesh node.
kappafloat, optional: Diffusivity coefficient. Controls the rate of smoothing. Default is 0.05.
dtfloat, optional: Timestep used for each smoothing iteration. Default is 1.0.
iter_totalint, optional: Number of smoothing iterations to perform. Default is 150.

Returns:

smooth_datandarray of shape (N,): The smoothed scalar field after iter_total iterations.

schimpy.laplace_smooth_data.laplace_smooth_with_vel2(mesh, data, vel, kappa=0.05, dt=1.0, iter_total=1)

Apply Laplacian smoothing with additive forcing to a scalar field on a mesh.

This function performs iterative diffusion of data while incorporating a source or forcing term vel at each node. It evolves the field using explicit Euler integration of the PDE:

∂u/∂t = κ ∇²u + vel

Parameters:

meshobject: A mesh object with a nodes array and a method get_neighbor_nodes(ndx) returning neighbor node indices for a given node.
datandarray of shape (N,): Initial scalar field values at each mesh node.
velndarray of shape (N,): Additive source or forcing term to apply at each node.
kappafloat, optional: Diffusivity coefficient. Default is 0.05.
dtfloat, optional: Timestep used for each smoothing iteration. Default is 1.0.
iter_totalint, optional: Number of smoothing iterations to perform. Default is 1.

Returns:

smooth_datandarray of shape (N,): The smoothed and forced scalar field after iter_total iterations.

schimpy.laplace_smooth_data.laplace_smooth_with_vel3(mesh, nlayer, data, vel, kappa=0.05, dt=1.0, iter_total=1)

Apply layer-aware Laplacian smoothing with forcing to a scalar field on a mesh.

This function diffuses values across mesh nodes but restricts neighbor contributions to those from the same or deeper layers. Shallower neighbors are excluded from smoothing influence, preserving stratification or flow directionality.

Parameters:

meshobject: A mesh object with a nodes array and a method get_neighbor_nodes(ndx) returning neighbor node indices for a given node.
nlayerndarray of shape (N,): Integer layer index for each node. Smoothing ignores neighbors with shallower layer values.
datandarray of shape (N,): Initial scalar field values at each mesh node (used as fallback for excluded neighbors).
velndarray of shape (N,): Additive source or forcing term applied at each node.
kappafloat, optional: Diffusivity coefficient. Default is 0.05.
dtfloat, optional: Timestep used for each smoothing iteration. Default is 1.0.
iter_totalint, optional: Number of smoothing iterations to perform. Default is 1.

Returns:

smooth_datandarray of shape (N,): The smoothed scalar field after iter_total iterations with layer-aware filtering and forcing.

schimpy.laplace_smooth_data.smooth_kernel_numba(data, neighbors, kappa, dt, iter_total)

schimpy.lsc2 module

Methods for generating local sigma coordinates These routines are meant to be called a pair. First, default_num_layers is called to obtain the recommended number of layers for each node based on depth. Then, gen_sigma is called to generate the actual local sigma values at each level (nlevels = nlayers+1).

Note that in this script eta is the “reference” free surface at which the mesh is conditioned, which can be a global scalar or array of local nodal values. Using a medium-higher value (2-4 depending on typical flood levels) usually does’t hurt the final product in low water. The example() shows how to visualize a mesh generated on one ref water surface on another surface.

The major user parameters are already set at their defaults. It is mildly important to realize that the S coordinate parameters have the same qualitative interpretation, but that the S system is really just used as a heuristic and everything is manipulated locally.

Besides theta (refinement to the surface) the mostly likely item to manipulate will be minlayer and maxlayer. These can be supplied locally (if these are given as arrays) or globally (if provided as scalars).

class schimpy.lsc2.BilinearMeshDensity

Bases: object

Methods

density
depth

density(z, h, x)

depth(t, h, x)

class schimpy.lsc2.CubicLSC2MeshFunction

Bases: object

Methods

density
depth

density(x, tlev)

depth(x, tlev)

schimpy.lsc2.default_num_layers(x, eta, h0, minlayer, maxlayer, dz_target, meshfun, maxlev=100): Returns the number of layers that, according to meshfun, gives a depth matching eta + h0 In the (likely) case of inexact fit) the lower bound n- of the number of layers not yet outfitted for variation in x

schimpy.lsc2.default_num_layers0(total_ref_depth, minlayer, maxlayer)

schimpy.lsc2.example()

schimpy.lsc2.example2()

schimpy.lsc2.example3()

schimpy.lsc2.flip_sigma(sigma)

Flip the ordering of non-nan sigma values.

The output of get_sigma starts from 0.0, but sigma in vgrid.in from -0.1. So it needs to be flipped for further use.

Parameters:

sigma: numpy.ndarray

Returns:

numpy.ndarray: New sigma array that has flipped ordering.

schimpy.lsc2.gen_sigma(nlayer, minlayer, maxlayer, eta, h, mesh, meshfun, nsmoothlay=0, out_dir='./')

“ Generate local sigma coordinates based on # layers, reference surface and depth

Parameters:

nlayer: ndarray: Veector of size np (number of nodes) giving desired # layers for each node in the mesh
eta: ndarray or float: reference water level heights at each node at which generation is to occur.
h: ndarray: unperturbed depth for each node in the mesh
meshfloat: maximum theta to use in S calculations. This is interpreted the same as a standard S grid theta although it will be varied according to depth
meshfun: float: S coordinate parameter b
nsmoothlay: how many layers to smooth on the bottom
out_dir: Path
hc: float: S coordinate parameter hc (do not alter)

schimpy.lsc2.label_components(mesh, nlayer, thresh, exclude)

schimpy.lsc2.lowest_layer_height(htrans, nlevel, klev=0)

schimpy.lsc2.mesh_function_depths(nlayer, depth, mesh, meshfun)

schimpy.lsc2.plot_mesh(ax, x, zcor, startvis, stopvis, c='black', linewidth=1)

schimpy.lsc2.process_orphans(mesh, nlayer, depth, hcor)

schimpy.lsc2.process_orphans2(mesh, nlayer, depth, hcor)

schimpy.lsc2.sigma_z(sigma, eta, h)

schimpy.lsc2.smooth_bed(mesh, eta, h, hcor, nlevel, speed, out_dir='./')

schimpy.lsc2.szcoord(s, h, eta, theta, b, hc)

schimpy.lsc2.z_sigma(zcor)

schimpy.material_poly module

schimpy.material_poly.create_arg_parser()

schimpy.material_poly.create_poly(shapefile, dsetname, keyfile, polyfile, type, default=None): Converts a polygon shapefile to the yaml input of the preprocessor

schimpy.material_poly.read_keyfile(keyfile): Reads a file pairing labels and values

schimpy.merge_th module

schimpy.merge_th.create_arg_parser()

schimpy.merge_th.main()

schimpy.merge_th.merge_th(th_spec)

schimpy.merge_th.read_data(fname, variable)

schimpy.merge_th.read_locations_from_input(fname, role)

schimpy.merge_th.read_th_spec(fname)

schimpy.merge_th.write_th(df, fname, elapsed, ref_time=None)

schimpy.metricsplot module

Metrics plot

schimpy.metricsplot.plot_comparison(*args, style_palette, **kwargs)

Create a simple comparison plot without metrics calculation

Parameters:

*args: variable number of TimeSeries

Returns:

matplotlib.pyplot.figure.Figure

schimpy.metricsplot.plot_metrics(obs, tssim, style_palette, **kwargs)

Create a metrics plot

Parameters:

*args: variable number of TimeSeries

Returns:

matplotlib.pyplot.figure.Figure

schimpy.model_time module

Script to make model date conversion convenient, converting elapsed model seconds to or from dates

schimpy.model_time.describe_elapsed(times, start, dt=None)

schimpy.model_time.describe_timestamps(timestamps, start, dt=None)

schimpy.model_time.elapsed_to_timestamp(input, time_basis, elapsed_unit='s'): Take input dataframe or th file and convert to timestamp, returns dataframe

schimpy.model_time.file_to_elapsed(infile, start, outpath=None, annotate=False, skip_nan=False)

schimpy.model_time.file_to_timestamp(infile, start, outpath=None, annotate=False, elapsed_unit='s', time_format='%Y-%m-%dT%H:%M ')

schimpy.model_time.get_headers(infile, no_index=True)

schimpy.model_time.is_elapsed(input): Check whether the input file is ‘elapsed’ or ‘timestamped’. Uses the first non-comment, non-blank line of the file to determine this. Ignores any text after a ‘#’ comment marker.

schimpy.model_time.multi_file_to_elapsed(input_files, output, start, name_transform='prune_dated')

schimpy.model_time.prune_dated(name)

schimpy.model_time.read_elapsed(input): Take input dataframe or th filename, returns dataframe

schimpy.model_time.read_th(input, time_basis=None, to_timestamp=True, elapsed_unit='s', head=None): Read input file and return dataframe. Automatically converts to timestamp if time_basis is supplied unless to_timestamp is False

schimpy.nml module

class schimpy.nml.Namelist(d)

Bases: object

The Namelist class simply creates an attribute for each key-value pair in the dictionary.

class schimpy.nml.TopLevelNamelist(d)

Bases: object

TopLevelNamelist is a class for the top-level elements of the dictionary, and Namelist is a class for all other nested elements. The TopLevelNamelist class creates attributes for each key-value pair in the dictionary and, if the value is itself a dictionary, creates a new Namelist object with the nested dictionary.

schimpy.nml.map_to_dict(obj): This function takes an object of type TopLevelNamelist as input and returns a dictionary representation of the object. The function uses the vars built-in function to get a dictionary of attributes and values for the object, and then iterates over the key-value pairs in the dictionary. If the value is an instance of the Namelist class, it recursively maps the Namelist object to a dictionary using the map_to_dict function. If the value is not an instance of the Namelist class, it simply adds the key-value pair to the dictionary. This way, you can easily map an object of type TopLevelNamelist back to a dictionary representation, preserving the structure of the original dictionary.

schimpy.nml.map_to_object(d)

In this example, TopLevelNamelist is a class for the top-level elements of the dictionary, and Namelist is a class for all other nested elements. The TopLevelNamelist class creates attributes for each key-value pair in the dictionary and, if the value is itself a dictionary, creates a new Namelist object with the nested dictionary. The Namelist class simply creates an attribute for each key-value pair in the dictionary.

The map_to_object function takes a dictionary d as input and returns a new TopLevelNamelist object with the values from d.

This way, you can easily map the dictionary returned by parse_namelist to objects, with different classes for the top-level and nested elements, and access the values in the dictionary as attributes of the objects.

schimpy.nml.parse(file_content)

Here’s a simple implementation of a parser for the Fortran namelist format If there’s a line starting with !, the parser will store it as the full_line_comment and attach it to the next key-value pair it encounters. If there’s an inline comment starting with !, it will be stored as inline_comment.

For the most part this parser is comment preserving; you might notice some whitespace and blank line(s) being eliminated in the round trip through write method below

schimpy.nml.write(namelist_data): writes out the namelist dictionary from the parse method to a string. The comments are preserved but not the whitespace or indentations

schimpy.nudging module

Created on Tue Jun 8 10:19:56 2021

@author: zzhang To be implemented: other weights function (length scale) from OI in additional to gaussian

class schimpy.nudging.Nudging(input, **kwargs)

Bases: object

A class to create schism nudging

Attributes:

mesh_gpd
z

Methods

`create_nudging`([create_file])
`read_yaml`()	read yaml and load mesh grid

concatenate_nudge
construct_weights
create_region_nudging
gaussian_weights
gen_nudge_3dfield
gen_nudge_obs
gen_region_weight
get_nudging_comb
in_vertices
organize_nudging
plot
read_data
reorder_variables
signa

concatenate_nudge(weights_var, values_var, imap_var, var_newlist, create_file=True)

construct_weights(attribute, x, y, x0, y0, norm_factor)

create_nudging(create_file=True)

Parameters:

create_fileTYPE, optional: Options to create nudging files. The default is True.
Returns
——-
None.

create_region_nudging(region_info)

static gaussian_weights(xy, xyc, attribute)

gen_nudge_3dfield(region_info)

gen_nudge_obs(region_info)

gen_region_weight(attribute, vertices)

get_nudging_comb()

in_vertices(vertices)

property mesh_gpd

organize_nudging(weights_comb, values_comb, imap_comb)

plot(imap, values, **kwargs)

read_data(data)

read_yaml(): read yaml and load mesh grid

static reorder_variables(var_info, var_ordered_list)

static signa(x1, x2, x3, y1, y2, y3)

property z

schimpy.nudging.create_arg_parser()

schimpy.nudging.main()

schimpy.nudging.write_to_log(message)

schimpy.param module

class schimpy.param.Params(fname, default=None)

Bases: object

Attributes:

hotstart_freq
nc_out_freq
nc_stack
run_start: Get start time as datetime
station_out_freq

Methods

`adjust_dt`()	Adjust dt without perturbing variables that depend on it
`copy`()	Return a copy of this Params set
`diff`(other[, defaults])	Compare to another instance of Params
`get_run_start`()	Get start time as datetime
`process_default`(default)	Process default parameters
`searchfor`(key[, section])	Search for key in all the sections
`set_hotstart_freq`(freq)	Set hotstart frequency using Pandas offset or string that evaluates as offset
`set_interval`(name, freq)	Set binary output frequency using Pandas offset or string that evaluates as offset
`set_nc_out_freq`(freq)	Set binary output frequency using Pandas offset or string that evaluates as offset
`set_nc_stack`(freq)	Set binary output frequency using Pandas offset or string that evaluates as offset
`set_run_start`(run_start)	Set start time
`set_station_out_freq`(freq)	Set station output frequency
`update`(other[, defaults])	Update from another instance of Params in-place
`validate`()	Validation tests

get_baro
get_hotstart_freq
get_interval
get_nc_out_freq
get_nc_stack
get_station_out_freq
sections
to_dataframe
write

adjust_dt(): Adjust dt without perturbing variables that depend on it

copy(): Return a copy of this Params set

diff(other, defaults=False)

Compare to another instance of Params

Parameters:

other: str | Params: Can be a string that evaluates to param filename, a Param object
defaultsbool: Search includes defaults

Returns:

diffpd.DataFrame: Data with multi index for section and parameter, including only parameters that are different, including possibly one being absent from one Param set

get_baro()

get_hotstart_freq()

get_interval(name)

get_nc_out_freq()

get_nc_stack()

get_run_start(): Get start time as datetime

get_station_out_freq()

property hotstart_freq

property nc_out_freq

property nc_stack

process_default(default)

Process default parameters

Parameters:

defaultstr or Param instance or ‘repo’: If default is ‘repo’, default is the GitHub repo version. If it is a filename, that name is evaluated. If it is a templated version, that version is read. (config part of this not done yet)

property run_start: Get start time as datetime

searchfor(key, section=False)

Search for key in all the sections

Parameters:

keystr

Key to search for

section = bool If boolean, returns a tuple of section, value

default = str Name of default to use for backup

Returns

Value cached under key

Raises

IndexError if key not present

sections(defaults=False)

set_hotstart_freq(freq)

Set hotstart frequency using Pandas offset or string that evaluates as offset

Parameters:

freq
If None, frequency will be set using default (or 1 Hour) and station output disabled

set_interval(name, freq): Set binary output frequency using Pandas offset or string that evaluates as offset

set_nc_out_freq(freq): Set binary output frequency using Pandas offset or string that evaluates as offset

set_nc_stack(freq): Set binary output frequency using Pandas offset or string that evaluates as offset

set_run_start(run_start)

Set start time

Parameters:

startdatetime
Coercible to datetime

set_station_out_freq(freq)

Set station output frequency

Parameters:

freqoffset or string: Sets output interval for staout files and ensures that output is enabled. If None, frequency will be set using default (or 1 Hour) and station output disabled

property station_out_freq

to_dataframe(defaults=None)

update(other, defaults=False)

Update from another instance of Params in-place

Parameters:

other: str | Params: Can be a string that evaluates to param filename, a Param object
defaultsbool: Search includes defaults

validate(): Validation tests

write(fname)

schimpy.param.param_from_template(name): Returns param based on named template files

schimpy.param.read_params(fname, default=None)

schimpy.param.test_param()

schimpy.params module

class schimpy.params.Core(*args: Any, **kwargs: Any)

Bases: Parameterized

Methods

__call__(*args, **kwargs)

Call self as a function.

dt
eco_class
ibc
ibtp
ihfskip
ipre
mdc2
msc2
nspool
ntracer_age
ntracer_gen
rnday
sed_class

class schimpy.params.HydroOutput(*args: Any, **kwargs: Any)

Bases: OutControls

Class to specify which variables to output from the SCHISM model

Methods

__call__(*args, **kwargs)

Call self as a function.

air_pressure
air_temperature
barotropic_pres_grad_xy
bottom_stress_xy
depth_avg_vel_xy
diffusivity
downward_longwave
dry_flag_node
elevation
evaporation_rate
from_iof_array
get_iof_array_names
horizontal_side_vel_xy
horizontal_vel_xy
latent_heat
mixing_length
precipitation_rate
salinity
salinity_at_element
sensible_heat
solar_radiation
specific_humidity
temperature
temperature_at_element
to_iof_array
total_heat
turbulent_kinetic_ener
upward_longwave
vertical_vel_at_element
vertical_velocity
viscosity
water_density
wind_speed_xy
wind_stress_xy
z_coordinates

air_pressure = False

air_temperature = False

barotropic_pres_grad_xy = False

bottom_stress_xy = False

depth_avg_vel_xy = False

diffusivity = False

downward_longwave = False

dry_flag_node = True

elevation = False

evaporation_rate = False

horizontal_side_vel_xy = False

horizontal_vel_xy = False

latent_heat = False

mixing_length = False

precipitation_rate = False

salinity = False

salinity_at_element = False

sensible_heat = False

solar_radiation = False

specific_humidity = False

temperature = False

temperature_at_element = False

total_heat = False

turbulent_kinetic_ener = False

upward_longwave = False

vertical_vel_at_element = False

vertical_velocity = False

viscosity = False

water_density = False

wind_speed_xy = False

wind_stress_xy = False

z_coordinates = False

class schimpy.params.Opt(*args: Any, **kwargs: Any)

Bases: Parameterized

Methods

__call__(*args, **kwargs)

Call self as a function.

alphaw
btrack_nudge
coricoef
courant_weno
cur_wwm
dfh0
dfv0
dramp
dramp_ss
drampbc
drampwafo
drampwind
dtb_max
dtb_min
dzb_min
eos_a
eos_b
eps1_tvd_imp
eps2_tvd_imp
epsilon1
epsilon2
epsilon3
flag_fib
flag_ic
fwvor_advxy_stokes
fwvor_advz_stokes
fwvor_breaking
fwvor_gradpress
fwvor_streaming
fwvor_wveg
fwvor_wveg_NL
gen_wsett
h0
h1_bcc
h1_pp
h2_bcc
h2_pp
h_bcc1
h_massconsv
h_tvd
hmin_airsea_ex
hmin_man
hmin_radstress
hmin_salt_ex
hvis_coef0
hw_depth
hw_ratio
i_hmin_airsea_ex
i_hmin_salt_ex
i_prtnftl_weno
iadjust_mass_consv0
ibcc_mean
ibdef
ibtrack_test
ic_elev
icou_elfe_wwm
ics
ielad_weno
ielm_transport
ieos_pres
ieos_type
if_source
iflux
iflux_out_format
iharind
ihconsv
ihdif
ihhat
ihorcon
ihot
ihydraulics
iloadtide
imm
indvel
inter_mom
inu_elev
inu_tr
inu_uv
inunfl
inv_atm_bnd
ip_weno
ipre2
iprecip_off_bnd
irouse_test
isav
isconsv
ishapiro
itr_met
itransport_only
itur
iunder_deep
iupwind_mom
iwbl
iwind_form
iwindoff
izonal5
kr_co
lev_tr_source
level_age
loadtide_coef
max_subcyc
meth_sink
mid
moitn0
mxitn0
nadv
nchi
ncor
niter_shap
nquad
nramp_elev
nstep_ice
nstep_wwm
ntd_weno
nu_sum_mult
nws
prmsl_ref
rearth_eq
rearth_pole
rho0
rinflation_icm
rlatitude
rmaxvel
rtol0
s1_mxnbt
s2_mxnbt
sfea0
shapiro0
shorewafo
shw
slam0
slr_rate
small_elad
stab
start_day
start_hour
start_month
start_year
step_nu_tr
tdmin_pp1
tdmin_pp2
thetai
turbinj
turbinjds
utc_start
vclose_surf_frac
vdmax_pp1
vdmax_pp2
vdmin_pp1
vdmin_pp2
velmin_btrack
vnf1
vnf2
vnh1
vnh2
wafo_obcramp
wtiminc
xlsc0

cur_wwm = False

dramp_ss = 60.0

eos_a = -0.1

eos_b = 1001.0

fwvor_advxy_stokes = False

fwvor_advz_stokes = False

fwvor_breaking = False

fwvor_gradpress = False

fwvor_streaming = False

fwvor_wveg = False

fwvor_wveg_NL = False

h1_bcc = 1.0

h2_bcc = 0.5

hw_depth = 15.0

hw_ratio = 1.2

iadjust_mass_consv0 = 1

ieos_pres = 0.0

ieos_type = 0

if_source = 2

inunfl = True

inv_atm_bnd = False

ipre2 = 0

isav = 0

iunder_deep = 0

iwbl = 0

nstep_ice = 0

rho0 = 1000.0

shw = 0.025

slr_rate = 0.0

turbinj = False

vclose_surf_frac = 0.0

wafo_obcramp = 1

class schimpy.params.OutControls(*args: Any, **kwargs: Any)

Bases: Parameterized

Parameters controlling output

Methods

__call__(*args, **kwargs)

Call self as a function.

from_iof_array
get_iof_array_names
to_iof_array

from_iof_array(iof_array)

get_iof_array_names()

to_iof_array()

class schimpy.params.Params(core, opt, schout)

Bases: tuple

Methods

`count`(value, /)	Return number of occurrences of value.
`index`(value[, start, stop])	Return first index of value.

core: Alias for field number 0

opt: Alias for field number 1

schout: Alias for field number 2

class schimpy.params.Schout(*args: Any, **kwargs: Any)

Bases: Parameterized

Methods

__call__(*args, **kwargs)

Call self as a function.

iof_age
iof_ana
iof_cos
iof_dvd
iof_eco
iof_fib
iof_gen
iof_hydro
iof_ice
iof_icm_ba
iof_icm_cbp
iof_icm_core
iof_icm_dbg
iof_icm_ph
iof_icm_sav
iof_icm_sed
iof_icm_silica
iof_icm_veg
iof_icm_zb
iof_marsh
iof_sed
iof_sed2d
iof_ugrid
iof_wwm
iout_sta
nc_out
nhot
nhot_write
nspool_sta

class schimpy.params.TracerGenOutput(*args: Any, **kwargs: Any)

Bases: Parameterized

Methods

__call__(*args, **kwargs)

Call self as a function.

get_tracer_names
ntracer_gen

get_tracer_names()

class schimpy.params.WindWaveOutput(*args: Any, **kwargs: Any)

Bases: OutControls

A collection of parameters that define the wind wave outputs.

Methods

__call__(*args, **kwargs)

Call self as a function.

bottom_excursion_period
bottom_wave_period
charnock_coeff
continuous_peak_period
discrete_peak_direction
diss_rate_bott_friction
diss_rate_dep_breaking
diss_rate_vegetation
diss_rate_whitecapping
dominant_direction
energy_input_atmos
frictional_velocity
from_iof_array
get_iof_array_names
mean_dir_spreading
mean_wave_direction
mean_wave_length
mean_wave_number
mean_wave_period
orbital_velocity
peak_group_vel
peak_n_factor
peak_period
peak_phase_vel
peak_spreading
peak_wave_length
peak_wave_number
rms_orbital_velocity
roller_diss_rate
roughness_length
sig_wave_height
tm_10
to_iof_array
u_resell_number
wave_energy_dir_x
wave_energy_dir_y
zero_downcross_period

schimpy.params.build_iof_dict(iof_name, vdict, cls): Builds dictionary of names from the class cls and the values that have the form iof_name(n) = 0 or 1 where n is an integer and the values are 0 or 1 which map onto False (0) or True (1)

schimpy.params.coerce_to_type(schema, value)

schimpy.params.create_params(namelists)

schimpy.params.get_type_dict(cls)

schimpy.params.get_value_dict(map, cls): Create a dict from namelist from name: value elements and coerce to the type in the schema

schimpy.plot_default_formats module

Convenient routines to set up and to tweak matplotlib plots.

schimpy.plot_default_formats.set_color_cycle_dark2()

Set color cycles of Dark2 theme of colorbrewer.org globally. Just calling this function once before finalize a plot is enough to change the color cycles.

Returns:

brewer_colors: list: list of the colors

schimpy.plot_default_formats.set_dual_axes(ax, ts, cell_method='inst')

Create a dual y-axis with unit information in the given time series. It converts SI units to non-SI one.

Parameters:

ax: matplotlib.axes: axes of a plot to manage
ts: vtools.data.TimeSeries: timeseries with unit information

schimpy.plot_default_formats.set_dual_axes_elev(ax1, filtered=False)

Set dual axes for elevation.

Parameters:

ax: matplotlib axes

schimpy.plot_default_formats.set_dual_axes_salt(ax1, filtered=False)

Set a dual y-axis for salt with a PSU y-axis

Parameters:

ax: axis: a Matplotlib axes

schimpy.prepare_schism module

Driver module to prepares input files for a SCHISM run.

schimpy.prepare_schism.prepare_schism(args, use_logging=True)

schimpy.priority_queue module

class schimpy.priority_queue.priorityDictionary

Bases: dict

Methods

`clear`()
`copy`()
`fromkeys`(iterable[, value])	Create a new dictionary with keys from iterable and values set to value.
`get`(key[, default])	Return the value for key if key is in the dictionary, else default.
`items`()
`keys`()
`pop`(key[, default])	If the key is not found, return the default if given; otherwise, raise a KeyError.
`popitem`(/)	Remove and return a (key, value) pair as a 2-tuple.
`setdefault`(key, val)	Reimplement setdefault to call our customized __setitem__.
`smallest`()	Find smallest item after removing deleted items from heap.
`update`([E, ]**F)	If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]
`values`()

setdefault(key, val): Reimplement setdefault to call our customized __setitem__.

smallest(): Find smallest item after removing deleted items from heap.

schimpy.profile_plot module

schimpy.profile_plot.get_index_bounds()

schimpy.profile_plot.nearest_neighbor_fill(arr)

schimpy.profile_plot.profile_plot(x, z, data, ax, context_label=None, add_labels=False, xlabel=None, xmin=None, xmax=None, max_depth=None): UnTRIM-like profile plot of salinity xmin,xmax are the bounds (in km) of the profile max_depth is the maximum depth, data assumed to be

schimpy.profile_plot.set_index_bounds(min_station, max_station, max_depth)

schimpy.profile_plot.vertical_fill(arr)

schimpy.raster_to_nodes module

Optimized raster_to_nodes function without rasterstats, using rasterio directly.

schimpy.raster_to_nodes.raster_to_nodes(mesh, nodes_sel, path_raster, bins=None, mapped_values=None, mask_value=None, fill_value=None, band=1)

Applies raster values to mesh by calculating means over surrounding elements.

Parameters:

(same as original)

Returns:

numpy.array: means of raster values of the element balls around the nodes

schimpy.read_output_xyt module

Read outputs from read_output*_xyt and create a neat list of Vtools time series. This module depends on deprecated vtools code and is scheduled for removal

schimpy.read_output_xyt.read_depth_avg_from_output7b_xyt(fpath, time_basis)

Read output file from read_output7b_xyt and return depth and depth-averaged values in vtools.data.timeseries.

Parameters:

fpath: str: master input file name of read_output7b_xyt
time_basis: datetime.datetime: time base of the outputs

Returns:

lists of a set vtools.data.timeseries of depth and depth-averaged values: For scalars, the list has only one set of time series. For vectors, the list has two sets of time series. Each time series has multiple columns of data, and each column is for stations.

schimpy.schism_hotstart module

Module for creating a schism hotstart file

Options:

Centering:
- node2D: node (2D surface)
- node3D: node at whole level
- edge: edge center at whole level (mainly for horizontal velocty)
- elem: element center at whole level (mainly for vertical velocity)
- prism: prism center (for tracers); three different variables tr_el, tr_nd,
- tr_el need to be generated for the hotstart.nc file.
  
  tr_nd = tr_nd0 (on nodes)
  
  tr_el (on element at middle level)
Initializer:
- text_init: 2D map input from either *.prop or *.ic files; require input text file.
- simple_trend: can either be a number or an equation that depends on x (lat) and y(lon). e.g,: 0.97 + 1.e-5*x
- patch_init: regional-based method. Polygon shapefile input required.
- extrude_casts: 3D nearest neighbourhood interpolation based on Polaris cruise transects.
- obs_points: interpolated from 1D (time series of) observational points.
- hotstart_nc: initialize with a previous hotstart output from the same or a different mesh.
- schout_nc: initialize with a schism output snapshot.

Required data files:

param.in
hgrid.gr3
vgrid.in
hotstart.yaml and input files defined in the yaml file.

class schimpy.schism_hotstart.SCHISMHotstart

Bases: object

Mock object

class schimpy.schism_hotstart.VariableField(v_meta, vname, mesh, depths, date, crs, tr_mname, hotstart, hotstart_ini=None, **kwargs)

Bases: object

A class initializing each varaible for the hotstart file

Methods

`define_new_grid`(mesh)	Generating hgrid and vgrid based on centering option for a new grid
`elem2node_values`(vmap)	equation converting 2D values on element to nodes.
`extrude_casts`([ini_meta, inpoly])
`get_grid`()	Getting the number and coordinates of horizontal nodes/elems/edges for different centering options and return them as grid.
`initializer_options`()	Options for input file initializers The input initializer overwrites self.initializer
`map_to_3D`(v_2d, nz)	polulate the 2D map values to 3D by applying the uniform values over dpeth.
`obs_points`([ini_meta, inpoly])	obs_file includes Lat, Lon, and values for the variable.
`patch_initializer_options`(initializer)	Options for patch initializers The input initializer overwrites self.initializer
`simple_trend`([ini_meta, inpoly])	Assigning a spatially uniformed value or an equation that's dependent on lat, lon
`text_init`([ini_meta, inpoly])	Reading 2D map from either a .prop (on element) or a .ic (on node) file If a prop file is read, the element values will need to be converted to node values.

GenerateField
create_dataarray
get_key
get_value
hotstart_nc
interp_from_mesh
node2elem_values
patch_init
schout_nc
var_centering

GenerateField()

create_dataarray(var)

define_new_grid(mesh)

Generating hgrid and vgrid based on centering option for a new grid: Parameters

elem2node_values(vmap): equation converting 2D values on element to nodes.

extrude_casts(ini_meta=None, inpoly=None)

get_grid(): Getting the number and coordinates of horizontal nodes/elems/edges for different centering options and return them as grid.

classmethod get_key(dict_obj)

classmethod get_value(dict_obj)

hotstart_nc(ini_meta=None, inpoly=None)

initializer_options(): Options for input file initializers The input initializer overwrites self.initializer

interp_from_mesh(hgrid_fn, vin, vgrid_fn=None, vgrid_version='5.10', inpoly=None, dist_th=None, method=None)

classmethod map_to_3D(v_2d, nz): polulate the 2D map values to 3D by applying the uniform values over dpeth.

node2elem_values(vmap)

obs_points(ini_meta=None, inpoly=None): obs_file includes Lat, Lon, and values for the variable.

patch_init(poly_fn=None)

patch_initializer_options(initializer): Options for patch initializers The input initializer overwrites self.initializer

schout_nc(var, ini_meta=None, inpoly=None)

simple_trend(ini_meta=None, inpoly=None): Assigning a spatially uniformed value or an equation that’s dependent on lat, lon

text_init(ini_meta=None, inpoly=None): Reading 2D map from either a .prop (on element) or a .ic (on node) file If a prop file is read, the element values will need to be converted to node values.

var_centering()

schimpy.schism_hotstart.create_arg_parser()

schimpy.schism_hotstart.describe_tracers(param_nml, modules=['HYDRO'])

return the number of tracers, the sequence of the tracers and a list of tracer names based on the input list of modules and corresponding input files.

Availabel modules are:

T (default)

S (default)

GEN

AGE

SED3D: SED

EcoSim: ECO

ICM: ICM and/or ICM_PH

CoSiNE: COSINE

Feco: FIB

TIMOR

FABM

The script is mainly translated from schism_ini.F90

class schimpy.schism_hotstart.hotstart(input=None, modules=None, crs=None, envvar=None)

Bases: object

A class to generate hotstart initial condition for SCHISM

Methods

`get_mesh`(hgrid_fn[, vgrid_fn, vgrid_version])	Load and cache a SCHISM mesh (hgrid+vgrid), checking consistency between horizontal and vertical grids.
`map_to_schism`()	map the hotstart variable to the variable names required by SCHISM hotstart file.
`read_yaml`([use_logging])	read yaml and load mesh grid
`wet_dry_check`()	modify idry_e, idry, and idry_s based on eta2 and water depth.

close_hotstart_cache
create_hotstart
generate_3D_field
get_hotstart_data
initialize_netcdf

close_hotstart_cache()

create_hotstart()

generate_3D_field(variable)

get_hotstart_data(path)

get_mesh(hgrid_fn, vgrid_fn=None, vgrid_version=None)

Load and cache a SCHISM mesh (hgrid+vgrid), checking consistency between horizontal and vertical grids.

Parameters:

hgrid_fnstr: Path to the hgrid (horizontal mesh) file.
vgrid_fnstr or None: Path to the vgrid (vertical grid) file. None if not applicable.
vgrid_versionint or None: Version of vgrid format if needed.

Returns:

meshSchismMesh: Fully loaded and validated mesh object.

initialize_netcdf(default_turbulence=True)

map_to_schism(): map the hotstart variable to the variable names required by SCHISM hotstart file.

read_yaml(use_logging=True): read yaml and load mesh grid

wet_dry_check(): modify idry_e, idry, and idry_s based on eta2 and water depth.

schimpy.schism_hotstart.hotstart_to_outputnc(hotstart_fn, init_date, hgrid_fn='hgrid.gr3', vgrid_fn='vgrid.in', vgrid_version=5.8, outname='hotstart_out.nc'): convert hotstart.nc to schism output nc file format that can be read by VisIt.

schimpy.schism_hotstart.main()

schimpy.schism_hotstart.num(s)

schimpy.schism_hotstart.project_mesh(mesh, new_crs)

schimpy.schism_hotstart.read_hotstart(): Mock method to read existing hotstart

schimpy.schism_hotstart.read_param_nml(nml_fn): read param.in file and generate a dict object with key, value pairs for all the parameters

schimpy.schism_input module

This module handles SCHISM input data which are a mesh, structures, and sources/sinks. @author: Kijin Nam, knam@water.ca.gov

class schimpy.schism_input.SchismInput(logger=None)

Bases: object

Attributes:

mesh
nudging
sources
structures
time_start

Methods

add_structure
clear_structures
n_sinks
n_sources
n_structures

add_structure(value)

clear_structures()

property mesh

n_sinks()

n_sources()

n_structures()

property nudging

property sources

property structures

property time_start

schimpy.schism_linestring module

Line String data based on Shapely LineStrings

class schimpy.schism_linestring.LineString(coordinates=None, prop=None)

Bases: LineString

Attributes:

prop

Methods

__call__(*args, **kwargs)

Call self as a function.

property prop

class schimpy.schism_linestring.LineStringIo

Bases: object

Methods

read
write

read(**kwargs)

write(**kwargs)

class schimpy.schism_linestring.LineStringIoFactory

Bases: object

Methods

get_reader
get_writer

get_reader(name)

get_writer(name)

registered_readers = {'shp': 'LineStringShapefileReader', 'yaml': 'LineStringYamlReader'}

registered_writers = {'shp': 'LineStringShapefileWriter', 'yaml': 'LineStringYamlWriter'}

class schimpy.schism_linestring.LineStringShapefileReader

Bases: LineStringIo

Methods

read(fpath, **kwargs)

write

read(fpath, **kwargs)

Parameters:

fpath: str: input file name

Returns:

lines: list of LineStrings

class schimpy.schism_linestring.LineStringShapefileWriter

Bases: LineStringIo

Methods

write(fpath, lines[, spatial_reference, ...])

read

write(fpath, lines, spatial_reference=None, driver_name=None, **kwargs)

Parameters:

fpath: str: output file name
lines: array of schism_linestring.LineString: list of LineStrings
spatial_reference: osgeo.osr.SpatialReference
default: NAD83, UTM zone 10N, meter
todo: reference needs to be in api right now hard to use

class schimpy.schism_linestring.LineStringYamlReader

Bases: LineStringIo

Methods

read
write

read(fpath, **kwargs)

class schimpy.schism_linestring.LineStringYamlWriter

Bases: LineStringIo

Write line strings from a YAML file

Methods

read
write

write(fpath, lines)

schimpy.schism_linestring.read_linestrings(fpath)

schimpy.schism_linestring.write_linestrings(fpath, lines)

Parameters:

fpath: str: output file name
lines: array of schism_linestring.LineString: list of LineStrings

schimpy.schism_mesh module

3D Version of schism_mesh

schimpy.schism_mesh.BoundaryType: alias of Enum

class schimpy.schism_mesh.SchismMesh

Bases: TriQuadMesh

Memory model of 3D SCHISM mesh

Attributes:

boundaries: An array of the boundary information
edges: Get the array of edges
elems: Array of node indexes of all elements.
n_vert_levels
node2elems
nodes: Node array consisting of three-dimensional coordinates of each node.
vmesh
z: Get the elevation of levels at all the nodes

Methods

`add_boundary`(nodes, btype[, comment])	Add one boundary.
`allocate`(n_elems, n_nodes)	Allocate memory for nodes and elems
`areas`()	Get the array of element areas
`build_edgecenters`()	Build centers of sides
`build_edges_from_elems`([shift])	Build edge array from the elements.
`build_elem_balls`()	Build balls of elements around each node
`build_z`([elev])	Build vertical coordinates
`centroids`()	Get a Numpy array of element centroids Returns ------- numpy.ndarray
`clear_boundaries`()	Delete all the current boundary information
`compare`(mesh)	Compare the mesh with another
`edge_len`()	Get a NumPy array of edge lengths The ordering of the edges is decided from triquadmesh.
`elem`(elem_i)	Get connectivity of an element
`element2edges`(elem_i)	Get edge indexes of the give element index
`fill_land_and_island_boundaries`()	Fill land and island boundaries for boundary edges not assigned to boundaries.
`fill_open_boundaries`()	Fill open boundaries for boundary edges not assigned to boundaries.
`find_closest_elems`(pos[, count])	Find indexes of the closet elems with the given position.
`find_closest_nodes`(pos[, count, boundary])	Returns the count closest nodes to the given node in 2D space.
`find_edge`(nodes[, direction])	Find an edge index with the two given node indexes.
`find_elem`(pos)	Find a element index from a coordinate pos = A coordinate (2D) return = element index
`find_intersecting_elems_with_line`(line_segment)	Format of the line segment: start_x, start_y, end_x, end_y
`find_neighbors_on_segment`(line_segment)	Find elements on the line_segment and neighbors that are all to the left (downstream) Format of the line segment: start_x, start_y, end_x, end_y Returns a list of elements on the segment and a list of neighbors.
`find_nodes_in_box`(box)	Find nodes in a bounding box.
`find_two_neighboring_node_paths`(line_segment)	Find two neighboring node paths around a line_segment
`get_centers_of_elements`()	Get the array of the centers of the element
`get_centers_of_sides`()	Get the array of the centers of the sides
`get_coordinates_3d`()	Get the array of each 3-d nodes
`get_edges_from_node`(node_i)	Get edge indexes related to node_i
`get_elems_i_from_node`(node_i)	Get the ball of elements around a node, node_i
`get_neighbor_nodes`(node_i)	Get neighboring node indexes from the given node index.
`is_elem_on_boundary`(elem_i)	Check if the given element with index elem_i is on the boundary
`mark_elem_deleted`(elem_i)	Mark an element as deleted or invalid.
`merged_mesh`()	merge all the meshes to create a boundary polygon
`n_boundaries`([btype])	Get the number of boundaries.
`n_edges`()	Get the total number of edges.
`n_elems`()	Get the total number of elements.
`n_nodes`()	Get the total number of nodes.
`n_total_boundary_nodes`(btype)	Get the total node boundary of a given type
`node`(node_i)	Selects a single node
`plot_elems`(var[, ax, inpoly, plot_nan])	Plot variables (1D array on element) based on SCHISM mesh grid.
`plot_mesh_boundary`([ax, edgecolor])	Plot the edge of the computational grid.
`plot_open_boundaries`([ax, edgecolor])	Plot the open boundaries of the computational grid.
`renumber`()	removes duplicate elems and nodes that are not referenced by any element, as well as elems that have been deleted (==-1) This function is lifted and modified slightly from Rusty's code.
`set_elem`(index, connectivity)	Set element connectivity information.
`set_node`(index, coords)	Set one node information.
`shortest_path`(n1, n2[, boundary_only])	Dijkstra on the edge graph from node n1 to n2.
`to_geopandas`([feature_type, crs, shp_fn, ...])	Create mesh polygon and points as geopandas dataframe and shapefiles if Shap_fn file name is supplied.
`trim_elems`(paths[, left])	Given a path, trim all elems to the left of it.
`trim_to_left_of_mesh`(line_segments)	Trim mesh using line_segments.

plot_edges
plot_nodes

add_boundary(nodes, btype, comment=None)

Add one boundary.

Parameters:

nodes: an array of integer: array of inter node indexes in the boundary path
btype: integer: an integer constant for boundary types.
comment: optional, string

areas()

Get the array of element areas

Returns:

numpy.ndarray

property boundaries

An array of the boundary information

Getter:: Get the array of the boundary information

build_z(elev=0.0)

Build vertical coordinates

Returns:

numpy.ndarray

centroids(): Get a Numpy array of element centroids Returns ——- numpy.ndarray

clear_boundaries(): Delete all the current boundary information

edge_len()

Get a NumPy array of edge lengths The ordering of the edges is decided from triquadmesh. Look edges properties to find out connectivity

Returns:

numpy.ndarray

fill_land_and_island_boundaries(): Fill land and island boundaries for boundary edges not assigned to boundaries.

fill_open_boundaries(): Fill open boundaries for boundary edges not assigned to boundaries.

find_two_neighboring_node_paths(line_segment)

Find two neighboring node paths around a line_segment

Parameters:

line_segment: array-like: two end points of the line segment, start_x, start_y, end_x, end_y

Returns:

up_path: array of int: upstream side of node paths
down_path: array of int: downstream side of node paths

get_centers_of_elements()

Get the array of the centers of the element

Returns:

numpy.ndarray: Array of 2-d coordinates of the centers of the elements The shape of the array is (n_elems, 2)

get_centers_of_sides()

Get the array of the centers of the sides

Returns:

numpy.ndarray: Array of 3-d coordinates of the centers of the elements The shape of the array is (n_elems, 2)

get_coordinates_3d()

Get the array of each 3-d nodes

Returns:

numpy.ndarray: Array of 3-d coordinates The shape of the array is (n_nodes * n_vert_levels, 3) The points below the most bottom level will be filled with the elevation of the the bottom level

merged_mesh(): merge all the meshes to create a boundary polygon

n_boundaries(btype=None)

Get the number of boundaries. If a boundary type is given, it counts only boundaries with the corresponding type.

Parameters:

btype: integer, optional: Type of the boundary.

n_total_boundary_nodes(btype)

Get the total node boundary of a given type

Parameters:

btype: integer: Type of the boundary.

property n_vert_levels

plot_edges(var, ax=None, size=500, inpoly=None, **kwargs)

plot_elems(var, ax=None, inpoly=None, plot_nan=False, **kwargs): Plot variables (1D array on element) based on SCHISM mesh grid. if var is None,just plot the grid.

plot_mesh_boundary(ax=None, edgecolor='k', **kwargs): Plot the edge of the computational grid.

plot_nodes(var, ax=None, inpoly=None, plot_nan=False, **kwargs)

plot_open_boundaries(ax=None, edgecolor='blue', **kwargs): Plot the open boundaries of the computational grid.

to_geopandas(feature_type='polygon', crs=None, shp_fn=None, node_values=None, elem_values=None, edge_values=None, value_name=None, create_gdf=True): Create mesh polygon and points as geopandas dataframe and shapefiles if Shap_fn file name is supplied.

trim_to_left_of_mesh(line_segments)

Trim mesh using line_segments. This function trims the mesh on the left sides of the line segments. The left side here means left when you look at the second end point of a line segment from the first one. An actual path to trimming is a nodal path that is on the right side of the line segment. To manage torus like mesh topology, the argument takes an array of line segments. The user need to provides a set of line segments to make sure the left side of the line segments does not cover the whole mesh. To trim multiple parts of a mesh, use this function multiple times. This function clears up any boundary definitions associated with the original grid. It is user’s responsibility to create them again.

line_segments = array of line segments defined by two end points

property vmesh

property z

Get the elevation of levels at all the nodes

Returns:

numpy.ndarray: Depth array of each levels at the nodes. The shape of the array is (n_nodes, n_vert_levels) The levels below the most bottom level will be filled with the elevation of the bottom level

schimpy.schism_mesh.read_mesh(fpath_mesh, fpath_vmesh=None, vgrid_version='5.10', **kwargs)

Read a mesh data

Returns:

SchismMesh

schimpy.schism_mesh.write_mesh(mesh, fpath_mesh, node_attr=None, write_boundary=False, crs=None, **kwargs)

Write a horizontal mesh

Parameters:

mesh: SchismMesh: Mesh
fpath_mesh: str

schimpy.schism_polygon module

Polygon data structure with preprocessor-related attributes and converters

class schimpy.schism_polygon.SchismPolygon(shell=None, holes=None, prop=None)

Bases: Polygon

A polygon class based on shapely.geometry.Polygon. This class has extra information

Attributes:

attribute
name
prop
type

Methods

`__call__`(args, *kwargs)	Call self as a function.
`contains`(point)	Check the polygon contains the point
`intersects`(val)	Check the polygon intersects with the point

property attribute

contains(point)

Check the polygon contains the point

Parameters:

point: np.ndarray or shapely.geometry.polygon.Polygon

Returns:

bool

intersects(val)

Check the polygon intersects with the point

Parameters:

point: np.ndarray or shapely.geometry.polygon.Polygon

Returns:

bool

property name

property prop

property type

class schimpy.schism_polygon.SchismPolygonDictConverter

Bases: SchismPolygonIo

Convert a tree to a list of polygons

Methods

read

read(data)

class schimpy.schism_polygon.SchismPolygonIo

Bases: object

SchismPolygon I/O abstract class

Methods

read

read(stream)

class schimpy.schism_polygon.SchismPolygonIoFactory

Bases: object

A factory class for SchismPolygonIo

Methods

get_reader
get_writer
show_registered_readers

get_reader(name)

get_writer(name)

registered_readers = {'dict': 'SchismPolygonDictConverter', 'shp': 'SchismPolygonShapefileReader', 'yaml': 'SchismPolygonYamlReader'}

registered_writers = {'shp': 'SchismPolygonShapefileWriter', 'yaml': 'SchismPolygonYamlWriter'}

show_registered_readers()

class schimpy.schism_polygon.SchismPolygonShapefileReader

Bases: SchismPolygonIo

Read polygons from a shape file

Methods

read(fpath)

Read polygons from a Shapefile and return a list of SchismPolygons.

read(fpath)

Read polygons from a Shapefile and return a list of SchismPolygons.

Parameters:

fpath: str: Filename of a Shapefile containing Polygons with data columns such as name, type, and attribute.

Returns:

list: list of SchismPolygons

class schimpy.schism_polygon.SchismPolygonShapefileWriter

Bases: SchismPolygonIo

Methods

write(fpath, polygons[, spatial_reference, ...])

Convert SCHISM polygon YAML file to a shapefile

read

write(fpath, polygons, spatial_reference=None, driver_name=None)

Convert SCHISM polygon YAML file to a shapefile

Parameters:

fpath: str: output file name
polygons: array of schism_polygon.SchismPolygon: polygons to write
spatial_reference: osgeo.osr.SpatialReference or crs string: default: NAD83, UTM zone 10N, meter
driver_name: osgeo.ogr Driver name: default: ESRI Shapefile

class schimpy.schism_polygon.SchismPolygonYamlReader

Bases: SchismPolygonIo

Read polygons from a SCHISM YAML polygon file

Methods

read

read(fpath)

class schimpy.schism_polygon.SchismPolygonYamlWriter

Bases: SchismPolygonIo

Write polygons into a YAML file

Methods

read
write

write(fpath, polygons)

schimpy.schism_polygon.read_polygons(fpath): Read a polygon file

schimpy.schism_polygon.write_polygons(fpath, polygons)

schimpy.schism_setup module

Setup and processes SCHISM Inputs

class schimpy.schism_setup.SchismSetup(logger=None)

Bases: object

A class to manage SCHISM input data

Attributes:

input
mesh: Mesh

Methods

`adopt_new_mesh`(fname)	Adopt a new grid.
`apply_polygons`(polygons, default)	Partition the grid with the given polygons.
`creart_sources_from_user_input`()	Create a source from a user input
`create_flux_regions`(linestrings[, out_fname])	Create and write flux_regions.gr3 with the given lines
`create_node_partitioning`(gr3_fname, ...)	Create a gr3 file with node partitioning using polygons in the polygon file.
`create_open_boundaries`(segments)	Create open boundaries with linestrings
`create_prop_partitioning`(prop_fname, ...)	Create a prop file with element partitioning using polygons in the polygon file.
`create_source_sink_in`(source_sinks[, out_fname])	Create source_sink.in from source/sink location information in_fname = input file name
`create_structures`(structures[, nudging])	Create structures
`elements_on_linestring`(coords)	List elements along linestring
`interpolate_tide`(time_start, time_end, dt, ...)	Interpolate an observed tide time series with the given dt.
`load`(dir)	Read SCHISM input
`modify_depth`(polygon_data)	Modify depth with the polygon information
`reorder_open_boundaries`(order)	Reorder open boundaries with the given order order = list of open boundary names TODO: How to put the name of the boundaries is not settled.
`trim_to_left_of_mesh`(line_segments)	Trim mesh using line_segments.
`write_hgrid`(fname[, attr, boundary])	Write a hgrid file only.
`write_hgrid_ll`(fname, boundary[, input_crs, ...])	Write a hgrid.ll, lat-long mesh file, of the current mesh.
`write_structures`([fname])	Write a SCHISM structure file fname = output file name

apply_linestring_ops
get_closest_node_i_from_new_mesh

adopt_new_mesh(fname): Adopt a new grid. fname = the file name of a new hgrid file

apply_linestring_ops(default, linestrings)

apply_polygons(polygons, default)

Partition the grid with the given polygons. Each node (not element) will be assigned with an integer ID which is the index of the polygons. If some polygons overlap, the latter one will trump the former one. The area that are not covered by any of the given polygons will have a default negative one attribute.

Parameters:

polygons: list: a list of polygon dict (from YAML most of time)

Returns:

numpy.ndarray: attributes

creart_sources_from_user_input(): Create a source from a user input

create_flux_regions(linestrings, out_fname='fluxflag.prop')

Create and write flux_regions.gr3 with the given lines

Parameters:

linestrings: list: A list containing information for flux regions. It must contains ‘linestrings.’
out_fname: str, optional: Output file name

create_node_partitioning(gr3_fname, polygons, default, smooth): Create a gr3 file with node partitioning using polygons in the polygon file. gr3_fname = output gr3 file name polygons = polygons

create_open_boundaries(segments): Create open boundaries with linestrings

create_prop_partitioning(prop_fname, polygons, default): Create a prop file with element partitioning using polygons in the polygon file. prop_fname = output prop file name polygons = polygons

create_source_sink_in(source_sinks, out_fname='source_sink.in'): Create source_sink.in from source/sink location information in_fname = input file name

create_structures(structures, nudging=None): Create structures

elements_on_linestring(coords): List elements along linestring

get_closest_node_i_from_new_mesh(mesh, node_i)

property input

interpolate_tide(time_start, time_end, dt, in_fname, out_fname): Interpolate an observed tide time series with the given dt. time_start = start time in Python datetime time_end = end time in Python datetime dt = delta t for the interpolation output in_fname = input file name of tide records out_fname = output file name

load(dir)

Read SCHISM input

Parameters:

dir: String: An directory where the SCHISM inputs reside

property mesh

Mesh

Getter:: Return the mesh.

modify_depth(polygon_data): Modify depth with the polygon information

reorder_open_boundaries(order): Reorder open boundaries with the given order order = list of open boundary names TODO: How to put the name of the boundaries is not settled.

trim_to_left_of_mesh(line_segments)

Trim mesh using line_segments. This function trims the mesh on the left sides of the line segments. The left side here means left when you look at the second end point of a line segment from the first one. An actual path to trimming is a nodal path that is on the right side of the line segment. To manage torus like mesh topology, the argument takes an array of line segments. The user need to provides a set of line segments to make sure the left side of the line segments does not cover the whole mesh. To trim multiple parts of a mesh, use this function multiple times. This function clears up any boundary definitions associated with the original grid. It is user’s responsibility to create them again.

line_segments = array of line segments defined by two end points

write_hgrid(fname, attr=None, boundary=True): Write a hgrid file only. fname = the output file name attr = attribute array in numpy format. If None, original data will be kept. boundary = If True, boundary info will be appended at the end of the file. Otherwise, not appended.

write_hgrid_ll(fname, boundary, input_crs='EPSG:26910', output_crs='EPSG:4269')

Write a hgrid.ll, lat-long mesh file, of the current mesh.

Parameters:

fname: str: the output file name
input_epsg: int, optional: input EPSG. default value is 26910, NAD83/UTM10N.
output_epsg: int, optional: output EPSG. default value is 4269, NAD83

write_structures(fname='hydraulics.in'): Write a SCHISM structure file fname = output file name

schimpy.schism_setup.check_and_suggest(testees, list_words, logger=None): Check testees in list_words and if not suggest something if possible

schimpy.schism_setup.check_similarity(testee, list_words): Check similarity of a word

schimpy.schism_setup.create_schism_setup(fname, logger=None)

Read a mesh and return a SCHISM input set-up instance.

Parameters:

fname: str

Returns:

SCHISM input set-up instance

schimpy.schism_setup.ensure_outdir(outdir, fname)

schimpy.schism_setup.load_schism(dir): A load function

schimpy.schism_source module

class schimpy.schism_source.SchismSource

Bases: object

A class to hold structure information

Attributes:

coord
element_id
note
type

property coord

property element_id

property note

property type

class schimpy.schism_source.SchismSourceIO(input)

Bases: object

A class to manage source/sink I/O

Methods

read
write

read(fname)

write(fname='source_sink.in')

schimpy.schism_source.read_sources(fname)

schimpy.schism_sources_sinks module

schimpy.schism_sources_sinks.concat_msource_csv(csv_fn1, csv_fn2, merged_source_sink_in, csv_merged, freq='infer', how='left')

schimpy.schism_sources_sinks.concat_source_sink_yaml(yaml_fn1, yaml_fn2, new_yaml)

schimpy.schism_sources_sinks.concat_vsource_sink_csv(csv_fn1, csv_fn2, merged_source_sink_in, csv_type, csv_merged, freq='infer', how='left')

Concatenate source and sink files

Parameters:

csv_fn1STR: Filename of the 1st dated vsource.csv or vsink.csv
csv_fn2STR: Filename of the 2nd dated vsource.csv or vsink.csv
merged_source_sink_inSTR: Filename of source_sink.in or source_sink.yaml
csv_typeSTR: Indicate if the files are “sources” or “sinks”
csv_mergedSTR: Output merged csv filename
freqSTR, optional: Frequency for the output csv file. The default is ‘infer’.
howSTR, optional: Options see pandas.join(). The default is ‘left’.

Returns:

None.

Raises:

NotImplementedError: DESCRIPTION.

schimpy.schism_sources_sinks.csv2yaml(source_csv, source_yaml)

Converting from source csv to source yaml file

Parameters:

source_csvCSV FILENAME: DESCRIPTION.
source_yamlYAML FILENAME: DESCRIPTION.

Returns:

None

schimpy.schism_sources_sinks.read_source_sink_csv(csv_fn)

schimpy.schism_sources_sinks.read_source_sink_in(source_sink_in)

Parse source sink.in file

Parameters:

source_sink_inSTR: source_sink.in
Returns
——-
source_dfPANDAS DATAFRAME: a dataframe of source names
sink_dfTYPE: a dataframe of sink names

schimpy.schism_sources_sinks.read_source_sink_th(th_fn, source_or_sink_df)

Read source_sink.th file

Parameters:

th_fnSTR: *.th file
source_or_sink_dfPANDAS DATAFRAME: source_df or sink_df produced by read_source_sink_in.

Returns:

thPANDAS DATAFRAME: source or sink data frame with time series data of T, S and other variables

schimpy.schism_sources_sinks.read_source_sink_yaml(yaml_fn)

Read source sink yaml file

Parameters:

yaml_fnstr: source_sink.yaml filename.

Returns:

df_sourcesPANDAS dataframe: For sources
df_sinksPANDAS dataframe: For sinks

schimpy.schism_sources_sinks.unsorted_unique(a)

Find unique elements with no sorting

np.unique automatically sorts the elements. This function performs unique without sorting.

Parameters:

aList or array: Input array

Returns:

a_uniquearray: Unsorted unique array

schimpy.schism_sources_sinks.write_source_sink_csv(th, csv_fn)

schimpy.schism_sources_sinks.write_source_sink_in(source_sink_yaml, hgrid_fn, source_sink_in='source_sink.in')

Create source_sink.in based on hgrid and source_sink.yaml using the create_source_sink_in function in schimpy preprocessor

Parameters:

source_sink_yamlSTR: Filename for source_sink.yaml
hgrid_fnSTR: schism hgrid.gr3
source_sink_inSTR, optional: Filename for source_sink.in. The default is ‘source_sink.in’.

Returns:

None.

schimpy.schism_sources_sinks.write_source_sink_yaml(df_sources, df_sinks, yaml_fn)

Write source sink to yaml

Parameters:

df_sourcesPANDAS dataframe: with colums:[‘x’,’y’]
df_sinksTYPE: DESCRIPTION.
yaml_fnTYPE: DESCRIPTION.

Returns:

None.

schimpy.schism_sources_sinks.yaml2csv(source_yaml, source_csv)

Converting source yaml file to source csv file

Parameters:

source_yaml :YAML FILENAME: DESCRIPTION.
source_csvCSV FILENAME: DESCRIPTION.

Returns:

None.

schimpy.schism_sources_sinks.yaml2df(source_yaml)

Converting source yaml file to pandas dataframe

Parameters:

source_yaml :YAML FILENAME

Returns:

pandas dataframe

schimpy.schism_structure module

class schimpy.schism_structure.SchismStructure

Bases: object

A class to hold structure information

Attributes:

coords
n_duplicate
name
node_pairs
properties
property_names
reference
reference_pair
type
use_timeseries

Methods

n_node_pairs

property coords

property n_duplicate

n_node_pairs()

property name

property node_pairs

property properties

property property_names

property reference

property reference_pair

property type

property use_timeseries

class schimpy.schism_structure.SchismStructureIO(input)

Bases: BaseIO

A class to manage hydraulic structure I/O files

Attributes:

linecounter

Methods

`read`(fname)	Read in 'hydraulics.in' file.
`write`([fname])	Write out 'hydraulics.in' file.

read(fname): Read in ‘hydraulics.in’ file.

write(fname='hydraulics.in'): Write out ‘hydraulics.in’ file.

schimpy.schism_vertical_mesh module

SchismVerticalMesh class with a reader

schimpy.schism_vertical_mesh.read_vmesh(fpath_vmesh, vgrid_version=None): Read a vgrid file

schimpy.schism_yaml module

A customized version of YAML parser for SCHISM It stores document in an ordered dict and supports variable substitution.

class schimpy.schism_yaml.ArgumentParserYaml(prog=None, usage=None, description=None, epilog=None, version=None, parents=[], formatter_class=<class 'argparse.HelpFormatter'>, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True)

Bases: ArgumentParser

Extended parser to handle YAML file as file input for ArgumentParser. If a file input given with ‘fromfile_prefix_chars’ has a YAML extension, ‘.yaml’, it will be handled as optional pairs for ArgumentParser. For example, ‘script.py’ can use a YAML file for an input file of ArgumentParser as follow: parser = schism_yaml.ArgumentParserYaml(fromfile_prefix_chars=’@’) parser.parse_arg()

$script.py @args.yaml

And when ‘args.yaml’ contains: input1: 1 input2: 2 3

it has the same effect as $script.py –input1 1 –input2 2 3

Methods

`add_argument`(add_argument)
`add_subparsers`(**kwargs)
`error`(message)	Prints a usage message incorporating the message to stderr and exits.
`exit`([status, message])
`format_usage`()
`parse_args`([args, namespace])
`print_usage`([file])
`register`(registry_name, value, object)
`set_defaults`(**kwargs)

add_argument_group
add_mutually_exclusive_group
convert_arg_line_to_args
format_help
get_default
parse_intermixed_args
parse_known_args
parse_known_intermixed_args
print_help

class schimpy.schism_yaml.YamlAction(option_strings, dest, nargs=None, **kwargs)

Bases: Action

Custom action to parse YAML files for argparse. This action reads in simple pairs of data from a YAML file, and feeds them to the parser. A YAML file must be a list of pairs without multiple levels of tree. Example: parser.add_argument(”–yaml”, action=YamlAction)

Methods

__call__(parser, namespace, values[, ...])

Call self as a function.

format_usage

schimpy.schism_yaml.dump(data, stream=None, Dumper=<class 'yaml.dumper.Dumper'>, **kwds): Serialize a Python object into a YAML stream. If stream is None, return the produced string instead.

schimpy.schism_yaml.load(stream, envvar=None): Load a schism YAML

schimpy.separate_species module

Separation of tidal data into species The key function in this module is separate_species, which decomposes tides into subtidal, diurnal, semidiurnal and noise components. A demo function is also provided that reads tide series (6min intervl) from input files, seperates the species, writes results and optionally plots an example

schimpy.separate_species.create_arg_parser()

schimpy.separate_species.main()

schimpy.separate_species.plot_result(ts, ts_semi, ts_diurnal, ts_sub_tide, station)

schimpy.separate_species.run_example(): This is the data for the example. Note that you want the data to be at least 4 days longer than the desired output

schimpy.separate_species.separate_species(ts, noise_thresh_min=40)

Separate species into subtidal, diurnal, semidiurnal and noise components

Input:: ts: timeseries to be decomposed into species, assumed to be at six minute intervals. The filters used have long lenghts, so avoid missing data and allow for four extra days worth of data on each end.
Output:: four regular time series, representing subtidal, diurnal, semi-diurnal and noise

schimpy.separate_species.write_th(filename, ts_output): This works fine for fairly big series

schimpy.simulation_timing module

schimpy.simulation_timing.create_arg_parser()

schimpy.simulation_timing.schism_timing(workdir, start=1, end=None, block_days=1.0)

schimpy.small_areas module

schimpy.small_areas.create_arg_parser(): Create ArgumentParser

schimpy.small_areas.main()

schimpy.small_areas.small_areas(mesh, warn=10.0, fail=1.0, logger=None, write_out_smalls=False, prepro_output_dir='./')

schimpy.sms2gr3 module

Manage conversion from SMS 2dm format to gr3. Some material borrowed @author: snegusse

class schimpy.sms2gr3.Boundary(name, btype, nodestring): Bases: object

schimpy.sms2gr3.addnode(list)

schimpy.sms2gr3.convert_2dm(file, outfile=None, elev2depth=False, logger=None)

schimpy.sms2gr3.create_arg_parser()

schimpy.split_quad module

PoC of quad splitting

schimpy.split_quad.split_all_quads(mesh)

Split all quad elements into triangular ones and return a new triangular mesh. This function maintains the original node indices. Currently this function does not add boundary information to the new mesh.

Parameters:

mesh: SchismMesh: a mesh with elements to split

Returns:

SchismMesh: A new triangular mesh. It does not contain any extra information, e.g. boundary information.

schimpy.stacked_dem_fill module

Routines to fill elevation (or other scalar) values at points from a prioritized list of rasters

schimpy.stacked_dem_fill.ParseType(type)

schimpy.stacked_dem_fill.bilinear(points, gt, raster): Bilinear interpolated point using data on raster points: npoint x 3 array of (x,y,z points) gt: geotransform information from gdal raster: the data

schimpy.stacked_dem_fill.create_arg_parser()

schimpy.stacked_dem_fill.create_dem_sampler(dem_list: str | List[str], cache_dir: str = './dem_cache', q: float = 1e-06)

Create a DEM sampler dem_sampler(xy) with disk caching.

The cache key includes: - The list of DEM source names (from the YAML or the provided list). - A daily stamp (YYYYMMDD) to force refresh at least daily. - A compact signature of the request batch: length, quantized centroid, and

quantized bounding box (min/max) of XY.

Parameters:

dem_liststr or list of str: Either a YAML file path consumable by stacked_dem_fill() or a list of DEM file paths.
cache_dirstr, optional: Directory for diskcache storage, by default "./dem_cache".
qfloat, optional: Quantization (meters) for the request signature, by default 1e-6.

Returns:

callable: dem_sampler(points_xy) mapping (k,2) XY→depth(+down) array.

schimpy.stacked_dem_fill.filelist_main(demlistfile, pointlistfile, out_dir='./', sep=''): higher level driver routine that parses the names of the DEMs from demfilelist points ( x,y or x,y,z ) from pointlistfile

schimpy.stacked_dem_fill.fill_2dm(infile, outfile, files, na_fill=2.0)

schimpy.stacked_dem_fill.fill_gr3(infile, outfile, files, elev2depth=True, na_fill=2.0)

schimpy.stacked_dem_fill.main()

schimpy.stacked_dem_fill.stacked_dem_fill(files, points, out_dir, values=None, negate=False, require_all=True, na_fill=None)

Fill values at an array of points using bilinear interpolation from a prioritized stack of DEMs. This function manages prioritization of the DEMs, gradually filling points that are still marked as nan. Uses a cache to speed up repeated queries.

Parameters:

fileslist of str: List of DEM file paths. Existence is checked; raises ValueError if any file is missing.
pointsnp.ndarray: Numpy array of shape (n_points, 2) containing (x, y) coordinates for interpolation.
out_dirstr or Path: Directory to write output files and cache.
valuesnp.ndarray or None, optional: Optional array of initial values at each point. If provided, must be same length as points. Points with NaN values will be filled.
negatebool, optional: If True, output values will be negated (e.g., convert elevation to depth).
require_allbool, optional: If True, raises ValueError if the DEMs do not cover all points. In either case, a file dem_misses.txt is created or overwritten with locations of uncovered points.
na_fillfloat or None, optional: Value to substitute for points that remain NaN after all DEMs are processed. If require_all is True, na_fill must be None.

Returns:

np.ndarray: Array of values at the input points, filled from the DEMs.

Raises:

ValueError: If any DEM file does not exist, or if require_all is True and not all points are covered.

schimpy.stacked_dem_fill.test_main()

schimpy.station module

schimpy.station.convert_db_station_in(outfile='station.in', stationdb=None, sublocdb=None, station_request='all', default=-0.5)

schimpy.station.convert_stations(input, output, write_sta_var='all')

Read a station shapefile/.in file and write to a .in/shapefile

Parameters:

inputfname: Path to input station.in style file or station.shp style file with station id, x, y, z, name and subloc fields
outputfname: Path to input station.in style file or station.shp style file with station id, x, y, z, name and subloc fields
write_sta_var‘all’ or list(str): List of variables to put in output request from the choices ‘elev’, ‘air pressure’, ‘wind_x’, ‘wind_y’, ‘temp’, ‘salt’, ‘u’, ‘v’, ‘w’ or ‘all’ to include them all

Returns:

ResultDataFrame: DataFrame with hierarchical index (id,subloc) and columns x,y,z,name

schimpy.station.create_arg_parser(): Create an argument parser

schimpy.station.example()

schimpy.station.flux_stations_from_yaml(inp): Retrieve station id of fluxlines from yaml file or content

schimpy.station.main(): A main function to convert polygon files

schimpy.station.merge_station_subloc(station_dbase, station_subloc, default_z)

Merge BayDeltaSCHISM station database with subloc file, producing the union of all stations and sublocs including a default entry for stations with no subloc entry

Parameters:

station_dbaseDataFrame: This should be the input that has only the station id as an index and includes other metadata like x,y,
station_sublocDataFrame: This should have (id,subloc) as an index

Returns:

ResultDataFrame: DataFrame that links the information.

schimpy.station.read_flux_out(fpath, names, reftime)

Read fluxes from a SCHISM flux.out file

Parameters:

fpathstr
Path to the file
namesstr
name of file that contains names of flux areas, typically something like flow_xsects.yaml
reftimestr
start of simulation, against which relative times will be calculated

schimpy.station.read_obs_links(fpath): Read an obs_links csv file which has comma as delimiter and (id,subloc,variable) as index

schimpy.station.read_pointstrings(fpath)

schimpy.station.read_staout(fname, station_infile, reftime, ret_station_in=False, multi=False, elim_default=False, time_unit='s')

Read a SCHISM staout_* file into a pandas DataFrame

Parameters:

fpathfname: Path to input staout file or a variable name in [“elev”, “air pressure”, “wind_x”, “wind_y”, “temp”, “salt”, “u”, “v”, “w”] whose 1-index will be mapped to a name like staout_1 for elev
station_infilestr or DataFrame: Path to station.in file or DataFrame from read_station_in
reftimeTimestampe: Start of simulation, time basis for staout file elapse time
ret_station_inbool: Return station_in DataFrame for use, which may speed reading of a second file
multibool: Should the returned data have a multi index for the column with location and sublocation. If False the two are collapsed
elim_defaultbool: If the MultiIndex is collapsed, stations with subloc “default” will be collapsed. Eg. (“CLC”,”default”) becomes “CLC_default”
time_unitstring: Convertible to pandas frequency string, this is the timestamp of the file.

Returns:

ResultDataFrame: DataFrame with hierarchical index (id,subloc) and columns representing the staout data (collapsed as described above

Examples

>>> staout1,station_in = read_staout("staout_1","station.in",reftime=pd.Timestamp(2009,2,10),
                             ret_station_in = True,multi=False,elim_default=True)
>>> staout6 = read_staout("staout_6",station_in,reftime=pd.Timestamp(2009,2,10),multi=False,elim_default=True)

schimpy.station.read_station_dbase(fpath)

Read a BayDeltaSCHISM station data base csv file into a pandas DataFrame

The BayDelta SCHISM format is open, but expects these columns: index x y z ! id subloc “Name”

Parameters:

fpathfname: Path to input dbase style file

Returns:

ResultDataFrame: DataFrame with hierarchical index (id,subloc) and columns x,y,z,name

schimpy.station.read_station_in(fpath)

Read a SCHISM station.in file into a pandas DataFrame

Note

This only reads the tabular part, and assumes the BayDelta SCHISM format with columns: index x y z ! id subloc “Name”

Note that there is no header and the delimiter is a space. Also note that the text beginning with ! is extra BayDeltaSCHISM extra metadata, not required for vanilla SCHISM

Parameters:

fpathfname: Path to input station.in style file

Returns:

ResultDataFrame: DataFrame with hierarchical index (id,subloc) and columns x,y,z,name

schimpy.station.read_station_out(fpath_base, stationinfo, var=None, start=None)

schimpy.station.read_station_shp(fpath, pop_xy=True)

Read a shapefile and convert into a pandas DataFrame

Parameters:

fpathfname: Path to input point shapefile - has station id, x, y, z, name and subloc labels (id is the station id, index will be autogenerated)
pop_xybool: Repopulate the x & y fields with point coordinates?

Returns:

ResultDataFrame: DataFrame that has station id, x, y, z, name and subloc labels (id is the station id, index will be autogenerated)

schimpy.station.read_station_subloc(fpath)

Read a BayDeltaSCHISM station_sublocs.csv file into a pandas DataFrame

The BayDelta SCHISM format has a header and uses “,” as the delimiter and has these columns: id,subloc,z

The id is the station id, which is the key that joins this file to the station database. ‘subloc’ is a label that describes the sublocation or subloc and z is the actual elevation of the instrument

Example might be: id,subloc,z 12345,upper,-0.5

Other columns are allowed, but this will commonly merged with the station database file so we avoid column names like ‘name’ that might collide

Parameters:

fpathfname: Path to input station.in style file

Returns:

ResultDataFrame: DataFrame with hierarchical index (id,subloc) and data column z

schimpy.station.staout_name(var)

schimpy.station.station_names_from_file(fpath)

schimpy.station.station_subset(fpath, run_start, locs, extract_freq, convert=None, stationfile=None, isflux='infer', miss='raise')

Extract a subset of stations from an staout file or flux.out file

Parameters:

fpathstr

Path to the output file to be read

run_startpd.Timestamp

Start time (reference time) for the simulation elapsed time

locspd.DataFrame or str

A DataFrame with rows specifying the data to subset or a string that is the path to such a file. There are a few options. Minimally this file should have either one column called “station_id” or one called “id” and another called “subloc”. If you use station_id, it should be an underscore-connected combination of id and subloc which should be unique, and this will be the treatment of the output. of the station. If you use “subloc” you can use “default” leave the subloc column blank. You can also use another optional column called “alias” and this will become the label used.

extract_freqstr or pd.tseries.TimeOffset: Frequency to extract. This allows some economies if you want, say, 15min data. Use pandas freq string such as ‘15T’ for 15min
convert: str or function: A small number of conversions are supported (“ft”, “ec” for uS/cm, “cfs” for flow)
stationfilestr: Name of station file such as station.in. In the case of flow this will be a yaml file or fluxflag.prop file produced by our preprocessing system. If you leave this None, ‘station.in’ in the same directory as the output file will be assumed for staout files. For flow, a string must be supplied but will be tested first in the directory of execution and then side-by-side in that order.
isflux‘infer’ | True | False: Is the request for flux.out?
miss‘raise’ | ‘drop’ | ‘nan’: What to do when a requested station_id does not exist. The default, raise, helps station lists from growing faulty. ‘drop’ will ignore the column and ‘nan’ will return nans for the column.

Returns:

ResultDataFrame: DataFrame that returns the converted and subsetted data. Column names will be the ids unless ‘alias’ is provided in locs, in which case those names will be swapped in.

schimpy.station.station_subset_multidir(dirs, staoutfile, run_start, locs, extract_freq, convert, stationfile=None, names=None, isflux='infer', miss='raise')

Extract a subset of stations from an staout file or flux.out file across a list of directories

Parameters:

dirslist(str)

List of directories. The output dataframe will have a column multindex (dir,station_id) where dir is the directory of the output.

fpathstr

Path to the output file to be read

run_startpd.Timestamp

Start time (reference time) for the simulation elapsed time

locspd.DataFrame or str

A DataFrame with rows specifying the data to subset or a string that is the path to such a file. There are a few options for staout station files. Minimally this file should have either one column called “station_id” or one called “id” and another called “subloc”. If you use station_id, it should be an underscore-connected combination of id and subloc and this will be the index treatment of the output. Flux files only have the station_id option. If you use “subloc” you can use “default” leave the subloc column blank. You can also include another optional column called “alias” and this will become the label used.

extract_freqstr or pd.tseries.TimeOffset: Frequency to extract … this allows some economies if you want, say, 15min data. Use pandas freq string such as ‘15T’ for 15min
convert: str or function: A small number of conversions are supported (“ft”, “ec” for uS/cm, “cfs” for flow)
stationfilestr: Name or list of station file such as station.in. You can provide a list of the same length as dirs or a single value which will be assumed to be appropriate for all the directories. In the case of station.in, you can use None and ‘station.in’ in each directory will be assumed for staout files. For flow, a string (yaml file) must be supplied but will be tested first in the directory of execution and then side-by-side in that order.
isflux‘infer’ | True | False: Is the request for flux.out?
miss‘raise’ | ‘drop’ | ‘nan’: What to do when a requested station_id does not exist. The default, raise, helps station lists from growing faulty. ‘drop’ will ignore the column and ‘nan’ will return nans for the column.

Returns:

ResultDataFrame: DataFrame that returns the converted and subsetted data. Column names will be the ids unless ‘alias’ is provided in locs, in which case those names will be swapped in.

schimpy.station.u(x)

schimpy.station.write_pointstrings(fpath, station_in, request='all')

schimpy.station.write_station_in(fpath, station_in, request=None)

Write a SCHISM station.in file given a pandas DataFrame of metadata

Parameters:

fpathfname: Path to output station.in file
station_inDataFrame: DataFrame that has station id, x, y, z, name and subloc labels (id is the station id, index will be autogenerated)
request‘all’ or list(str): List of variables to put in output request from the choices ‘elev’, ‘air pressure’, ‘wind_x’, ‘wind_y’, ‘temp’, ‘salt’, ‘u’, ‘v’, ‘w’ or ‘all’ to include them all

schimpy.station.write_station_shp(fpath, station_in)

Write a point Shapefile file given a pandas DataFrame of metadata

Parameters:

fpathfname: Path to output station.in file
station_inDataFrame: DataFrame that has station id, x, y, z, name and subloc labels (id is the station id, index will be autogenerated)

schimpy.subset_schism_output module

Created on Wed Oct 27 11:41:00 2021

@author: babban

schimpy.subset_schism_output.create_arg_parser(): Create an argument parser return: argparse.ArgumentParser

schimpy.subset_schism_output.create_partition(mesh, polygons, enforce_exact=False)

Takes a mesh and list of polygons and partitions according to where the centroids (mesh.centroids in schimpy) fall. Parameters ———— mesh : schimpy.SchismMesh The mesh to partition

polygons : Polygons (parsed from shape file or yaml into SCHIMPY

enforce_exact: bool Requires a unique, complete partition. Initially not implemented for True

Produces meshes and dicitonary(?) maps of local_to_global and global_to_local. (tuple or class)

schimpy.subset_schism_output.partition_schout(in_Schout_Files, partition_shp, combined=True, exclude=[], transform={'salt_depth_ave': ('depth_ave', 'salt')})

Partitions schout binary output files (start with combined) into a set of smaller schout files corresponding to each partition.

Initially implementation will be nodal variables but ultimately native centered (edge centered velocity, prism centered tracers).

Transform is an opportunity to generate new variables that are well determined with the data from one time step, but not based on time-stenciled operations.

Exclude would be an opportunity to prune variables not desired by dropping variables, although certain variables that are required for well-formedness (zcor, wet-dry) and visualization would not be “excludable” so exclude = “all_data” could be used to exclude all but the non-excludable. No output, but side effect is production of files. p0000/schout_1.nc.

schimpy.subset_schism_output.partition_scribeio(partition_shp, variables=['out2d', 'zCoordinates', 'salinity', 'horizontalVelX', 'horizontalVelY', 'verticalVelocity'])

Partitioning scribio format output files into a set of smaller files corresponding to each partitions. This function will loop all the schism scribeIO output files that contains varaibles defined by the input variables, and result subset outputs will be saved to a subset subdirectory.

Parameters:

partition_shparcgis shape file
shape files contains polygons where subset of output desried
variableslist of str
Output variables to be subsetted

schimpy.subset_schism_output.records(file)

schimpy.subset_schism_output.subset_schism_output()

schimpy.subset_schism_output.subset_schism_scribeIO_output(partition_shp)

schimpy.subset_schism_output.write_global_local_maps(dest, global_local, local_global): writes maps out in the schism + visit format. Note that the global owner of a shared node is the lowest rank that contains it.

schimpy.three_point_linear_norm module

class schimpy.three_point_linear_norm.ThreePointLinearNorm(linthresh, vmin=None, vmax=None, clip=False)

Bases: Normalize

Attributes:

clip
vmax
vmin

Methods

`__call__`(value[, clip])	Normalize the data and return the normalized data.
`autoscale`(A)	Set vmin, vmax to min, max of A.
`autoscale_None`(A)	autoscale only None-valued vmin or vmax
`inverse`(value)	Maps the normalized value (i.e., index in the colormap) back to image data value.
`process_value`(value)	Homogenize the input value for easy and efficient normalization.
`scaled`()	return true if vmin and vmax set

autoscale(A): Set vmin, vmax to min, max of A.

autoscale_None(A): autoscale only None-valued vmin or vmax

inverse(value)

Maps the normalized value (i.e., index in the colormap) back to image data value.

Parameters:

value: Normalized value.

scaled(): return true if vmin and vmax set

schimpy.trimesh module

This is a class to hold an unstructured triangular mesh.

Lots of the codes are copied from Rusty Chris Collerman’s trigrid program and modified a bit to meet our needs.

Prerequisite: Numpy, rtree package, and libspatialindex for rtree

schimpy.trimesh.BoundaryTypes: alias of Enum

schimpy.trimesh.EdgeTypes: alias of Enum

class schimpy.trimesh.TriMesh

Bases: object

Class that holds a triangular mesh information

Attributes:

edges: Array of edges
elems: Array of node indices of each element.
nodes: Node array consisting of three-dimensional coordinates of each node.

Methods

`add_boundary`(nodes, btype)	Add boundary types to an edge with the given array of node indices
`allocate`(n_elems, n_nodes)	Allocate memory for nodes and elems
`build_edgecenters`()	Build centers of sides
`build_edges_from_elems`()	This is a function copied and modified from TriGrid
`deepcopy`(mesh)	Deep copy mesh information.
`element2edges`(elem_i)	Get edge indices from the give element index elem_i = the element index return = generator of found edge indices
`find_closest_elems`(pos[, count])	Find indices of the closet elems with the given position.
`find_closest_nodes`(pos[, count, boundary])	Returns the count closest nodes to the given node in 2D space.
`find_elem`(pos)	Find a element index from a coordinate pos = A coordinate (2D) return = element index
`find_elem_with_tolerance`(pos, tolerance)	Find a element index from a coordinate with some tolerance pos = A coordinate (2D) return = element index
`find_nodes_in_box`(box)	Find nodse in a bounding box box = a numpy array of bounding box, [x_min, x_max, y_min, y_max] return = node indices
`get_edges_from_node`(node_i)	Get edge indices related to node_i
`get_elems_i_from_node`(node_i)	Get neighboring elements indexes of a node, so-called a ball.
`get_neighbor_nodes`(node_i)	Get neighboring node indices from the given node index.
`is_elem_on_boundary`(elem_i)	Check if the given element with index elem_i is on the boundary
`n_edges`()	Get the total number of edges.
`n_elems`()	Get the total nuber of elems.
`n_nodes`()	Get the total number of nodes.
`set_elem`(index, connectivities)	Set element connectivity information.
`set_node`(index, coords)	Set one node information.
`shortest_path`(n1, n2[, boundary_only])	dijkstra on the edge graph from n1 to n2.
`trim_to_left`(paths)	Given a path, trim all elems to the left of it.

add_boundary(nodes, btype): Add boundary types to an edge with the given array of node indices

allocate(n_elems, n_nodes)

Allocate memory for nodes and elems

Parameters:

n_elems: integer: Total number of elems
n_nodes: integer: Total number of nodes

build_edgecenters()

Build centers of sides

Returns:

numpy.array: list of side centers

build_edges_from_elems(): This is a function copied and modified from TriGrid

deepcopy(mesh): Deep copy mesh information.

property edges

Array of edges

Getter:: Get the array of the edges.
Type:: Numpy integer array

element2edges(elem_i): Get edge indices from the give element index elem_i = the element index return = generator of found edge indices

property elems

Array of node indices of each element. The shape of the array is (# of elems, 3). It is assumed that all elems are triangular.

Getter:: Get the Numpy array of the node indices.
Type:: Numpy integer array

find_closest_elems(pos, count=1): Find indices of the closet elems with the given position. The distance is measured with the element mass center. All triangular elems is assumed. pos = position tuple return = element indices

find_closest_nodes(pos, count=1, boundary=False): Returns the count closest nodes to the given node in 2D space. pos = position count = # of nodes to retrieve boundary=1: only choose nodes on the boundary. Copied from TriGrid

find_elem(pos): Find a element index from a coordinate pos = A coordinate (2D) return = element index

find_elem_with_tolerance(pos, tolerance): Find a element index from a coordinate with some tolerance pos = A coordinate (2D) return = element index

find_nodes_in_box(box): Find nodse in a bounding box box = a numpy array of bounding box, [x_min, x_max, y_min, y_max] return = node indices

get_edges_from_node(node_i): Get edge indices related to node_i

get_elems_i_from_node(node_i): Get neighboring elements indexes of a node, so-called a ball.

get_neighbor_nodes(node_i): Get neighboring node indices from the given node index.

is_elem_on_boundary(elem_i)

Check if the given element with index elem_i is on the boundary

Parameters:

elem_iint: element index

Returns:

is_on_boundarybool
True if the element is on the boundary, otherwise False

n_edges(): Get the total number of edges.

n_elems(): Get the total nuber of elems.

n_nodes(): Get the total number of nodes.

property nodes

Node array consisting of three-dimensional coordinates of each node. The shape of the array is (# of nodes, 3)

Getter:: Get the array of the nodes.
Type:: Numpy float array.

set_elem(index, connectivities)

Set element connectivity information. Memory for elems must be allocated already.

Parameters:

index: integer: Zero-based element index
connectivities: Numpy array: a Numpy array of element connectivity, which means node indies in the element.

set_node(index, coords)

Set one node information. Memory for nodes must be allocated already.

Parameters:

index: integer: Zero-based node index
coords: Numpy array: a Numpy array of node coordinates

shortest_path(n1, n2, boundary_only=False): dijkstra on the edge graph from n1 to n2. copied and modified form Rusty’s code. n1 = node_i for one end of the path n2 = node_i for the other end boundary_only = limit search to edges on the boundary (have a -1 for element2)

trim_to_left(paths): Given a path, trim all elems to the left of it. This fuction is lifted and modified slightly from Rusty’s code.

schimpy.trimesh.enum(**enums): A enum type definition. Copied from http://stackoverflow.com/questions/36932/how-can-i-represent-an-enum-in-python

schimpy.triquadmesh module

This is a class to hold an unstructured triangular and quad mesh for SCHISM copied and modified from Rusty Holleman’s trigrid.

Prerequisite: Numpy, rtree package, and libspatialindex for rtree

schimpy.triquadmesh.BoundaryType: alias of Enum

schimpy.triquadmesh.EdgeType: alias of Enum

schimpy.triquadmesh.NodeType: alias of Enum

class schimpy.triquadmesh.TriQuadMesh(logger=None)

Bases: object

Class that holds a triangular and quadrilateral mesh information

Attributes:

edges: Get the array of edges
elems: Array of node indexes of all elements.
node2elems
nodes: Node array consisting of three-dimensional coordinates of each node.

Methods

`add_boundary`(nodes, btype)	Add boundary types to an edge with the given array of node indexes
`allocate`(n_elems, n_nodes)	Allocate memory for nodes and elems
`build_edgecenters`()	Build centers of sides
`build_edges_from_elems`([shift])	Build edge array from the elements.
`build_elem_balls`()	Build balls of elements around each node
`compare`(mesh)	Compare the mesh with another
`elem`(elem_i)	Get connectivity of an element
`element2edges`(elem_i)	Get edge indexes of the give element index
`find_closest_elems`(pos[, count])	Find indexes of the closet elems with the given position.
`find_closest_nodes`(pos[, count, boundary])	Returns the count closest nodes to the given node in 2D space.
`find_edge`(nodes[, direction])	Find an edge index with the two given node indexes.
`find_elem`(pos)	Find a element index from a coordinate pos = A coordinate (2D) return = element index
`find_intersecting_elems_with_line`(line_segment)	Format of the line segment: start_x, start_y, end_x, end_y
`find_neighbors_on_segment`(line_segment)	Find elements on the line_segment and neighbors that are all to the left (downstream) Format of the line segment: start_x, start_y, end_x, end_y Returns a list of elements on the segment and a list of neighbors.
`find_nodes_in_box`(box)	Find nodes in a bounding box.
`get_edges_from_node`(node_i)	Get edge indexes related to node_i
`get_elems_i_from_node`(node_i)	Get the ball of elements around a node, node_i
`get_neighbor_nodes`(node_i)	Get neighboring node indexes from the given node index.
`is_elem_on_boundary`(elem_i)	Check if the given element with index elem_i is on the boundary
`mark_elem_deleted`(elem_i)	Mark an element as deleted or invalid.
`n_edges`()	Get the total number of edges.
`n_elems`()	Get the total number of elements.
`n_nodes`()	Get the total number of nodes.
`node`(node_i)	Selects a single node
`renumber`()	removes duplicate elems and nodes that are not referenced by any element, as well as elems that have been deleted (==-1) This function is lifted and modified slightly from Rusty's code.
`set_elem`(index, connectivity)	Set element connectivity information.
`set_node`(index, coords)	Set one node information.
`shortest_path`(n1, n2[, boundary_only])	Dijkstra on the edge graph from node n1 to n2.
`trim_elems`(paths[, left])	Given a path, trim all elems to the left of it.

add_boundary(nodes, btype): Add boundary types to an edge with the given array of node indexes

allocate(n_elems, n_nodes)

Allocate memory for nodes and elems

Parameters:

n_elems: int: Total number of elems
n_nodes: int: Total number of nodes

build_edgecenters()

Build centers of sides

Returns:

numpy.array: list of side centers

build_edges_from_elems(shift=1)

Build edge array from the elements.

Parameters:

shift:: shift of indexing in edged building. It is introduce to keep the ordering of edges in line with SCHISM Mesh.

build_elem_balls(): Build balls of elements around each node

compare(mesh)

Compare the mesh with another

Parameters:

mesh: triquadmesh.TriQuadMesh: a mesh to compare

Returns:

boolean: True if they have identical node and element array

property edges

Get the array of edges

Getter:: Get the array of the edges.
Type:: Numpy integer array

elem(elem_i)

Get connectivity of an element

Parameters:

elem_i: int: element index

Returns:

Numpy int32 array: connectivity of the element (node indexes of the element) None, if the element is marked as deleted

element2edges(elem_i)

Get edge indexes of the give element index

Parameters:

elem_i: int: the element index
Returns
——-
array of int: edge indexes of the element

property elems

Array of node indexes of all elements. The shape of the array is (# of elems, 5).

Returns:

list of Numpy integer array: list of node indexes for all elements

find_closest_elems(pos, count=1)

Find indexes of the closet elems with the given position. The distance is measured with the element mass center. All triangular elems is assumed.

Parameters:

pos: array-like: 2D position

Returns:

int or list: element index or indexes

find_closest_nodes(pos, count=1, boundary=False)

Returns the count closest nodes to the given node in 2D space. Roughly copied from trigrid

Parameters:

pos: array-like: position
count: int: # of nodes to retrieve
boundary: int 1: only choose nodes on the boundary.

Returns:

int or list: nearest node indexes

find_edge(nodes, direction=False)

Find an edge index with the two given node indexes.

Parameters:

nodes: array-like: two node indexes
direction:: match the ordering of the nodes when an edge is found.

Returns:

int: an edge index, None if not found

find_elem(pos): Find a element index from a coordinate pos = A coordinate (2D) return = element index

find_intersecting_elems_with_line(line_segment): Format of the line segment: start_x, start_y, end_x, end_y

find_neighbors_on_segment(line_segment): Find elements on the line_segment and neighbors that are all to the left (downstream) Format of the line segment: start_x, start_y, end_x, end_y Returns a list of elements on the segment and a list of neighbors. The lists are not guarateed to be ordered spatially

find_nodes_in_box(box)

Find nodes in a bounding box. Note that the box is not interleaved. The backend is based on R-tree.

Parameters:

box: array-like: array of bounding box, [x_min, x_max, y_min, y_max]

Returns:

set: node indexes

get_edges_from_node(node_i)

Get edge indexes related to node_i

Parameters:

node_i: int: Node index (zero-based)
Returns
——-
list: a list of edges

get_elems_i_from_node(node_i)

Get the ball of elements around a node, node_i

Parameters:

node_i: int: node index (zero-based)

Returns:

set: set of element indexes

get_neighbor_nodes(node_i): Get neighboring node indexes from the given node index.

is_elem_on_boundary(elem_i)

Check if the given element with index elem_i is on the boundary

Parameters:

elem_iint: element index

Returns:

is_on_boundarybool
True if the element is on the boundary, otherwise False

mark_elem_deleted(elem_i)

Mark an element as deleted or invalid.

Parameters:

elem_i: int: element index to mark

n_edges(): Get the total number of edges.

n_elems(): Get the total number of elements.

n_nodes(): Get the total number of nodes.

node(node_i): Selects a single node

property node2elems

property nodes

Node array consisting of three-dimensional coordinates of each node. The shape of the array is (# of nodes, 3)

Getter:: Get the array of the nodes.
Type:: Numpy float array.

renumber()

removes duplicate elems and nodes that are not referenced by any element, as well as elems that have been deleted (==-1) This function is lifted and modified slightly from Rusty’s code.

Returns:

dict

{‘valid_elems’:new_elems, ‘pointmap’:old_indexes,: ‘valid_nodes’:active_nodes}

set_elem(index, connectivity)

Set element connectivity information. Memory for elems must be allocated already.

Parameters:

index: integer: Zero-based element index
connectivity: Numpy array: a Numpy array of element connectivity, which means node indexes in the element.

set_node(index, coords)

Set one node information. Memory for nodes must be allocated already.

Parameters:

index: integer: Zero-based node index
coords: Numpy array: a Numpy array of node coordinates

shortest_path(n1, n2, boundary_only=False)

Dijkstra on the edge graph from node n1 to n2. copied and modified form Rusty’s code. Keep in mind that the solution can be non-unique because there are multiple paths that have the same distances.

Parameters:

n1: int: node index for one end of the path
n2: int: node_i for the other end
boundary_only: boolean: limit search to edges on the boundary

Returns:

numpy.ndarray: shortest node indexes or None if it cannot be found

trim_elems(paths, left=None)

Given a path, trim all elems to the left of it. This function is lifted and modified slightly from Rusty’s code.

Parameters:

paths: array of integer array-like: arrays of cut paths in arrays of node indexes

schimpy.triquadmesh.enum(**enums)

A enum type definition

Copied from http://stackoverflow.com/questions/36932/how-can-i-represent-an-enum-in-python

schimpy.unit_conversions module

schimpy.vgrid_opt2 module

Package for optimising vgrid smoothness, shape and completeness

schimpy.vgrid_opt2.example()

schimpy.vgrid_opt2.fix_depth(zcor, zcornew, x)

schimpy.vgrid_opt2.gradient_matrix(mesh, sidedist2, sidemasked)

schimpy.vgrid_opt2.hess_base(xvar, zcorig, mesh, nlayer, ndx, eta, depth, gradmat, sidelen2, nodemasked, sidemasked, ata, dx2fac, curvewgt, foldwgt, foldfrac)

schimpy.vgrid_opt2.incr_grad(grad, i, k, val, ndx)

schimpy.vgrid_opt2.index_interior(mat, nodemasked, nlevel=None)

schimpy.vgrid_opt2.laplace2(mesh, nodemasked, sidemasked): produces a 2d matrix

schimpy.vgrid_opt2.mesh_opt(zcor, mesh, nlayer, ndx, eta, depth, gradmat, sidelen2, nodemasked, sidemasked, ata, dx2fac, curvewgt, foldwgt, foldfrac, href_hess, grad_hess, laplace_hess, maxiter=8000)

schimpy.vgrid_opt2.meshessp(xvar, p, zcorig, mesh, nlayer, ndx, eta, depth, gradmat, sidelen2, nodemasked, sidemasked, ata, dx2fac, curvewgt, foldwgt, foldfrac, href_hess, grad_hess, laplace_hess)

schimpy.vgrid_opt2.meshgrad(xvar, zcorig, mesh, nlayer, ndx, eta, depth, gradmat, sidelen2, nodemasked, sidemasked, ata, dx2fac, curvewgt, foldwgt, foldfrac, href_hess, grad_hess, laplace_hess)

schimpy.vgrid_opt2.meshobj(xvar, zcorig, mesh, nlayer, ndx, eta, depth, gradmat, sidelen2, nodemasked, sidemasked, ata, dx2fac, curvewgt, foldwgt, foldfrac, href_hess, grad_hess, laplace_hess)

schimpy.vgrid_opt2.smooth_heights(zcor, x, wgt=0.2)

schimpy.vgrid_opt2.targeth2inv(zbar, eta)

schimpy.vgrid_opt2.test_gradients()

schimpy.vgrid_opt2.test_vgrid_spacing(zcor, zcorig, nodemasked, foldfrac)

schimpy.vgrid_opt2.triweight(n)

schimpy.write_ts module

schimpy.write_ts.cdec_header(fname, ts, tz, var=None, unit=None)

Helper function to create a cdec-like header Requres some metadata like time zone, variable name and unit which will be pulled from series if omitted from input.

Parameters:

fname: str: Output file name or path
ts: :class:`~vtools.data.timeseries.TimeSeries`: The time series to be stored
tz: string: Time zone of data
var: string: Variable name
unit: string: Unit of the time series

Returns:

head: string: CDEC-style header

schimpy.write_ts.write_ts(ts, fname, dateformat='%Y-%m-%d %H:%M', fmt='%.2f', header=None, sep=',')

Estimate missing values within a time series by interpolation.

Parameters:

ts: :class:`~vtools.data.timeseries.TimeSeries`: The time series to be stored
fname: string: Output file name or path
dateformat: string: Date format compatible with datetime.datetime.strftime
fmt: string: Value format compatible withy numpy.savetxt
header: string: Header to add to top of file
sep: string: Delimieter for fields, often a space or comma

Returns:

Examples

Writing csv format with date format 2009-03-15 21:00 and space separated values

>>> write_ts(ts,"test.csv","%Y-%m-%d %H:%M","%.2f,%.2f","Datetime,u,v",",")

Write vtide format with same format and space separated values, this time taking advantage of defaults

>>> write_ts(ts,"test_vtide.dat",sep = " ")

Writing cdec format, with csv values and date and time separated. The header is generated with the cdec_header helper function

>>> head = cdec_header("practice.csv",ts,"PST","Wind Vel","m/s")
>>> write_ts(ts,"test_cdec.csv",CDECDATEFMT,"%.2f",header=head)