schimpy package

Submodules

schimpy.archive_ts module

Archive SCHISM time series outputs from station, flux and extracted output from a “study”.

Goals: 1. Allow outputs from multiple scenarios to be collected in one directory by adding labels to the name. 2. Translate from fortranesque format to csv with # comments and datetime indexes. 3. Assure that the datetimes are not affected by floating point precision of the time columns 4. Add scenario info as data so that origins can be identified and data can be concatenated.

schimpy.archive_ts.archive_flux(rundir, ardir, scenario_label, stationfile, scenario_data, runstart)

schimpy.archive_ts.archive_staout(rundir, ardir, scenario_label, scenario_data, staouts=None, stationfile='station.in', float_format='%.3f', time_unit='s', multi=False, elim_default=True, do_flux=False, time_sharded=False, runstart=None)

schimpy.archive_ts.archive_time_series(rundir, ardir, runstart, scenario_label=None, scenario_data={}, staouts={}, stationfile='station.in', time_sharded=False)

Archive time series from rundir/outputs to ardir

rundir/param.nml must point to a file with the correct run start

schimpy.archive_ts.create_arg_parser()

Create an argument parser return: argparse.ArgumentParser

schimpy.archive_ts.ex()

schimpy.archive_ts.get_ordered_files(loc, pat, time_sharded)

schimpy.archive_ts.infer_runstart(rundir)

Infer runstart based on param.nml in directory rundir

schimpy.archive_ts.main()

schimpy.archive_ts.main_hardwire()

schimpy.archive_ts.process_extracted_scalar(rundir, ardir, extract_data_file, variable, model_start, station_file, output_file)

Process extracted data into a time series

schimpy.archive_ts.shard_number(x)

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

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

schimpy.clip_beyond_subdomain module

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(is_test=False)

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

schimpy.combine_consume.create_arg_parser()

Create argument parser for

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.main()

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.main(input, output)

Function for converting line string files.

schimpy.convert_mesh module

schimpy.convert_points module

schimpy.convert_polygons module

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

schimpy.convert_polygons.main(input, output)

schimpy.convert_sav_class_to_number module

schimpy.create_mesh_n_levels module

schimpy.create_vgrid_lsc2 module

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

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

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

schimpy.grid_opt module

schimpy.hotstart_inventory module

schimpy.hotstart_inventory.create_arg_parser()

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

Create an inventory of existing hotstarts or expected hotstarts

Existing vs expected depends on whether workdir is an outputs or study dir.

Parameters:

startConvertible to Datetime

Start date of run. If None inferred from paramfile. Error if

dtfloat

dt in seconds, for instance perhaps 90s for clinic or 120s for tropic. This is needed to intepret the so-called iteration number in the hotstart labels which are really time step numbers.

workdirstr

Directory to inventory. If it is an outputs directory, the inventory

comprise existing hotstarts.

paramfilestr

Name of param.nml file, expected in workdir or workdir/.. If None, then both start and dt must be supplied. If all three are None, the name “param.nml” will be attempted

Returns:

Dataframe, if programatic, listing hotstarts. Should look like “Date, Iteration” pairs. CLI should print it out.

Notes

If the listing is done in the run dir, this will be the expected hotstarts. If it is in the outputs dir, it will be an inventory of existing hotstarts.

schimpy.hotstart_inventory.hotstart_inventory2(start, dt=90)

schimpy.hotstart_inventory.main()

schimpy.hrr3 module

adapted from pyschism, original work of Linlin Cui.

class schimpy.hrr3.AWSGrib2Inventory(start_date: datetime | None = 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_data(mesh, data, rate=0.05, iter_total=150)

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

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

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

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

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)

“ 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

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)

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.clip(args)

Clip file to dates

schimpy.model_time.create_arg_parser()

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

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

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.main()

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

schimpy.model_time.prune_dated(name)

schimpy.model_time.to_datetime(args)

Convert elapsed inputs to dated

schimpy.model_time.to_elapsed(args)

Convert dated inputs to elapsed times

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

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(*, dt, eco_class, ibc, ibtp, ihfskip, ipre, mdc2, msc2, nspool, ntracer_age, ntracer_gen, rnday, sed_class, name)

