7.3.4 Jython Library

Convert Geopotential (GP) to Height (Z)

Apply the function name to each timestep of the data

`applyToRangeValues(function, data):`

Apply the function name to each value in each timestep of the data

`averageOverTime(field, makeTimes):`

Average the values in each time step If makeTimes is true (1) then we return a field mapping all of the times to the average. Else we just return the average

combine several fields together

`differenceFromBaseTime(field):`

set the value of each time step N: D(N)= D(N) - D(0)

`exportGridToNetcdf(grid, filename):`

Write out the grid data to CF compliant netCDF file

`extractLatitudeFromNWPGrid(fieldimpl):`

Get the latitude coordinate from a grid. Return a grid of the latitudes at each point.

`extractLongitudeFromNWPGrid(fieldimpl):`

Get the longitude coordinate from a grid. Return a grid of the longitudes at each point.

`extractPressureFromNWPGrid(fieldimpl):`

Get the pressure coordinate from a time series grid and return a grid of the pressure at all points. Input grid must have pressure or height (which is converted to pressure in the standard atmosphere). User must be sure input is a suitable FlatField.

Change units from geopotential meters to meters

`getNthTimeGrid(fieldimpl, Nth):`

Get the Nth grid in time series of grids; User must be sure input is a suitable data field. returns a single time. Nth is an integer, >=0, <= max index of grid time series.

`getSliceAtAltitude(fieldimpl, alt, unit):`

Extract a 2D horizontal slice from a 3D grid at the given altitude; level is a real number; if unit is supplied, it must be compatible with meters (ft, fathoms, etc) param fieldimpl is a grid which may have one or more time steps.

`getSliceAtLevel(fieldimpl, level):`

Extract a 2D horizontal slice from a 3D grid at "Level." level is a real number; must be appropriate for the grid. param fieldimpl is a grid which may have one or more time steps.

`horizontalAdvection(param, u, v):`

horizontal advection

`horizontalDivergence(param, u, v):`

horizontal flux divergence

`layerAverage(grid, top, bottom, unit):`

Wrapper for calculating layer average

`layerDiff(grid, top, bottom, unit):`

Wrapper for calculating layer difference

Flip the longitudes in a grid from -180-180 to 0-360 (or vice-versa). Only works for cyclic rectilinear grids.

Make a 2D slice from a 3D slice at a single level

Make a vector from 3 components

makeVector(a,b,c) = [a,b,c]

Merge a set of single time grids/images into a time sequence

`makeTopographyFromField(grid):`

make a topography out of a grid

true wind vectors

Make a vector from 2 components

makeVector(a,b) = [a,b]

`maskGrid(grid, mask, value, resample):`

mask one grid by the values in the other. value is the masking value

`maxOverTime(field, makeTimes):`

Take the max of the values in each time step If makeTimes is true (1) then we return a field mapping all of the times to the average. Else we just return the max

Merge a set of time sequences of grids/images into a single time sequence. All grids/images must have the same parameter name

`minOverTime(field, makeTimes):`

Take the min of the values in each time step If makeTimes is true (1) then we return a field mapping all of the times to the average. Else we just return the min

`newName(field, varname, copy):`

create a new field with a new parameter name

`newUnit(field, varname, unitname):`

set the name and unit on a grid

remove the units from a grid

`oldaverageOverTime(field, makeTimes):`

@deprecated Average the values in each time step If makeTimes is true (1) then we return a field mapping all of the times to the average. Else we just return the average

`resampleGrid(oldGrid, gridwithNewDomain):`

display gridded data on a new domain

generate a running average:

Where:

grid = grid to average

nave - number of steps to average over

option - option for unsmoothed end points

0 - set to missing

1 - use symmetry

-1 - assume cyclic

grid = grid to average

nave - number of steps to average over

option - option for unsmoothed end points

0 - set to missing

1 - use symmetry

-1 - assume cyclic

`substitute(data, low, high, newValue):`

change values in data between low/high to newvalue

set the value of each time step N: D(N)= D(N) + D(0)

