ucar.unidata.data.grid

Class GridMath

java.lang.Object

ucar.unidata.data.grid.GridMath

public class GridMath
extends java.lang.Object

A class to handle grid math. This handles math between grids on different manifolds where possible.

Author:

IDV Development Team

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	AXIS_X axis identifier - X
static java.lang.String	AXIS_Y axis identifier - Y
static java.lang.String	FUNC_AVERAGE function for the applyFunctionOverTime routine
static java.lang.String	FUNC_DIFFERENCE function for the timeStepFunc routine
static java.lang.String	FUNC_EXP
static java.lang.String	FUNC_MAX function for the applyFunctionOverTime routine
static java.lang.String	FUNC_MIN function for the applyFunctionOverTime routine
static java.lang.String	FUNC_MODE function for the applyFunctionOverTime routine
static java.lang.String	FUNC_POW function for the applyFunctionOverTime 10 base pow routine
static java.lang.String	FUNC_PRCNTL function for the applyFunctionOverTime routine
static java.lang.String	FUNC_RNG function for the applyFunctionOverTime routine
static java.lang.String	FUNC_STDEV function for the applyFunctionOverTime routine
static java.lang.String	FUNC_SUM function for the applyFunctionOverTime routine
static java.lang.String	FUNC_UPROB function for the applyFunctionOverTime routine
static visad.Real	NEGATIVE_ONE negative one
static int	OPT_CYCLIC cyclic option
static int	OPT_MISSING missing option
static int	OPT_SYMMETRIC symmetric option
static java.lang.String	PRCNTL

Constructor Summary

Constructors

Constructor and Description
GridMath()

Method Summary