Bases: Parameterized

dt = 0.0

eco_class = 0

ibc = 0

ibtp = 0

ihfskip = 0

ipre = 0

mdc2 = 0

msc2 = 0

name = 'Core'

nspool = 0

ntracer_age = 0

ntracer_gen = 0

rnday = 0.0

sed_class = 0

class schimpy.params.HydroOutput(*, air_pressure, air_temperature, barotropic_pres_grad_xy, bottom_stress_xy, depth_avg_vel_xy, diffusivity, downward_longwave, dry_flag_node, elevation, evaporation_rate, 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, total_heat, turbulent_kinetic_ener, upward_longwave, vertical_vel_at_element, vertical_velocity, viscosity, water_density, wind_speed_xy, wind_stress_xy, z_coordinates, name)

Bases: OutControls

Class to specify which variables to output from the SCHISM model

Methods

from_iof_array
get_iof_array_names
to_iof_array

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

name = 'HydroOutput'

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(*, 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, name)

Bases: Parameterized

alphaw = 0.0

btrack_nudge = 0.009013

coricoef = 1.0

courant_weno = 0.8

cur_wwm = False

dfh0 = 0.0

dfv0 = 1.0

dramp = 1.0

dramp_ss = 60.0

drampbc = 1.0

drampwafo = 0.0

drampwind = 86400.0

dtb_max = 100.0

dtb_min = 1.0

dzb_min = 1e-05

eos_a = -0.1

eos_b = 1001.0

eps1_tvd_imp = 0.001

eps2_tvd_imp = 0.0001

epsilon1 = 1e-05

epsilon2 = 0.001

epsilon3 = 0.0001

flag_fib = 0

flag_ic = 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

gen_wsett = True

h0 = 1.0

h1_bcc = 1.0

h1_pp = 0.2

h2_bcc = 0.5

h2_pp = 1.0

h_bcc1 = 1.5

h_massconsv = 0.001

h_tvd = 2.0

hmin_airsea_ex = 0.01

hmin_man = 0.05

hmin_radstress = 0.1

hmin_salt_ex = 0.01

hvis_coef0 = 0.1

hw_depth = 15.0

hw_ratio = 1.2

i_hmin_airsea_ex = 1

i_hmin_salt_ex = 1

i_prtnftl_weno = 1

iadjust_mass_consv0 = 1

ibcc_mean = 0

ibdef = 10

ibtrack_test = 1

ic_elev = 0.0

icou_elfe_wwm = 0

ics = 0

ielad_weno = 0

ielm_transport = 0

ieos_pres = 0.0

ieos_type = 0

if_source = 2

iflux = 2

iflux_out_format = 0

iharind = 1

ihconsv = 0

ihdif = 0

ihhat = 0

ihorcon = 0

ihot = 0

ihydraulics = 0

iloadtide = 0

imm = 0

indvel = 0

inter_mom = 1

inu_elev = 1

inu_tr = 0

inu_uv = 1

inunfl = True

inv_atm_bnd = False

ip_weno = 0

ipre2 = 0

iprecip_off_bnd = 1

irouse_test = 0

isav = 0

isconsv = 0

ishapiro = 0

itr_met = 3

itransport_only = 0

itur = 0

iunder_deep = 0

iupwind_mom = 0

iwbl = 0

iwind_form = 1

iwindoff = 0

izonal5 = 0

kr_co = 0.5

lev_tr_source = 1

level_age = [-999.0]

loadtide_coef = 1.0

max_subcyc = 10

meth_sink = 2

mid = 'KL'

moitn0 = 0.1

mxitn0 = 5

nadv = 3

name = 'Opt'

nchi = 50

ncor = 1

niter_shap = 0

nquad = 5

nramp_elev = 0.0

nstep_ice = 0

nstep_wwm = 1

ntd_weno = 1

nu_sum_mult = 1.0

nws = 0

prmsl_ref = 1013.25

rearth_eq = 6378.137

rearth_pole = 6356.75

rho0 = 1000.0