`sumOverTime(field, makeTimes):`

Take the sum of the values in each time step If makeTimes is true (1) then we return a field mapping all of the times to the average. Else we just return the sum

`timeStepDifference(field, offset):`

set the value of each time step N: D(N)= D(N) - D(N+offset) where offset should be negative

set the value of each time step N: D(N)= D(N) + D(N+offset) where offset should be negative

creating the vector field using the wind direction

`wgt_runave(grid, wgts, option):`

generate a weighted running average:

Where:

grid = grid to average

wgts - comma separated list of weights

option - option for unsmoothed end points

0 - set to missing

1 - use symmetry

-1 - assume cyclic

grid = grid to average

wgts - comma separated list of weights

option - option for unsmoothed end points

0 - set to missing

1 - use symmetry

-1 - assume cyclic

`windShear(u, v, z, top, bottom, unit):`

calculate the wind shear between discrete layers

shear = sqrt((u(top)-u(bottom))^2 + (v(top)-v(bottom))^2)/zdiff

`windShearVector(u, v, top, bottom, unit):`

calculate the u and v layer difference and return as vector

`writeGridToXls(grid, filename):`

Write out the grid data to an excel spreadsheet

In the following operators, scalar operands are named S_{n} and
vector operands are named V_{n}. Lowercase u and v refer to the
grid relative components of a vector.

Gravity constant

Addition

ADD (S1, S2) = S1 + S2

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

Horizontal Advection, negative by convention

ADV ( S, V ) = - ( u * DDX (S) + v * DDY (S) )

Ageostrophic wind

AGE ( S ) = [ u (OBS) - u (GEO(S)), v (OBS) - v (GEO(S)) ]

Wrapper for atan2 built-in

ATN2 (S1, S2) = ATAN ( S1 / S2 )

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

Average of 2 scalars

AVG (S1, S2) = ( S1 + S2 ) / 2

Absolute Vorticity

AVOR ( V ) = VOR ( V ) + CORL(V)

Apply a circular aperature smoothing to the grid points. The weighting
function is the circular aperature diffraction function. D is
the radius of influence in grid increments, increasing D increases
the smoothing. (default D=2)

Apply a circular aperature smoothing to the grid points. The weighting
function is the circular aperature diffraction function. D is
the radius of influence in grid increments, increasing D increases
the smoothing. (default D=2)

Coriolis Parameter for all points in a grid

CORL = TWO_OMEGA*sin(latr)

Apply a Cressman smoothing to the grid points. The smoothed value
is given by a weighted average of surrounding grid points. D is
the radius of influence in grid increments,
increasing D increases the smoothing. (default D=2)

Apply a Cressman smoothing to the grid points. The smoothed value
is given by a weighted average of surrounding grid points. D is
the radius of influence in grid increments,
increasing D increases the smoothing. (default D=2)

Vector cross product magnitude

CROS ( V1, V2 ) = u1 * v2 - u2 * v1

Take the derivative with respect to the domain's X coordinate

Take the derivative with respect to the domain's Y coordinate

Total deformation

DEF ( V ) = ( STRD (V) ** 2 + SHR (V) ** 2 ) ** .5

North relative direction of a vector

DIRN ( V ) = DIRR ( un(v), vn(v) )

Grid relative direction of a vector

Horizontal Divergence

DIV ( V ) = DDX ( u ) + DDY ( v )

Vector dot product

DOT ( V1, V2 ) = u1 * u2 + v1 * v2

Partial x derivative of a vector

DVDX ( V ) = [ DDX (u), DDX (v) ]

Partial x derivative of a vector

DVDY ( V ) = [ DDY (u), DDY (v) ]

Frontogenesis function from theta and the wind

FRNT ( THTA, V ) = 1/2 * MAG ( GRAD (THTA) ) *
( DEF * COS (2 * BETA) - DIV )

Where: BETA = ASIN ( (-DDX (THTA) * COS (PSI)

- DDY (THTA) * SIN (PSI))/

MAG ( GRAD (THTA) ) )