Modifier and Type	Method and Description
static visad.FieldImpl	add(visad.FieldImpl grid1, visad.FieldImpl grid2) Add two grids together
static visad.FieldImpl	add(visad.FieldImpl grid1, visad.FieldImpl grid2, boolean useWA) Add two grids together
static visad.FieldImpl	applyFunctionOverGrid2D(visad.FieldImpl grid, java.lang.String function, visad.FieldImpl grid1, java.lang.String function1, float percentile) Evaluate the function of the grid and the function1 to the grid1.
static visad.FieldImpl	applyFunctionOverGrid2D(visad.FieldImpl grid, java.lang.String function, java.lang.String statThreshold) Apply the function to the 2D grid.
static visad.FlatField	applyFunctionOverGrids(visad.FlatField[] grids, java.lang.String function) Apply the function to the grids.
static visad.FlatField	applyFunctionOverGrids0(visad.FlatField[] grids, java.lang.String function)
static visad.FieldImpl	applyFunctionOverGridsExt(visad.FieldImpl field, java.lang.String function)
static visad.FieldImpl	applyFunctionOverLevels(visad.FieldImpl grid, java.lang.String function) Apply the function to the time steps of the given grid over the levels.
static visad.FieldImpl	applyFunctionOverMembers(visad.FieldImpl grid, float statThreshold, float exptdLoBound, float exptdUpBound, java.lang.String function) Apply the function to the ens members of the given grid.
static visad.FieldImpl	applyFunctionOverMembers(visad.FieldImpl grid, java.lang.String function) Apply the function to the ens members of the given grid.
static visad.FieldImpl	applyFunctionOverMembers(visad.FieldImpl grid, java.lang.String statThreshold, java.lang.String exptdLoBoundIn, java.lang.String exptdUpBoundIn, java.lang.String function) Apply the function to the ens members of the given grid.
static visad.FieldImpl	applyFunctionOverTime(visad.FieldImpl grid, java.lang.String function, boolean makeTimes) Apply the function to the time steps of the given grid.
static visad.FieldImpl	applyFunctionOverTime(visad.FieldImpl grid, java.lang.String function, int startIdx, int idxStride, boolean makeTimes) Apply the function to the time steps of the given grid.
static visad.FieldImpl	applyFunctionToAxis(visad.FieldImpl grid, java.lang.String function, java.lang.String axis) Apply the function to the x or y of the given grid at each level.
static visad.FieldImpl	applyFunctionToLevels(visad.FieldImpl grid, java.lang.String function) Apply the function to the time steps of the given grid at each level.
static visad.FieldImpl	atan2(visad.FieldImpl grid1, visad.FieldImpl grid2) Take the arctangent of two grids
static visad.FieldImpl	atan2(visad.FieldImpl grid1, visad.FieldImpl grid2, boolean useWA) Take the arctangent of two grids
static visad.FieldImpl	averageOverMembers(visad.FieldImpl grid) Average the grid over member
static visad.FieldImpl	averageOverTime(visad.FieldImpl grid, boolean makeTimes) Average the grid at each point over time
static visad.FieldImpl	calculateHelicity(visad.FieldImpl gridu, visad.FieldImpl gridv, float bottom, float top, float ux, float vy) Calculate Helicity to the time steps of the given grid at each level.
static float	calculateL1Norm(float[] vector)
static float	calculateL2Norm(float[] vector)
static visad.FieldImpl	ddx(visad.FieldImpl grid) Take the partial derivative with respect to X of the given field.
static visad.FieldImpl	ddy(visad.FieldImpl grid) Take the partial derivative with respect to Y of the given field.
static visad.FieldImpl	differenceFromBaseTime(visad.FieldImpl grid) This creates a field where D(T) = D(T)-D(0) Any time steps up to the offset time are set to missing
static visad.FieldImpl	divide(visad.FieldImpl grid1, visad.FieldImpl grid2) Divide two grids
static visad.FieldImpl	divide(visad.FieldImpl grid1, visad.FieldImpl grid2, boolean useWA) Divide two grids
static visad.FieldImpl	ensembleHighestValues(visad.FieldImpl grid) ensemble grid max values
static visad.FieldImpl	ensembleLowestValues(visad.FieldImpl grid) ensemble grid min values
static visad.FieldImpl	ensembleModeValues(visad.FieldImpl grid) ensemble grid min values
static visad.FieldImpl	ensemblePercentileValues(visad.FieldImpl grid, int percent) ensemble grid min values
static visad.FieldImpl	ensemblePercentileValues(visad.FieldImpl grid, java.lang.String percent) ensemble grid min values
static visad.FieldImpl	ensembleRangeValues(visad.FieldImpl grid) ensemble grid range values
static visad.FieldImpl	ensembleStandardDeviation(visad.FieldImpl grid) ensemble Standard Deviation
static visad.FieldImpl	ensembleUProbabilityValues(visad.FieldImpl grid, java.lang.String logicalOp, float pValue, float exptdLoBound, float exptdUpBound) ensemble grid univariate probability
static visad.FieldImpl	ensembleUProbabilityValues(visad.FieldImpl grid, java.lang.String logicalOp, java.lang.String pValue, java.lang.String exptdLoBound, java.lang.String exptdUpBound) ensemble grid univariate probability
static float	evaluateMode(float[] data) evaluate mode value
static float	evaluatePercentile(float[][] values, double p)
static float	evaluatePercentile(float[] values, double p)
static float	evaluatePercentile(float[] values, int begin, int length, double p) evaluate percentile value
static float	evaluateUProbability(float[] values, float pValue, int length) evaluate univariate probability of "variable with n ensemble values" smaller than pValue code from $NAWIPS/gempak/source/diaglib/de/decprb.c used to make this function.
static visad.FieldImpl	maxOverTime(visad.FieldImpl grid, boolean makeTimes) Take the max value at each grid point
static visad.FieldImpl	minOverTime(visad.FieldImpl grid, boolean makeTimes) Take the min value at each grid point
static visad.FieldImpl	multiply(visad.FieldImpl grid1, visad.FieldImpl grid2) Multiply two grids
static visad.FieldImpl	multiply(visad.FieldImpl grid1, visad.FieldImpl grid2, boolean useWA) Multiply two grids
static visad.FieldImpl	partial(visad.FieldImpl grid)
static visad.FieldImpl	partial(visad.FieldImpl grid, int domainIndex) Take the partial derivative with respect variable at the domain index.
static visad.FlatField	powerTransformerFF(visad.FlatField grid, double lambda)
static visad.FlatField	quantileTransformerFF(visad.FlatField grid)
static visad.FieldImpl	replaceNegativeValue(visad.FieldImpl grid, float newValue)
static visad.FieldImpl	replacePositiveValue(visad.FieldImpl grid, float newValue)
static visad.FlatField	robustScalerFF(visad.FlatField grid)
static visad.FieldImpl	standardDeviationOverTime(visad.FieldImpl grid, boolean makeTimes) Compute the standard deviation of the grid at each point over time
static edu.wisc.ssec.mcidasv.data.hydra.Statistics	statisticsFF(visad.FlatField grid)
static visad.FieldImpl	subtract(visad.FieldImpl grid1, visad.FieldImpl grid2) Subtract two grids
static visad.FieldImpl	subtract(visad.FieldImpl grid1, visad.FieldImpl grid2, boolean useWA) Subtract two grids
static visad.FieldImpl	subtractExt(visad.FieldImpl grid, visad.FieldImpl grid2d) substractExt subtract a grid2d from each level of the 3d grid
static visad.FieldImpl	sumFromBaseTime(visad.FieldImpl grid) This creates a field where D(T) = D(0)+D(1)+...+D(T-1)+D(T)
static visad.FieldImpl	sumOverTime(visad.FieldImpl grid, boolean makeTimes) Sum each grid point
static visad.FieldImpl	timeRunningAverage(visad.FieldImpl grid, int nave, int opt) Create a running average across the time dimension.
static visad.FieldImpl	timeRunningAverage(visad.FieldImpl grid, int nave, int opt, boolean skipMissing) Create a running average across the time dimension.
static visad.FieldImpl	timeStepDifference(visad.FieldImpl grid, int offset) This creates a field where D(T) = D(T)-D(T+offset) Any time steps up to the offset time are set to missing
static visad.FieldImpl	timeStepFunc(visad.FieldImpl grid, int offset, java.lang.String func) This creates a field where is either D(T) = D(T)-D(T+offset) or D(T) = D(T)+D(T+offset) depending on the value of the func argument Any time steps up to the offset time are set to missing.
static visad.FieldImpl	timeStepSum(visad.FieldImpl grid, int offset) This creates a field where D(T) = D(T)+D(T+offset) Any time steps up to the offset time are set to missing
static visad.FieldImpl	timeWeightedRunningAverage(visad.FieldImpl grid, float[] wgts, int opt) Create a running average across the time dimension.
static visad.FieldImpl	timeWeightedRunningAverage(visad.FieldImpl grid, float[] wgts, int opt, boolean skipMissing) Create a running average across the time dimension.
static float[]	twoDConvert(float[][] nums)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

FUNC_AVERAGE

public static final java.lang.String FUNC_AVERAGE

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_STDEV

public static final java.lang.String FUNC_STDEV

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_PRCNTL