rinflation_icm = 2.0

rlatitude = 47.5

rmaxvel = 2.0

rtol0 = 1e-06

s1_mxnbt = 0.0

s2_mxnbt = 0.0

sfea0 = 45

shapiro0 = 0.8

shorewafo = 0.0

shw = 0.025

slam0 = -124

slr_rate = 0.0

small_elad = 1e-06

stab = 'GA'

start_day = 1

start_hour = 0

start_month = 1

start_year = 2000

step_nu_tr = 0.001

tdmin_pp1 = 0.01

tdmin_pp2 = 0.001

thetai = 0.7

turbinj = False

turbinjds = 0.0

utc_start = 8

vclose_surf_frac = 0.0

vdmax_pp1 = 0.02

vdmax_pp2 = 0.01

vdmin_pp1 = 1e-05

vdmin_pp2 = 1e-05

velmin_btrack = 0.0001

vnf1 = 1

vnf2 = 1

vnh1 = 1

vnh2 = 0

wafo_obcramp = 1

wtiminc = 3600.0

xlsc0 = 1.0

class schimpy.params.OutControls(*, name)

Bases: Parameterized

Parameters controlling output

Methods

from_iof_array
get_iof_array_names
to_iof_array

from_iof_array(iof_array)

get_iof_array_names()

name = 'OutControls'

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(*, iof_age, iof_ana, iof_cos, iof_dvd, iof_eco, iof_fib, 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, iout_sta, nc_out, nhot, nhot_write, nspool_sta, name)

Bases: Parameterized

iof_age = False

iof_ana = False

iof_cos = False

iof_dvd = False

iof_eco = False

iof_fib = False

iof_gen = TracerGenOutput(name='TracerGenOutput00004', ntracer_gen=0)

iof_hydro = HydroOutput(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, name='HydroOutput00002', 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)

iof_ice = False

iof_icm_ba = False

iof_icm_cbp = False

iof_icm_core = False

iof_icm_dbg = False

iof_icm_ph = False

iof_icm_sav = False

iof_icm_sed = False

iof_icm_silica = False

iof_icm_veg = False

iof_icm_zb = False

iof_marsh = False

iof_sed = False

iof_sed2d = False

iof_ugrid = False

iof_wwm = WindWaveOutput(bottom_excursion_period=True, bottom_wave_period=True, charnock_coeff=True, continuous_peak_period=True, discrete_peak_direction=True, diss_rate_bott_friction=True, diss_rate_dep_breaking=True, diss_rate_vegetation=True, diss_rate_whitecapping=True, dominant_direction=True, energy_input_atmos=True, frictional_velocity=True, mean_dir_spreading=True, mean_wave_direction=True, mean_wave_length=True, mean_wave_number=True, mean_wave_period=True, name='WindWaveOutput00003', orbital_velocity=True, peak_group_vel=True, peak_n_factor=True, peak_period=True, peak_phase_vel=True, peak_spreading=True, peak_wave_length=True, peak_wave_number=True, rms_orbital_velocity=True, roller_diss_rate=True, roughness_length=True, sig_wave_height=True, tm_10=True, u_resell_number=True, wave_energy_dir_x=True, wave_energy_dir_y=True, zero_downcross_period=True)

iout_sta = 0

name = 'Schout'

nc_out = True

nhot = 0

nhot_write = 0

nspool_sta = 0

class schimpy.params.TracerGenOutput(*, ntracer_gen, name)

Bases: Parameterized

Methods

get_tracer_names

get_tracer_names()

name = 'TracerGenOutput'

ntracer_gen = 0

class schimpy.params.WindWaveOutput(*, 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, 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, u_resell_number, wave_energy_dir_x, wave_energy_dir_y, zero_downcross_period, name)

Bases: OutControls

A collection of parameters that define the wind wave outputs.

Methods

from_iof_array
get_iof_array_names
to_iof_array

bottom_excursion_period = True

bottom_wave_period = True

charnock_coeff = True

continuous_peak_period = True

discrete_peak_direction = True

diss_rate_bott_friction = True

diss_rate_dep_breaking = True

diss_rate_vegetation = True