PSI = 1/2 ATAN2 ( SHR / STR )

geostrophic wind from height

GEO ( S ) = [ - DDY (S) * const / CORL, DDX (S) * const / CORL ]

Gradient of a scalar

GRAD ( S ) = [ DDX ( S ), DDY ( S ) ]

Horizontal smoothing using normally distributed weights
with theoretical response of 1/e for N * delta-x wave.
Increasing N increases the smoothing. (default N=6)

Horizontal smoothing using normally distributed weights
with theoretical response of 1/e for N * delta-x wave.
Increasing N increases the smoothing. (default N=6)

Inertial advective wind

INAD ( V1, V2 ) = [ DOT ( V1, GRAD (u2) ),
DOT ( V1, GRAD (v2) ) ]

Jacobian Determinant

JCBN ( S1, S2 ) = DDX (S1) * DDY (S2) - DDY (S1) * DDX (S2)

Laplacian operator

LAP ( S ) = DIV ( GRAD (S) )

Latitudue all points in a grid

Layer Average of a multi layer grid

LAV ( S ) = ( S (level1) + S (level2) ) / 2.

Layer Difference

LDF ( S ) = S (level1) - S (level2)

Magnitude of a vector

Mixing Ratio from Temperature, RH (requires pressure domain)

Multiply

MUL (S1, S2) = S1 * S2

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

Potetial Vorticity (usually from theta and wind)

Divide

QUO (S1, S2) = S1 / S2

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

Q-vector ( K / m / s )

QVCL ( THTA, V ) = ( 1/( D (THTA) / DP ) ) *
[ ( DOT ( DVDX (V), GRAD (THTA) ) ),
( DOT ( DVDY (V), GRAD (THTA) ) ) ]

Q-vector at a level ( K / m / s )

QVEC ( S, V ) = [ - ( DOT ( DVDX (V), GRAD (S) ) ),
- ( DOT ( DVDY (V), GRAD (S) ) ) ]
where S can be any thermal paramenter, usually THTA.

Apply a rectangular aperature smoothing to the grid points. The weighting
function is the product of the rectangular aperature diffraction function
in the x and y directions. D is the radius of influence in grid
increments, increasing D increases the smoothing. (default D=2)

Apply a rectangular aperature smoothing to the grid points. The weighting
function is the product of the rectangular aperature diffraction function
in the x and y directions. D is the radius of influence in grid
increments, increasing D increases the smoothing. (default D=2)

Create Relative Humidity from Temperature, mixing ratio (requires pressure domain)

Average over whole grid

SAVG ( S ) = average of all non-missing grid point values

Average over grid subset

SAVS ( S ) = average of all non-missing grid point values in the subset
area

Horizontal Flux Divergence

SDIV ( S, V ) = S * DIV ( V ) + DOT ( V, GRAD ( S ) )

Shear Deformation

SHR ( V ) = DDX ( v ) + DDY ( u )

Smooth a scalar grid using a 5-point smoother

SM5S ( S ) = .5 * S (i,j) + .125 * ( S (i+1,j) + S (i,j+1) +
S (i-1,j) + S (i,j-1) )

Smooth a scalar grid using a 5-point smoother (see sm5s)

Smooth a scalar grid using a 9-point smoother

SM9S ( S ) = .25 * S (i,j) + .125 * ( S (i+1,j) + S (i,j+1) +
S (i-1,j) + S (i,j-1) )
+ .0625 * ( S (i+1,j+1) +
S (i+1,j-1) +
S (i-1,j+1) +
S (i-1,j-1) )

Smooth a scalar grid using a 9-point smoother (see sm9s)

Stretching Deformation

STRD ( V ) = DDX ( u ) - DDY ( v )

Subtract

SUB (S1, S2) = S1 - S2

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

WA = use WEIGHTED_AVERAGE (default NEAREST_NEIGHBOR)

`thrm(S, level1, level2, unit):`

Thermal wind

THRM ( S ) = [ u (GEO(S)) (level1) - u (GEO(S)) (level2),
v (GEO(S)) (level1) - v (GEO(S)) (level2) ]