public static final java.lang.String FUNC_PRCNTL

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

PRCNTL

public static final java.lang.String PRCNTL

See Also:

Constant Field Values

FUNC_UPROB

public static final java.lang.String FUNC_UPROB

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_SUM

public static final java.lang.String FUNC_SUM

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_MAX

public static final java.lang.String FUNC_MAX

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_MIN

public static final java.lang.String FUNC_MIN

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_RNG

public static final java.lang.String FUNC_RNG

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_MODE

public static final java.lang.String FUNC_MODE

function for the applyFunctionOverTime routine

See Also:

Constant Field Values

FUNC_EXP

public static final java.lang.String FUNC_EXP

See Also:

Constant Field Values

FUNC_POW

public static final java.lang.String FUNC_POW

function for the applyFunctionOverTime 10 base pow routine

See Also:

Constant Field Values

FUNC_DIFFERENCE

public static final java.lang.String FUNC_DIFFERENCE

function for the timeStepFunc routine

See Also:

Constant Field Values

OPT_CYCLIC

public static final int OPT_CYCLIC

cyclic option

See Also:

Constant Field Values

OPT_MISSING

public static final int OPT_MISSING

missing option

See Also:

Constant Field Values

OPT_SYMMETRIC

public static final int OPT_SYMMETRIC

symmetric option

See Also:

Constant Field Values

AXIS_X

public static final java.lang.String AXIS_X

axis identifier - X

See Also:

Constant Field Values

AXIS_Y

public static final java.lang.String AXIS_Y

axis identifier - Y

See Also:

Constant Field Values

NEGATIVE_ONE

public static final visad.Real NEGATIVE_ONE

negative one

Constructor Detail

GridMath

public GridMath()

Method Detail

add

public static visad.FieldImpl add(visad.FieldImpl grid1,
                                  visad.FieldImpl grid2)
                           throws visad.VisADException

Add two grids together

Parameters:

grid1 - first grid

grid2 - second grid

Returns:

the sum of the grids

Throws:

visad.VisADException - problem doing the math

add

public static visad.FieldImpl add(visad.FieldImpl grid1,
                                  visad.FieldImpl grid2,
                                  boolean useWA)
                           throws visad.VisADException

Add two grids together

Parameters:

grid1 - first grid

grid2 - second grid

useWA - use WEIGHTED_AVERAGE for resampling

Returns:

the sum of the grids

Throws:

visad.VisADException - problem doing the math

subtract

public static visad.FieldImpl subtract(visad.FieldImpl grid1,
                                       visad.FieldImpl grid2)
                                throws visad.VisADException

Subtract two grids

Parameters:

grid1 - first grid

grid2 - second grid

Returns:

the difference of the grids

Throws:

visad.VisADException - problem doing the math

subtract

public static visad.FieldImpl subtract(visad.FieldImpl grid1,
                                       visad.FieldImpl grid2,
                                       boolean useWA)
                                throws visad.VisADException

Subtract two grids

Parameters:

grid1 - first grid

grid2 - second grid

useWA - true to use weighted average

Returns:

the difference of the grids

Throws:

visad.VisADException - problem doing the math

multiply

public static visad.FieldImpl multiply(visad.FieldImpl grid1,
                                       visad.FieldImpl grid2)
                                throws visad.VisADException

Multiply two grids

Parameters:

grid1 - first grid

grid2 - second grid

Returns:

the product of the grids

Throws:

visad.VisADException - problem doing the math

multiply

public static visad.FieldImpl multiply(visad.FieldImpl grid1,
                                       visad.FieldImpl grid2,
                                       boolean useWA)
                                throws visad.VisADException

Multiply two grids

Parameters:

grid1 - first grid

grid2 - second grid

useWA - true to use WEIGHTED_AVERAGE

Returns:

the product of the grids

Throws:

visad.VisADException - problem doing the math

divide

public static visad.FieldImpl divide(visad.FieldImpl grid1,
                                     visad.FieldImpl grid2)
                              throws visad.VisADException

Divide two grids

Parameters:

grid1 - first grid

grid2 - second grid

Returns:

the quotient of the grids

Throws:

visad.VisADException - problem doing the math

divide

public static visad.FieldImpl divide(visad.FieldImpl grid1,
                                     visad.FieldImpl grid2,
                                     boolean useWA)
                              throws visad.VisADException

Divide two grids

Parameters:

grid1 - first grid

grid2 - second grid

useWA - true to use WEIGHTED_AVERAGE

Returns:

the quotient of the grids

Throws:

visad.VisADException - problem doing the math

atan2

public static visad.FieldImpl atan2(visad.FieldImpl grid1,
                                    visad.FieldImpl grid2)
                             throws visad.VisADException

Take the arctangent of two grids

Parameters:

grid1 - first grid

grid2 - second grid

Returns:

the arctangent of the grids

Throws:

visad.VisADException - problem doing the math

atan2

public static visad.FieldImpl atan2(visad.FieldImpl grid1,
                                    visad.FieldImpl grid2,
                                    boolean useWA)
                             throws visad.VisADException

Take the arctangent of two grids

Parameters:

grid1 - first grid

grid2 - second grid

useWA - true to use WEIGHTED_AVERAGE

Returns:

the arctangent of the grids

Throws:

visad.VisADException - problem doing the math

averageOverTime

public static visad.FieldImpl averageOverTime(visad.FieldImpl grid,
                                              boolean makeTimes)
                                       throws visad.VisADException