diss_rate_whitecapping = True

dominant_direction = True

energy_input_atmos = True

frictional_velocity = True

mean_dir_spreading = True

mean_wave_direction = True

mean_wave_length = True

mean_wave_number = True

mean_wave_period = True

name = 'WindWaveOutput'

orbital_velocity = True

peak_group_vel = True

peak_n_factor = True

peak_period = True

peak_phase_vel = True

peak_spreading = True

peak_wave_length = True

peak_wave_number = True

rms_orbital_velocity = True

roller_diss_rate = True

roughness_length = True

sig_wave_height = True

tm_10 = True

u_resell_number = True

wave_energy_dir_x = True

wave_energy_dir_y = True

zero_downcross_period = True

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

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 key is not found, default is returned if given, otherwise KeyError is raised
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: 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

Functions to process raster data for schimpy pre-processing.

This add rasterstats, boto3 dependency to calculate raster stastistics such as means.

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 elementss.

When an element contains no raster data, zero will be assigned. When an element is partly covered by the raster data, an masked average is calculated.

If the bins are provided, the raster data will be binned and bins mapped to the mapped_values before the averaging begins. The binning uses numpy.digitize to classification, and in particular the i’th mapped value is used between the values of bins (i-1) and (i). There are some extra padding values provided as shown in the example

If the mask_value is given, raster data with the given mask value will be replaced with the fill_value before binning the data. This masking will only be used when bins are provided and pertains to special cases involving vegetation data.

Parameters:

mesh: schimpy.SchismMesh

The base mesh to work on

nodes_sel: array-like

The array or list of the nodes to process

path_raster: string-like

File fath to the raster data

bins: array-like, optional

Array of bins. It has to be 1-dimensional and monotonic

mapped_values: array-like, optional

The values of the classes. It should be bigger by one than the bins. The i’th value will be applied between the (i-1) and i value of bins.

band: int, optional

The band index to use from the raster data. The default value is 1.

Returns:

numpy.array

means of raster values of the element balls around the nodes

Notes

An example of this function in the pre-processor yaml is below:

gr3:
  sav_N.gr3:
   default: 0.
   polygons:
     - attribute: raster_to_nodes.raster_to_nodes(mesh, nodes_sel, 'NDVI.tif', bins=[-998., 0.0001, 0.3, 0.6, 1.0], mapped_values=[-999., 0., 40., 70., 100., -999.], maske_value=-10., fill_value=0.1)
       imports: schimpy.raster_to_nodes
       type: none
       vertices:
       #...

The values mesh and node_sel mean the SCHISM mesh and the selected node indices by a polygon. The example bins (or classifies) the raster values from 0.0001 to 0.3 and assigns the value 0., then assigns 40. for values between 0.3 and 0.6 and so forth.

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

schimpy.schism_input module

schimpy.schism_linestring module

Line String data based on Shapely LineStrings

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

Bases: LineString

Attributes:

area

Unitless area of the geometry (float)

boundary

Returns a lower dimension geometry that bounds the object

bounds

Returns minimum bounding region (minx, miny, maxx, maxy)

centroid

Returns the geometric center of the object

convex_hull

Imagine an elastic band stretched around the geometry: that’s a

coords

Access to geometry’s coordinates (CoordinateSequence)

envelope

A figure that envelopes the geometry

geom_type

Name of the geometry’s type, such as ‘Point’

has_z