Potential Temperature from Temperature (requires pressure domain)

Equivalent Potential Temperature from Temperature and Relative humidity (requires pressure domain)

North relative u component

Grid relative u component

add the components of 2 vectors

VADD (V1, V2) = [ u1+u2, v1+v2 ]

Make a true nort vector from two components

VECN ( S1, S2 ) = [ S1, S2 ]

Make a vector from two components

VECR ( S1, S2 ) = [ S1, S2 ]

`vlav(V, level1, level2, unit):`

calculate the vector layer average

VLDF(V) = [(u(level1) - u(level2))/2,
(v(level1) - v(level2))/2]

`vldf(V, level1, level2, unit):`

calculate the vector layer difference

VLDF(V) = [u(level1) - u(level2),
v(level1) - v(level2)]

Multiply the components of 2 vectors

VMUL (V1, V2) = [ u1*u2, v1*v2 ]

North relative v component

Relative Vorticity

VOR ( V ) = DDX ( v ) - DDY ( u )

Divide the components of 2 vectors

VQUO (V1, V2) = [ u1/u2, v1/v2 ]

Grid relative v component

subtract the components of 2 vectors

VSUB (V1, V2) = [ u1-u2, v1-v2 ]

Magnitude of the vertical wind shear in a layer

WSHR ( V ) = MAG [ VLDF (V) ] / LDF (Z)

Average along a grid row

XAV (S) = ( S (X1) + S (X2) + ... + S (KXD) ) / KNT
KXD = number of points in row
KNT = number of non-missing points in row
XAV for a row is stored at every point in that row.

Sum along a grid row

XSUM (S) = ( S (X1) + S (X2) + ... + S (KXD) )
KXD = number of points in row
XSUM for a row is stored at every point in that row.

Average along a grid column

YAV (S) = ( S (Y1) + S (Y2) + ... + S (KYD) ) / KNT
KYD = number of points in column
KNT = number of non-missing points in column

Sum along a grid column

YSUM (S) = ( S (Y1) + S (Y2) + ... + S (KYD) )
KYD = number of points in row
YSUM for a column is stored at every point in that column.

Average across the levels of a grid at all points

ZAV (S) = ( S (Z1) + S (Z2) + ... + S (KZD) ) / KNT
KZD = number of levels
KNT = number of non-missing points in column

Sum across the levels of a grid at all points

ZSUM (S) = ( S (Z1) + S (Z2) + ... + S (KZD) )
KYD = number of levels
ZSUM for a vertical column is stored at every point

mode value

percentile value

basic ensemble average

max value of all member

min value of all member

max - min grid value

basic ensemble average

`ens_uprob(grid, logicalOp1, pValue1, and_or, logicalOp2, pValue2, exptdLoBound, exptdUpBound):`

ensemble univariate probability calculation

combine 3 images as an RGB image

`makeNavigatedImage(d, ulLat, ulLon, lrLat, lrLon):`

This takes a image data object and a lat/lon bounding box and adds a lat/lon domain to the data. Use it in conjunction with a formula:

`calcDayAnom(daily, ltm, asPercent):`

Calculate the daily anomaly from a long term mean.

grid - daily values

ltm - long term mean (climatology)

asPercent - if 1, return percentage of climatology normal (+/-)

`calcMonAnom(monthly, ltm, normalize):`

Calculate the monthly anomaly from a long term mean. The number of timesteps in ltm must be 12 and the monthly data must start in January.

Create a daily climatology from a grid of daily data over a period of years.

Create a monthly climatology from a grid of monthly data over a period of years. The number of timesteps must be a multiple of 12.

Create monthly standard deviations from a grid of monthly data over a period of years. The number of timesteps must be a multiple of 12.

`applyFunctionToValuesInField(function, field, min, max, inside):`

`applyFunctionToValuesInRange(function, range, timeStep, min, max, inside):`

`applyToIndices(function, range, timeStep, indices):`