Average the grid at each point over time

Parameters:

grid - grid to average

makeTimes - If true then make a time field with the range being the same computed value If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

standardDeviationOverTime

public static visad.FieldImpl standardDeviationOverTime(visad.FieldImpl grid,
                                                        boolean makeTimes)
                                                 throws visad.VisADException

Compute the standard deviation of the grid at each point over time

Parameters:

grid - grid to compute std

makeTimes - If true then make a time field with the range being the same computed value If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

averageOverMembers

public static visad.FieldImpl averageOverMembers(visad.FieldImpl grid)
                                          throws visad.VisADException

Average the grid over member

Parameters:

grid - ensemble grid to average

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleStandardDeviation

public static visad.FieldImpl ensembleStandardDeviation(visad.FieldImpl grid)
                                                 throws visad.VisADException

ensemble Standard Deviation

Parameters:

grid - ensemble grid

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleLowestValues

public static visad.FieldImpl ensembleLowestValues(visad.FieldImpl grid)
                                            throws visad.VisADException

ensemble grid min values

Parameters:

grid - ensemble grid

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleHighestValues

public static visad.FieldImpl ensembleHighestValues(visad.FieldImpl grid)
                                             throws visad.VisADException

ensemble grid max values

Parameters:

grid - ensemble grid

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleRangeValues

public static visad.FieldImpl ensembleRangeValues(visad.FieldImpl grid)
                                           throws visad.VisADException

ensemble grid range values

Parameters:

grid - ensemble grid

Returns:

the new field

Throws:

visad.VisADException - On badness

ensemblePercentileValues

public static visad.FieldImpl ensemblePercentileValues(visad.FieldImpl grid,
                                                       java.lang.String percent)
                                                throws visad.VisADException

ensemble grid min values

Parameters:

grid - ensemble grid

percent - the percent

Returns:

the new field

Throws:

visad.VisADException - On badness

ensemblePercentileValues

public static visad.FieldImpl ensemblePercentileValues(visad.FieldImpl grid,
                                                       int percent)
                                                throws visad.VisADException

ensemble grid min values

Parameters:

grid - ensemble grid

percent - the percent

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleUProbabilityValues

public static visad.FieldImpl ensembleUProbabilityValues(visad.FieldImpl grid,
                                                         java.lang.String logicalOp,
                                                         float pValue,
                                                         float exptdLoBound,
                                                         float exptdUpBound)
                                                  throws visad.VisADException

ensemble grid univariate probability

Parameters:

grid - ensemble grid

logicalOp - gt or lt for P(X > | < pValue)

pValue - probability threshold value P(valueAtGridPoint < pValue)

exptdLoBound - expected lo bound

exptdUpBound - expected hi bound

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleUProbabilityValues

public static visad.FieldImpl ensembleUProbabilityValues(visad.FieldImpl grid,
                                                         java.lang.String logicalOp,
                                                         java.lang.String pValue,
                                                         java.lang.String exptdLoBound,
                                                         java.lang.String exptdUpBound)
                                                  throws visad.VisADException

ensemble grid univariate probability

Parameters:

grid - ensemble grid

logicalOp - gt or lt for P(X > | < pValue)

pValue - probability threshold value P(valueAtGridPoint < pValue)

exptdLoBound - expected lo bound

exptdUpBound - expected hi bound

Returns:

the new field

Throws:

visad.VisADException - On badness

ensembleModeValues

public static visad.FieldImpl ensembleModeValues(visad.FieldImpl grid)
                                          throws visad.VisADException

ensemble grid min values

Parameters:

grid - ensemble grid

Returns:

the new field

Throws:

visad.VisADException - On badness

timeStepDifference

public static visad.FieldImpl timeStepDifference(visad.FieldImpl grid,
                                                 int offset)
                                          throws visad.VisADException

This creates a field where D(T) = D(T)-D(T+offset) Any time steps up to the offset time are set to missing

Parameters:

grid - grid to average

offset - time step offset. e.g., offset=-1 results in D(T)=D(T)-D(T-1)

Returns:

the new field

Throws:

visad.VisADException - On badness

timeStepSum

public static visad.FieldImpl timeStepSum(visad.FieldImpl grid,
                                          int offset)
                                   throws visad.VisADException

This creates a field where D(T) = D(T)+D(T+offset) Any time steps up to the offset time are set to missing

Parameters:

grid - grid to average

offset - time step offset. e.g., offset=-1 results in D(T)=D(T)+D(T-1)

Returns:

the new field

Throws:

visad.VisADException - On badness

differenceFromBaseTime

public static visad.FieldImpl differenceFromBaseTime(visad.FieldImpl grid)
                                              throws visad.VisADException

This creates a field where D(T) = D(T)-D(0) Any time steps up to the offset time are set to missing

Parameters:

grid - grid to average

Returns:

the new field

Throws:

visad.VisADException - On badness

sumFromBaseTime

public static visad.FieldImpl sumFromBaseTime(visad.FieldImpl grid)
                                       throws visad.VisADException

This creates a field where D(T) = D(0)+D(1)+...+D(T-1)+D(T)

Parameters:

grid - grid to sum

Returns:

the new field

Throws:

visad.VisADException - On badness

timeStepFunc

public static visad.FieldImpl timeStepFunc(visad.FieldImpl grid,
                                           int offset,
                                           java.lang.String func)
                                    throws visad.VisADException