True if the geometry’s coordinate sequence(s) have z values (are

is_closed

True if the geometry is closed, else False

is_empty

True if the set of points in this geometry is empty, else False

is_ring

True if the geometry is a closed ring, else False

is_simple

True if the geometry is simple, meaning that any self-intersections

is_valid

True if the geometry is valid (definition depends on sub-class),

length

Unitless length of the geometry (float)

minimum_clearance

Unitless distance by which a node could be moved to produce an invalid geometry (float)

minimum_rotated_rectangle

Returns the oriented envelope (minimum rotated rectangle) that encloses the geometry.

oriented_envelope

Returns the oriented envelope (minimum rotated rectangle) that encloses the geometry.

prop

type

wkb

WKB representation of the geometry

wkb_hex

WKB hex representation of the geometry

wkt

WKT representation of the geometry

xy

Separate arrays of X and Y coordinate values

Methods

almost_equals(other[, decimal])	True if geometries are equal at all coordinates to a specified decimal place.
buffer(distance[, quad_segs, cap_style, ...])	Get a geometry that represents all points within a distance of this geometry.
contains(other)	Returns True if the geometry contains the other, else False
contains_properly(other)	Returns True if the geometry completely contains the other, with no common boundary points, else False
covered_by(other)	Returns True if the geometry is covered by the other, else False
covers(other)	Returns True if the geometry covers the other, else False
crosses(other)	Returns True if the geometries cross, else False
difference(other[, grid_size])	Returns the difference of the geometries.
disjoint(other)	Returns True if geometries are disjoint, else False
distance(other)	Unitless distance to other geometry (float)
dwithin(other, distance)	Returns True if geometry is within a given distance from the other, else False.
equals(other)	Returns True if geometries are equal, else False.
equals_exact(other, tolerance)	True if geometries are equal to within a specified tolerance.
hausdorff_distance(other)	Unitless hausdorff distance to other geometry (float)
interpolate(distance[, normalized])	Return a point at the specified distance along a linear geometry
intersection(other[, grid_size])	Returns the intersection of the geometries.
intersects(other)	Returns True if geometries intersect, else False
line_interpolate_point(distance[, normalized])	Return a point at the specified distance along a linear geometry
line_locate_point(other[, normalized])	Returns the distance along this geometry to a point nearest the specified point
normalize()	Converts geometry to normal form (or canonical form).
offset_curve(distance[, quad_segs, ...])	Returns a LineString or MultiLineString geometry at a distance from the object on its right or its left side.
overlaps(other)	Returns True if geometries overlap, else False
parallel_offset(distance[, side, ...])	Alternative method to offset_curve() method.
point_on_surface()	Returns a point guaranteed to be within the object, cheaply.
project(other[, normalized])	Returns the distance along this geometry to a point nearest the specified point
relate(other)	Returns the DE-9IM intersection matrix for the two geometries (string)
relate_pattern(other, pattern)	Returns True if the DE-9IM string code for the relationship between the geometries satisfies the pattern, else False
representative_point()	Returns a point guaranteed to be within the object, cheaply.
reverse()	Returns a copy of this geometry with the order of coordinates reversed.
segmentize(max_segment_length)	Adds vertices to line segments based on maximum segment length.
simplify(tolerance[, preserve_topology])	Returns a simplified geometry produced by the Douglas-Peucker algorithm
svg([scale_factor, stroke_color, opacity])	Returns SVG polyline element for the LineString geometry.
symmetric_difference(other[, grid_size])	Returns the symmetric difference of the geometries.
touches(other)	Returns True if geometries touch, else False
union(other[, grid_size])	Returns the union of the geometries.
within(other)	Returns True if geometry is within the other, else False

geometryType

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

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:

area

Unitless area of the geometry (float)

attribute

boundary

Returns a lower dimension geometry that bounds the object

bounds

Returns minimum bounding region (minx, miny, maxx, maxy)

centroid

Returns the geometric center of the object

convex_hull

Imagine an elastic band stretched around the geometry: that’s a

coords

Access to geometry’s coordinates (CoordinateSequence)

envelope

A figure that envelopes the geometry

exterior

geom_type

Name of the geometry’s type, such as ‘Point’

has_z

True if the geometry’s coordinate sequence(s) have z values (are

interiors

is_closed

True if the geometry is closed, else False

is_empty

True if the set of points in this geometry is empty, else False

is_ring

True if the geometry is a closed ring, else False

is_simple

True if the geometry is simple, meaning that any self-intersections

is_valid

True if the geometry is valid (definition depends on sub-class),

length

Unitless length of the geometry (float)

minimum_clearance

Unitless distance by which a node could be moved to produce an invalid geometry (float)

minimum_rotated_rectangle

Returns the oriented envelope (minimum rotated rectangle) that encloses the geometry.

name

oriented_envelope

Returns the oriented envelope (minimum rotated rectangle) that encloses the geometry.

prop

type

wkb

WKB representation of the geometry

wkb_hex

WKB hex representation of the geometry

wkt

WKT representation of the geometry

xy

Separate arrays of X and Y coordinate values

Methods

almost_equals(other[, decimal])	True if geometries are equal at all coordinates to a specified decimal place.
buffer(distance[, quad_segs, cap_style, ...])	Get a geometry that represents all points within a distance of this geometry.
contains(point)	Check the polygon contains the point
contains_properly(other)	Returns True if the geometry completely contains the other, with no common boundary points, else False
covered_by(other)	Returns True if the geometry is covered by the other, else False
covers(other)	Returns True if the geometry covers the other, else False
crosses(other)	Returns True if the geometries cross, else False
difference(other[, grid_size])	Returns the difference of the geometries.
disjoint(other)	Returns True if geometries are disjoint, else False
distance(other)	Unitless distance to other geometry (float)
dwithin(other, distance)	Returns True if geometry is within a given distance from the other, else False.
equals(other)	Returns True if geometries are equal, else False.
equals_exact(other, tolerance)	True if geometries are equal to within a specified tolerance.
from_bounds(xmin, ymin, xmax, ymax)	Construct a Polygon() from spatial bounds.
hausdorff_distance(other)	Unitless hausdorff distance to other geometry (float)
interpolate(distance[, normalized])	Return a point at the specified distance along a linear geometry
intersection(other[, grid_size])	Returns the intersection of the geometries.
intersects(val)	Check the polygon intersects with the point
line_interpolate_point(distance[, normalized])	Return a point at the specified distance along a linear geometry
line_locate_point(other[, normalized])	Returns the distance along this geometry to a point nearest the specified point
normalize()	Converts geometry to normal form (or canonical form).
overlaps(other)	Returns True if geometries overlap, else False
point_on_surface()	Returns a point guaranteed to be within the object, cheaply.
project(other[, normalized])	Returns the distance along this geometry to a point nearest the specified point
relate(other)	Returns the DE-9IM intersection matrix for the two geometries (string)
relate_pattern(other, pattern)	Returns True if the DE-9IM string code for the relationship between the geometries satisfies the pattern, else False
representative_point()	Returns a point guaranteed to be within the object, cheaply.
reverse()	Returns a copy of this geometry with the order of coordinates reversed.
segmentize(max_segment_length)	Adds vertices to line segments based on maximum segment length.
simplify(tolerance[, preserve_topology])	Returns a simplified geometry produced by the Douglas-Peucker algorithm
svg([scale_factor, fill_color, opacity])	Returns SVG path element for the Polygon geometry.
symmetric_difference(other[, grid_size])	Returns the symmetric difference of the geometries.
touches(other)	Returns True if geometries touch, else False
union(other[, grid_size])	Returns the union of the geometries.
within(other)	Returns True if geometry is within the other, else False

geometryType

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

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_structure module

class schimpy.schism_structure.SchismStructure

Bases: object

A class to hold structure information

Attributes:

coords

n_duplicate

name

node_pairs

properties

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 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)

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.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

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.Usage()

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.filelist_main(demlistfile, pointlistfile, 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, 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 routine controls prioritization of the dems, gradually filling points that are still marked nan

Parameters:

files: list[str]

list of files. Existence is checked and ValueError for bad file

points: np.ndarray

this is a numpy array of points, nrow = num of points and ncol = 2 (x,y).

values: np.ndarray

values at each point – this is an output, but this gives an opportunity to use an existing data structure to receive

negate: bool

if True, values will be inverted (from elevation to depth)

require_all: bool

if True, a ValueError is raised if the list of DEMs does not cover all the points. In either case (True/False) a file is created or overwritten (dem_misses.txt) that will show all the misses.

na_fill: float

value to substitute at the end for values that are NA after all DEMs are processed. If require_all = True na_fill must be None

Returns:

valuesnp.ndarray

Values at the nodes

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

schimpy.triquadmesh module

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)

Module contents

Top-level package for schimpy.