`averageFromMap(field, mapSets):`

`averageFromMapAndClip(field, mapSets):`

`filterMaps(mapSets, propName, operator, value):`

Return a new set of maps whose property propName satisfies the given operator/value. The operators can be ==,!=, <,>,<=,>=, match, !match

`getMapProperty(polygon, propName):`

Get the named property from the given mapData

`getMapsWithProperty(mapSets, propName, value):`

Return a new set of maps that have the given property value

Make a 3d map. map - map line data - topo - topography dataset

`makeFieldFromMapBounds(mapSets, length1, length2, fill, unit):`

Make a field whos lat/lon area is the bounds of the given mapSet. It has length1 points in the x and length2 in the y. Fill it with the fill value and the given unit

`mapsAbsoluteValue(originalValues, newValues, indexArray):`

`mapsApplyToField(function, field, mapSets, inside):`

mapSets defines a set of polygons. This procedure fills the areas in the field are enclosed by each polygon with the average value within that area

`mapsApplyToRange(function, range, timeStep, mapSets, inside):`

`mapsAverage(originalValues, newValues, indexArray):`

`mapsMax(originalValues, newValues, indexArray, value):`

`mapsMin(originalValues, newValues, indexArray, value):`

`mapsSetValue(originalValues, newValues, indexArray, value):`

`subsetFromMap(field, mapSets, fillValue, inverse):`

mapSets defines a set of polygons. This procedure fills the areas in the field that are not enclosed by the polygons with the fill value. If inverse is 1 then it fills the areas that are enclosed

`subsetRangeFromMap(range, timeStep, mapSets, fillValue, inverse):`

mapSets defines a set of polygons. This procedure fills the areas in the field that are not enclosed by the polygons with the fill value. If inverse is 1 then it fills the areas that are enclosed

`subsetRangeWithProperty(range, mapSets):`

test code

`subsetWithProperty(field, mapSets):`

test code

`testIndexToLatLon(field, mapSets):`

Test out the GridUtil.getLatLons method. Call this with some grid field and a set of maps

`testIndexToLatLon2(field, mapSets):`

Test out the GridUtil.getLatLons method. Call this with some grid field and a set of maps

Clear the shell

`createDisplay(displayType, data, dataName):`

create a display of type displayType. Right click in input field to select particular displayType. The data is can be a data object, a datachoice or a list of data or datachoices The dataName is used to name the data, i.e., its the parameter name

Find the data source object with the given name. If no name is given then this will return the first (non-formula) data source

`getData(dataSourceName, dataChoiceName):`

Find the data source with the given name and the data choice on that data source with the given name. If no dataSourceName is given then use the first one in the list If no dataChoiceName is given then use the first one held by the data source Return the data for the data choice. If no data source or data choice is found then return null

`getDataChoice(dataSourceName, dataChoiceName):`

Find the data source with the given name and the data choice on that data source with the given name. If no dataSourceName is given then use the first one in the list If no dataChoiceName is given then use the first one held by the data source Return the data choice If no data source or data choice is found then return null

List all of the variables defined in the shell's interpreter

Create a datasource from the given file name or url. The optional type parameter is used to specify the type of data

Print out the math type of the given data

`selectData(name1, name2, name3, name4, name5):`

Select up to 5 data fields. This returns a List of the actual Data objects

`selectDataChoice(name1, name2, name3, name4, name5):`

Select up to 5 data choices. This returns a List of the data choices, not the actual Data To get the data do:

dataList.get(0).getData(None)

The given dataSource can be an actual data source or the name of a data source. This procedure will define a set of jython variables that correspond to the data choices held by the given data source.

This procedure will define a set of jython variables, 'dataSource0, dataSource1, ...' that correspond to loaded data sources.

Bring up the jython library dialog

A utility to make a 2 dimensional float array filled with the given value

evaluate a formula and return a DerivedDataChoice

`makeFloatArray(rows, cols, value):`

A utility to make a 2 dimensional float array filled with the given value

Print out the values of the sounding data

Print out the values of the set of sounding data