This creates a field where is either D(T) = D(T)-D(T+offset) or D(T) = D(T)+D(T+offset) depending on the value of the func argument Any time steps up to the offset time are set to missing. If offset == 0 then we use D(0) as the fixed operand foreach operator, e.g.: D(T) = D(T) - D(0)

Parameters:

grid - grid to average

offset - time step offset.

func - which function to apply, SUM or DIFFERENCE

Returns:

the new field

Throws:

visad.VisADException - On badness

timeWeightedRunningAverage

public static visad.FieldImpl timeWeightedRunningAverage(visad.FieldImpl grid,
                                                         float[] wgts,
                                                         int opt)
                                                  throws visad.VisADException

Create a running average across the time dimension.

Parameters:

grid - grid to average

wgts - weights per step (usually odd and add to 1)

opt - options for end points

     N = {last point in the series}
    xi = {input series}
    xo = {output series}
    nwgt = {number of wgts}

    opt < 0 : utilize cyclic conditions
          e.g., nwgt = 2
                 xo(0) = w(0) * xi(0) + w(1) * xi(1)
                 xo(N) = w(0) * xi(N) + w(1) * xi(0)
          e.g., nwgt = 3
                 xo(0) = w(0) * xi(N) + w(1) * xi(0) + w(2) * xi(1)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(0)
          e.g., nwgt = 4
                 xo(0) = w(0) * xi(N) + w(1) * xi(0) + w(2) * xi(1) + w(3) * xi(2)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(1) + w(3) * xi(2)

    opt = 0 : set unsmoothed beginning and end pts to x@_FillValue (most common)
          e.g., nwgt = 2
                 xo(0) = w(0) * xi(0) + w(1) * xi(1)
                 xo(N) = xi@_FillValue
          e.g., nwgt = 3
                 xo(0) = xi@_FillValue
                 xo(1) = w(0) * xi(0) + w(1) * xi(1) + w(2) * xi(2)
                 xi(N) = xi@_FillValue
          e.g., nwgt = 4
                 xo(0)     = xi@_FillValue
                 xo(1)     = w(0) * xi(0) + w(1) * xi(1) + w(2) * xi(2) + w(3) * xi(3)
                 xo(N - 2) = w(0) * xi(N - 3) + w(1) * xi(N - 2) + w(2) * xi(N - 1) + w(3) * xi(N)
                 xo(N - 1) = xi@_FillValue
                 xo(N)     = xi@_FillValue

    opt > 0 : utilize reflective (symmetric) conditions
          e.g., nwgt = 2
                 xo(0) = w(0) * xi(0) + w(1) * xi(1)
                 xo(N) = w(0) * xi(N) + w(0) * xi(0)
          e.g., nwgt = 3
                 xo(0) = w(0) * xi(1) + w(1) * xi(0) + w(2) * xi(1)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(N - 1)
          e.g., nwgt = 4
                 xo(0) = w(0) * xi(1) + w(1) * xi(0) + w(2) * xi(1) + w(3) * xi(2)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(0) + w(3) * xi(2)
 

Returns:

the new field

Throws:

visad.VisADException - On badness

timeWeightedRunningAverage

public static visad.FieldImpl timeWeightedRunningAverage(visad.FieldImpl grid,
                                                         float[] wgts,
                                                         int opt,
                                                         boolean skipMissing)
                                                  throws visad.VisADException

Create a running average across the time dimension.

Parameters:

grid - grid to average

wgts - weights per step (usually odd and add to 1)

opt - options for end points

     N = {last point in the series}
    xi = {input series}
    xo = {output series}
    nwgt = {number of wgts}

    opt < 0 : utilize cyclic conditions
          e.g., nwgt = 2
                 xo(0) = w(0) * xi(0) + w(1) * xi(1)
                 xo(N) = w(0) * xi(N) + w(1) * xi(0)
          e.g., nwgt = 3
                 xo(0) = w(0) * xi(N) + w(1) * xi(0) + w(2) * xi(1)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(0)
          e.g., nwgt = 4
                 xo(0) = w(0) * xi(N) + w(1) * xi(0) + w(2) * xi(1) + w(3) * xi(2)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(1) + w(3) * xi(2)

    opt = 0 : set unsmoothed beginning and end pts to x@_FillValue (most common)
          e.g., nwgt = 2
                 xo(0) = w(0) * xi(0) + w(1) * xi(1)
                 xo(N) = xi@_FillValue
          e.g., nwgt = 3
                 xo(0) = xi@_FillValue
                 xo(1) = w(0) * xi(0) + w(1) * xi(1) + w(2) * xi(2)
                 xi(N) = xi@_FillValue
          e.g., nwgt = 4
                 xo(0)     = xi@_FillValue
                 xo(1)     = w(0) * xi(0) + w(1) * xi(1) + w(2) * xi(2) + w(3) * xi(3)
                 xo(N - 2) = w(0) * xi(N - 3) + w(1) * xi(N - 2) + w(2) * xi(N - 1) + w(3) * xi(N)
                 xo(N - 1) = xi@_FillValue
                 xo(N)     = xi@_FillValue

    opt > 0 : utilize reflective (symmetric) conditions
          e.g., nwgt = 2
                 xo(0) = w(0) * xi(0) + w(1) * xi(1)
                 xo(N) = w(0) * xi(N) + w(0) * xi(0)
          e.g., nwgt = 3
                 xo(0) = w(0) * xi(1) + w(1) * xi(0) + w(2) * xi(1)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(N - 1)
          e.g., nwgt = 4
                 xo(0) = w(0) * xi(1) + w(1) * xi(0) + w(2) * xi(1) + w(3) * xi(2)
                 xo(N) = w(0) * xi(N - 1) + w(1) * xi(N) + w(2) * xi(0) + w(3) * xi(2)
 

skipMissing - if true, missing timesteps will not be included in the average and the average will be done on the non-missing times

Returns:

the new field

Throws:

visad.VisADException - On badness

timeRunningAverage

public static visad.FieldImpl timeRunningAverage(visad.FieldImpl grid,
                                                 int nave,
                                                 int opt)
                                          throws visad.VisADException

Create a running average across the time dimension.

Parameters:

grid - grid to average

nave - number of steps to average

opt - options for end points

     In the following:

         N = {last point in the series, i.e. N = npts - 1}
         xi = {input series}
         xo = {output series}

     opt < 0 : utilize cyclic conditions
                e.g., nave = 2
                      xo(0) = (xi(0) + xi(1))/nave
                      xo(N) = (xi(N) + xi(0))/nave
                e.g., nave = 3
                      xo(0) = (xi(N) + xi(0) + xi(1)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(0)) / nave
                e.g., nave = 4
                      xo(0) = (xi(N) + xi(0) + xi(1) + xi(2)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(0) + xi(1)) / nave

     opt = 0 : set unsmoothed beginning and end pts to x@_FillValue [most common]
                e.g., nave = 2
                      xo(0) = (xi(0) + xi(1)) / nave
                      xo(N) = xi@_FillValue
                e.g., nave = 3
                      xo(0) = xi@_FillValue
                      xo(1) = (xi(0) + xi(1) + xi(2)) / nave
                      xi(N) = xi@_FillValue
                e.g., nave = 4
                      xo(0) = xi@_FillValue
                      xo(1) = (xi(0) + xi(1) + xi(2) + xi(3)) / nave
                      xo(N - 2) = (xi(N - 3) + xi(N - 2) + xi(N - 1) + xi(N)) / nave
                      xo(N - 1)= xi@_FillValue
                      xo(N)= xi@_FillValue

     opt > 0 : utilize reflective (symmetric) conditions
                e.g., nave = 2
                      xo(0) = (xi(0) + xi(1)) / nave
                      xo(N) = (xi(N) + xi(N-1)) / nave
                e.g., nave = 3
                      xo(0) = (xi(1) + xi(0) + xi(1)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(N-1)) / nave
                e.g., nave = 4
                      xo(0) = (xi(2) + xi(1) + xi(0) + xi(1)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(N - 1) + xi(N - 2)) / nave
 

Returns:

the new field

Throws:

visad.VisADException - On badness

timeRunningAverage

public static visad.FieldImpl timeRunningAverage(visad.FieldImpl grid,
                                                 int nave,
                                                 int opt,
                                                 boolean skipMissing)
                                          throws visad.VisADException

Create a running average across the time dimension.

Parameters:

grid - grid to average

nave - number of steps to average

opt - options for end points

     In the following:

         N = {last point in the series, i.e. N = npts - 1}
         xi = {input series}
         xo = {output series}

     opt < 0 : utilize cyclic conditions
                e.g., nave = 2
                      xo(0) = (xi(0) + xi(1))/nave
                      xo(N) = (xi(N) + xi(0))/nave
                e.g., nave = 3
                      xo(0) = (xi(N) + xi(0) + xi(1)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(0)) / nave
                e.g., nave = 4
                      xo(0) = (xi(N) + xi(0) + xi(1) + xi(2)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(0) + xi(1)) / nave

     opt = 0 : set unsmoothed beginning and end pts to x@_FillValue [most common]
                e.g., nave = 2
                      xo(0) = (xi(0) + xi(1)) / nave
                      xo(N) = xi@_FillValue
                e.g., nave = 3
                      xo(0) = xi@_FillValue
                      xo(1) = (xi(0) + xi(1) + xi(2)) / nave
                      xi(N) = xi@_FillValue
                e.g., nave = 4
                      xo(0) = xi@_FillValue
                      xo(1) = (xi(0) + xi(1) + xi(2) + xi(3)) / nave
                      xo(N - 2) = (xi(N - 3) + xi(N - 2) + xi(N - 1) + xi(N)) / nave
                      xo(N - 1)= xi@_FillValue
                      xo(N)= xi@_FillValue

     opt > 0 : utilize reflective (symmetric) conditions
                e.g., nave = 2
                      xo(0) = (xi(0) + xi(1)) / nave
                      xo(N) = (xi(N) + xi(N-1)) / nave
                e.g., nave = 3
                      xo(0) = (xi(1) + xi(0) + xi(1)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(N-1)) / nave
                e.g., nave = 4
                      xo(0) = (xi(2) + xi(1) + xi(0) + xi(1)) / nave
                      xo(N) = (xi(N - 1) + xi(N) + xi(N - 1) + xi(N - 2)) / nave
 

skipMissing - if true, missing timesteps will not be included in the average and the average will be done on the non-missing times

Returns:

the new field

Throws:

visad.VisADException - On badness

sumOverTime

public static visad.FieldImpl sumOverTime(visad.FieldImpl grid,
                                          boolean makeTimes)
                                   throws visad.VisADException

Sum each grid point

Parameters:

grid - grid to analyze

makeTimes - If true then make a time field with the range being the same computed value. If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

minOverTime

public static visad.FieldImpl minOverTime(visad.FieldImpl grid,
                                          boolean makeTimes)
                                   throws visad.VisADException

Take the min value at each grid point

Parameters:

grid - grid to analyze

makeTimes - If true then make a time field with the range being the same computed value. If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

maxOverTime

public static visad.FieldImpl maxOverTime(visad.FieldImpl grid,
                                          boolean makeTimes)
                                   throws visad.VisADException

Take the max value at each grid point

Parameters:

grid - grid to analyze

makeTimes - If true then make a time field with the range being the same computed value. If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverTime

public static visad.FieldImpl applyFunctionOverTime(visad.FieldImpl grid,
                                                    java.lang.String function,
                                                    boolean makeTimes)
                                             throws visad.VisADException

Apply the function to the time steps of the given grid. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

function - One of the FUNC_ enums

makeTimes - If true then make a time field with the range being the same computed value. If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverTime

public static visad.FieldImpl applyFunctionOverTime(visad.FieldImpl grid,
                                                    java.lang.String function,
                                                    int startIdx,
                                                    int idxStride,
                                                    boolean makeTimes)
                                             throws visad.VisADException

Apply the function to the time steps of the given grid. The function is one of the FUNC_ enums

Parameters:

grid - grid to apply function to

function - One of the FUNC_ enums

startIdx - starting time index

idxStride - stride for time index

makeTimes - If true then make a time field with the range being the same computed value. If false then just return a single field of the computed values

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverGrids

public static visad.FlatField applyFunctionOverGrids(visad.FlatField[] grids,
                                                     java.lang.String function)
                                              throws visad.VisADException

Apply the function to the grids. Grids must have the same domains The function is one of the FUNC_ enums

Parameters:

grids - grids to apply function to

function - One of the FUNC_ enums

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverGrids0

public static visad.FlatField applyFunctionOverGrids0(visad.FlatField[] grids,
                                                      java.lang.String function)
                                               throws visad.VisADException

Throws:

visad.VisADException

applyFunctionOverMembers

public static visad.FieldImpl applyFunctionOverMembers(visad.FieldImpl grid,
                                                       java.lang.String statThreshold,
                                                       java.lang.String exptdLoBoundIn,
                                                       java.lang.String exptdUpBoundIn,
                                                       java.lang.String function)
                                                throws visad.VisADException

Apply the function to the ens members of the given grid. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

statThreshold - percent for FUNC_PRCNTL, probability threshold for FUNC_UPROB

exptdLoBoundIn - expected lo bound

exptdUpBoundIn - expected hi bound

function - One of the FUNC_ enums

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverMembers

public static visad.FieldImpl applyFunctionOverMembers(visad.FieldImpl grid,
                                                       float statThreshold,
                                                       float exptdLoBound,
                                                       float exptdUpBound,
                                                       java.lang.String function)
                                                throws visad.VisADException

Apply the function to the ens members of the given grid. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

statThreshold - percent for FUNC_PRCNTL, probability threshold for FUNC_UPROB

exptdLoBound - expected lo bound

exptdUpBound - expected hi bound

function - One of the FUNC_ enums

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverMembers

public static visad.FieldImpl applyFunctionOverMembers(visad.FieldImpl grid,
                                                       java.lang.String function)
                                                throws visad.VisADException

Apply the function to the ens members of the given grid. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

function - One of the FUNC_ enums

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionOverLevels

public static visad.FieldImpl applyFunctionOverLevels(visad.FieldImpl grid,
                                                      java.lang.String function)
                                               throws visad.VisADException

Apply the function to the time steps of the given grid over the levels. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

function - One of the FUNC_ enums

Returns:

the new field with the function applied at each point over the levels.

Throws:

visad.VisADException - On badness

applyFunctionOverGrid2D

public static visad.FieldImpl applyFunctionOverGrid2D(visad.FieldImpl grid,
                                                      java.lang.String function,
                                                      java.lang.String statThreshold)
                                               throws visad.VisADException

Apply the function to the 2D grid. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

statThreshold - percent for FUNC_PRCNTL, probability threshold for FUNC_UPROB

function - One of the FUNC_ enums

Returns:

the new time series point field

Throws:

visad.VisADException - On badness

applyFunctionOverGrid2D

public static visad.FieldImpl applyFunctionOverGrid2D(visad.FieldImpl grid,
                                                      java.lang.String function,
                                                      visad.FieldImpl grid1,
                                                      java.lang.String function1,
                                                      float percentile)
                                               throws visad.VisADException

Evaluate the function of the grid and the function1 to the grid1.

Parameters:

grid - 2d grid to apply function (max, min, average)

grid1 - 2d grid to apply function1 (percentile)

function - One of the FUNC_ enums

function1 - another function name

Returns:

the new time series point field

Throws:

visad.VisADException - On badness

applyFunctionToLevels

public static visad.FieldImpl applyFunctionToLevels(visad.FieldImpl grid,
                                                    java.lang.String function)
                                             throws visad.VisADException

Apply the function to the time steps of the given grid at each level. The function is one of the FUNC_ enums

Parameters:

grid - grid to average

function - One of the FUNC_ enums

Returns:

the new field

Throws:

visad.VisADException - On badness

applyFunctionToAxis

public static visad.FieldImpl applyFunctionToAxis(visad.FieldImpl grid,
                                                  java.lang.String function,
                                                  java.lang.String axis)
                                           throws visad.VisADException

Apply the function to the x or y of the given grid at each level. The function is one of the FUNC_ enumerations

Parameters:

grid - grid to apply

function - One of the FUNC_ enumerations

axis - the axis to apply the function (AXIS_X or AXIS_Y)

Returns:

the new field

Throws:

visad.VisADException - On badness

ddx

public static visad.FieldImpl ddx(visad.FieldImpl grid)
                           throws visad.VisADException,
                                  java.rmi.RemoteException

Take the partial derivative with respect to X of the given field.

Parameters:

grid - grid to parialize

Returns:

partialized grid

Throws:

java.rmi.RemoteException - Java RMI error

visad.VisADException - VisAD Error

ddy

public static visad.FieldImpl ddy(visad.FieldImpl grid)
                           throws visad.VisADException,
                                  java.rmi.RemoteException

Take the partial derivative with respect to Y of the given field.

Parameters:

grid - grid to parialize

Returns:

partialized grid

Throws:

java.rmi.RemoteException - Java RMI error

visad.VisADException - VisAD Error

partial

public static visad.FieldImpl partial(visad.FieldImpl grid,
                                      int domainIndex)
                               throws visad.VisADException,
                                      java.rmi.RemoteException

Take the partial derivative with respect variable at the domain index.

Parameters:

grid - grid to parialize

domainIndex - index of variable to use for derivative

Returns:

partialized grid

Throws:

java.rmi.RemoteException - Java RMI error

visad.VisADException - VisAD Error

partial

public static visad.FieldImpl partial(visad.FieldImpl grid)
                               throws visad.VisADException,
                                      java.rmi.RemoteException

Throws:

visad.VisADException

java.rmi.RemoteException

evaluatePercentile

public static float evaluatePercentile(float[] values,
                                       int begin,
                                       int length,
                                       double p)
                                throws visad.VisADException

evaluate percentile value

Parameters:

values - the values

begin - the starting index

length - number of points

p - the percentage

Returns:

the percentile

Throws:

visad.VisADException - VisAD Error

evaluatePercentile

public static float evaluatePercentile(float[][] values,
                                       double p)
                                throws visad.VisADException

Throws:

visad.VisADException

evaluatePercentile

public static float evaluatePercentile(float[] values,
                                       double p)
                                throws visad.VisADException

Throws:

visad.VisADException

twoDConvert

public static float[] twoDConvert(float[][] nums)

evaluateMode

public static float evaluateMode(float[] data)

evaluate mode value

Parameters:

data - the data

Returns:

the percentile

evaluateUProbability

public static float evaluateUProbability(float[] values,
                                         float pValue,
                                         int length)
                                  throws visad.VisADException

evaluate univariate probability of "variable with n ensemble values" smaller than pValue code from $NAWIPS/gempak/source/diaglib/de/decprb.c used to make this function.

Parameters:

values - the values, within the userspecified range, at a given grid point from an ensemble model run

pValue - the threshold used in the probability calculation - P(value smaller than pValue)

length - number of ensemble members (might not be the same as values.length)

Returns:

prob the univariate probability that the value at the grid point is less than pValue

Throws:

visad.VisADException - VisAD Error

applyFunctionOverGridsExt

public static visad.FieldImpl applyFunctionOverGridsExt(visad.FieldImpl field,
                                                        java.lang.String function)
                                                 throws visad.VisADException

Throws:

visad.VisADException

calculateHelicity

public static visad.FieldImpl calculateHelicity(visad.FieldImpl gridu,
                                                visad.FieldImpl gridv,
                                                float bottom,
                                                float top,
                                                float ux,
                                                float vy)
                                         throws visad.VisADException

Calculate Helicity to the time steps of the given grid at each level.

Parameters:

gridu - u component grid

gridv - v component grid

bottom - in meter

top - in meter

ux - average u wind

vy - average v wind

Returns:

the new field

Throws:

visad.VisADException - On badness

subtractExt

public static visad.FieldImpl subtractExt(visad.FieldImpl grid,
                                          visad.FieldImpl grid2d)
                                   throws visad.VisADException,
                                          java.rmi.RemoteException

substractExt subtract a grid2d from each level of the 3d grid

Parameters:

grid - 3d grid

grid2d - 2d grid

Returns:

the new 3d grid

Throws:

visad.VisADException - On badness

java.rmi.RemoteException - for bad

replaceNegativeValue

public static visad.FieldImpl replaceNegativeValue(visad.FieldImpl grid,
                                                   float newValue)
                                            throws visad.VisADException,
                                                   java.rmi.RemoteException

Throws:

visad.VisADException

java.rmi.RemoteException

replacePositiveValue

public static visad.FieldImpl replacePositiveValue(visad.FieldImpl grid,
                                                   float newValue)
                                            throws visad.VisADException,
                                                   java.rmi.RemoteException

Throws:

visad.VisADException

java.rmi.RemoteException

statisticsFF

public static edu.wisc.ssec.mcidasv.data.hydra.Statistics statisticsFF(visad.FlatField grid)
                                                                throws visad.VisADException

Throws:

visad.VisADException

quantileTransformerFF

public static visad.FlatField quantileTransformerFF(visad.FlatField grid)
                                             throws visad.VisADException

Throws:

visad.VisADException

powerTransformerFF

public static visad.FlatField powerTransformerFF(visad.FlatField grid,
                                                 double lambda)
                                          throws visad.VisADException

Throws:

visad.VisADException

robustScalerFF

public static visad.FlatField robustScalerFF(visad.FlatField grid)
                                      throws visad.VisADException

Throws:

visad.VisADException

calculateL2Norm

public static float calculateL2Norm(float[] vector)

calculateL1Norm

public static float calculateL1Norm(float[] vector)