visad
Class FlatField

java.lang.Object
  |
  +--visad.ThingImpl
        |
        +--visad.DataImpl
              |
              +--visad.FunctionImpl
                    |
                    +--visad.FieldImpl
                          |
                          +--visad.FlatField
Direct Known Subclasses:
FileFlatField, JamaMatrix, SingleBandedImageImpl
public class FlatField
extends FieldImpl
implements FlatFieldIface

FlatField is the VisAD class for finite samplings of functions whose range type and range coordinate systems are simple enough to allow efficient representation. The DomainSet, DomainCoordinateSystem, RangeSet, RangeCoordinateSystem and RangeCoordinateSystems variables of FlatField are immutable.

A FlatField range type may be either a RealType (for a function with range = R), a RealTupleType (for a function with range = R^n for n > 0), or a TupleType of RealType-s and RealTupleType-s..

VisAD avoids invoking methods once per datum through the use of FlatField's. These are logically Field's of Tuple's of RealType's and RealTupleType's. Internally FlatField's are stored as arrays of numerical values, rather than the arrays of data objects stored in Field's. Many of the methods in the FlatField class and in other classes (e.g., CoordinateTransform, Set, Unit) process data in the form double[Dimension][Length] where Length is the number of samples in a Field and Dimension is the number of Tuple elements in the Field range values. Note that the order of the Length and Dimension indices are reversed as array indices. This allows efficient processing of long columns of Field value components. For example, if Latitude is one component of Field values, then any computation involving Latitude can be applied in a tight loop to all Latitude's in the Field.

FlatField's support range types more general than RealTuple's. To understand the motive, consider a set of observations that include Latitude, Longitude, Altitude, Pressure, Temperature, etc. We can organize these as a Field whose range values have the Tuple type:


(Latitude, Longitude, Altitude, Pressure, Temperature, ...)
However, in order to declare that (Latitude, Longitude, Altitude) is a coordinate system with coordinate transform functions to other spatial coordinate systems, we need to organize:


(Latitude, Longitude, Altitude)
as a RealTupleType. Hence the range type of the Field of observations must be:


((Latitude, Longitude, Altitude), Pressure, Temperature, ...)
which is not a RealTupleType (since one of its components is a RealTupleType). In order to process such data efficiently, FlatField's must support range types that are Tuple's of RealType's and RealTupleType's.

See Also:
Serialized Form

Inner classes inherited from class visad.DataImpl
DataImpl.Syncher
 
Inner classes inherited from class visad.ThingImpl
ThingImpl.RemotePair
 
Fields inherited from class visad.FieldImpl
DomainCoordinateSystem, DomainSet, DomainUnits, Length
 
Fields inherited from class visad.DataImpl
Type
 
Constructor Summary
FlatField(FunctionType type)
          Constructs a FlatField from a function type.
FlatField(FunctionType type, Set domain_set)
          Constructs a FlatField from a function type and a (non-default) domain Set.
FlatField(FunctionType type, Set domain_set, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
          Constructs a FlatField from a function type, a sampling set of the domain, coordinate systems for the range components, sampling sets for the range components, and units for the range components.
FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
          Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, coordinate systems for the range components, sampling sets for the range components, and units for the range components.
FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, Set[] range_sets, Unit[] units)
          Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, sampling sets for the range components, and units for the range components.
 
Method Summary
 Data adjustSamplingError(Data error, int error_mode)
          return a FlatField that clones this, except its ErrorEstimate-s are adjusted for sampling errors in error
 Data binary(Data data, int op, MathType new_type, int sampling_mode, int error_mode)
          Return new Field with value 'this op data'.
 void clearMissing()
          Mark this FlatField as non-missing
 Object clone()
          Clones this instance.
 DataShadow computeRanges(ShadowType type, DataShadow shadow)
           
 Field convertToField()
          convert this FlatField to a (non-Flat) FieldImpl
 Data derivative(int error_mode)
           
 Data derivative(MathType[] derivType_s, int error_mode)
           
 Data derivative(RealTuple location, RealType[] d_partial_s, MathType[] derivType_s, int error_mode)
           
 Function derivative(RealType d_partial, int error_mode)
           
 Function derivative(RealType d_partial, MathType derivType, int error_mode)
           
 boolean equals(Object obj)
           
 Field extract(int component)
          extract field from this[].component; this is OK, when we get around to it
static void fillField(FlatField image, double step, double half)
           
 Unit[] getDefaultRangeUnits()
          Get default range Unit-s for 'Flat' components.
 float[][] getFloats()
          Returns the range values in their default units as floats.
 float[][] getFloats(boolean copy)
          Returns the range values in their default units as floats.
 CoordinateSystem[] getRangeCoordinateSystem()
          Returns the range CoordinateSystem assuming that the range type is a RealTupleType (and throws a TypeException if its not).
 CoordinateSystem[] getRangeCoordinateSystem(int i)
          Returns the CoordinateSystem of a component of the range.
 int getRangeDimension()
          Gets the number of components in the "flat" range.
 ErrorEstimate[] getRangeErrors()
          return array of ErrorEstimates associated with each RealType component of range; each ErrorEstimate is a mean error for all samples of a range RealType component
 Set[] getRangeSets()
          Returns the sampling set of each flat component.
 Unit[][] getRangeUnits()
          return array of Units associated with each RealType component of range; these may differ from default Units of range RealTypes, but must be convertable; the second index has length = 1 (since all samples have the same Units)
 Data getSample(int index)
          Get the range value at the index-th sample.
 Data getSample(int index, boolean metadataOnly)
          A stub routine which simply invokes getSample to override FieldImpl.getSample
 String[][] getStringValues()
          Get String values for Text components
 double[][] getValues()
          Returns the range values in their default units as doubles.
 double[][] getValues(boolean copy)
          Returns the range values in their default units as doubles.
 double[] getValues(int s_index)
          Get values for 'Flat' components in default range Unit-s.
 byte[][] grabBytes()
           
 boolean isFlatField()
           
 boolean isMissing()
          Test whether range values are missing
 String longString(String pre)
           
static void main(String[] args)
          run 'java visad.FlatField' to test the FlatField class
static FlatField makeField(FunctionType type, int length, boolean irregular)
          construct a FlatField of given type; used for testing
static FlatField makeField1(FunctionType type, double first1, double last1, int length1, double first2, double last2, int length2)
          construct a FlatField with a 2-D domain and a 1-D range; used for testing
static FlatField makeField2(FunctionType type, double first1, double last1, int length1, double first2, double last2, int length2)
          construct a FlatField with a 2-D domain and a 2-D range; used for testing
(package private) static FlatField makeRandomField2(FunctionType type, double first1, double last1, int length1, double first2, double last2, int length2)
          construct a FlatField with a 2-D domain and a 2-D range and random values; used for testing
protected static void makeRational(double[][] values, Unit[] units, ErrorEstimate[] errors)
          Ensure that numeric values and units are in rational form, i.e.
protected static void makeRational(float[][] values, Unit[] units, ErrorEstimate[] errors)
           
 Field resample(Set set, int sampling_mode, int error_mode)
          Resamples the range to domain samples of a given set.
 void setRangeErrors(ErrorEstimate[] errors)
          Sets the ErrorEstimates associated with each RealType component of the range.
 void setSample(int index, Data range)
          Set the range value at the index-th sample
 void setSample(int index, Data range, boolean copy)
          Set the range value at the index-th sample
 void setSamples(Data[] range, boolean copy)
          set the range values of the function; the order of range values must be the same as the order of domain indices in the DomainSet; copy argument included for consistency with Field, but ignored
 void setSamples(double[][] range)
          set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet
 void setSamples(double[][] range, boolean copy)
          set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true
 void setSamples(double[][] range, ErrorEstimate[] errors, boolean copy)
          set the range values of the function including ErrorEstimate-s; the order of range values must be the same as the order of domain indices in the DomainSet
 void setSamples(float[][] range)
          set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet
 void setSamples(float[][] range, boolean copy)
          set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true
 void setSamples(float[][] range, ErrorEstimate[] errors, boolean copy)
          set the range values of the function including ErrorEstimate-s; the order of range values must be the same as the order of domain indices in the DomainSet
 void setSamples(int[] indices, double[][] range)
           
 void setSamples(int start, double[][] range)
          update a subset of a FlatField's range samples, where start is the index of the first sample to update and range[0].length is the number of samples to update; the array is dimensioned double[number_of_range_components][number_of_range_samples]
 String toString()
           
 Data unary(int op, MathType new_type, int sampling_mode, int error_mode)
          Return new FlatField with value 'this op'.
 float[][] unpackFloats()
          unpack an array of floats from field sample values according to the RangeSet-s; returns a copy
 double[][] unpackValues()
          unpack an array of doubles from field sample values according to the RangeSet-s; returns a copy
(package private)  String valuesString()
           
 
Methods inherited from class visad.FieldImpl
__getitem__, __len__, __setitem__, __setitem__, combine, combine, combine, combine, domainEnumeration, domainFactor, domainFactor, domainMultiply, domainMultiply, domainMultiply, domainMultiply, extract, extract, getDomainCoordinateSystem, getDomainSet, getDomainUnits, getLength, setSample, setSample
 
Methods inherited from class visad.FunctionImpl
__getitem__, __getitem__, evaluate, evaluate, evaluate, evaluate, getDomainDimension, resample
 
Methods inherited from class visad.DataImpl
__add__, __add__, __div__, __div__, __mod__, __mod__, __mul__, __mul__, __neg__, __pow__, __pow__, __radd__, __rdiv__, __rmod__, __rmul__, __rpow__, __rsub__, __sub__, __sub__, abs, abs, acos, acos, acosDegrees, acosDegrees, add, add, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, ceil, ceil, changeMathType, computeRanges, computeRanges, computeReferenceRanges, cos, cos, cosDegrees, cosDegrees, dataClone, divide, divide, exp, exp, floor, floor, getType, invertOp, local, log, log, longString, max, max, min, min, multiply, multiply, negate, negate, notifyReferences, pow, pow, remainder, remainder, rint, rint, round, round, setParent, sin, sin, sinDegrees, sinDegrees, sqrt, sqrt, subtract, subtract, tan, tan, tanDegrees, tanDegrees, unary
 
Methods inherited from class visad.ThingImpl
adaptedAddReference, adaptedRemoveReference, addReference, removeReference
 
Methods inherited from class java.lang.Object
, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Constructor Detail

FlatField

public FlatField(FunctionType type)
          throws VisADException
Constructs a FlatField from a function type. The domain Set is the default Set of the function domain.
Parameters:
type - The type of the function.
Throws:
VisADException - Couldn't create necessary VisAD object.

FlatField

public FlatField(FunctionType type,
                 Set domain_set)
          throws VisADException
Constructs a FlatField from a function type and a (non-default) domain Set.
Parameters:
type - The type of the function.
domain_set - The sampling set of the domain. May be null, in which case the sampling set is the default Set of the function domain.
Throws:
VisADException - Couldn't create necessary VisAD object.

FlatField

public FlatField(FunctionType type,
                 Set domain_set,
                 CoordinateSystem range_coord_sys,
                 Set[] range_sets,
                 Unit[] units)
          throws VisADException
Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, sampling sets for the range components, and units for the range components.
Parameters:
type - The type of the function.
domain_set - The sampling set of the domain. May be null, in which case the sampling set is set to the default sampling set of the function domain (i.e. type.getDomain().getDefaultSet()).
range_coord_sys - Optional coordinate system for the range. May be null. If non-null , then the range of the function shall be a RealTuple (i.e. type.getRange() instanceof RealTuple shall be true) and the reference coordinate system of the range coordinate system shall be the same as the reference coordiinate system of the function range (i.e. range_coord_sys().getReference().equals( ((RealTuple)type.getRange()).getReference()) shall be true).
range_sets - The sampling sets of the (flat) range components. May be null, in which case the default sampling sets of the range component RealType-s are used (i.e. ((RealType)type.getFlatRange().getComponent(i)) .getDefaultSet() for all i in the flat range). If non-null, then the ith flat range component values are stored in bytes if range_sets[i].getLength() < 256, stored in shorts if range_sets[i].getLength() < 65536, etc.
units - The units of the (flat) range components. May be null, in which case the default units of the flat range RealType-s are used.
Throws:
VisADException - Couldn't create necessary VisAD object.

FlatField

public FlatField(FunctionType type,
                 Set domain_set,
                 CoordinateSystem[] range_coord_syses,
                 Set[] range_sets,
                 Unit[] units)
          throws VisADException
Constructs a FlatField from a function type, a sampling set of the domain, coordinate systems for the range components, sampling sets for the range components, and units for the range components.
Parameters:
type - The type of the function.
domain_set - The sampling set of the domain. May be null, in which case the sampling set is set to the default sampling set of the function domain (i.e. type.getDomain().getDefaultSet()).
range_coord_syses - Optional coordinate systems for the range components. May be null. If the ith component of the range is a RealTuple, then range_coord_syses[i] may be non-null and, if so, is the coordinate system for that component and shall have the same reference coordinate system as the corresponding component in the range of the function type.
range_sets - The sampling sets of the (flat) range components. May be null, in which case the default sampling sets of the range component RealType-s are used (i.e. ((RealType)type.getFlatRange().getComponent(i)) .getDefaultSet() for all i in the flat range). If non-null, then the ith flat range component values are stored in bytes if range_sets[i].getLength() < 256, stored in shorts if range_sets[i].getLength() < 65536, etc.
units - The units of the (flat) range components. May be null, in which case the default units of the flat range RealType-s are used.
Throws:
VisADException - Couldn't create necessary VisAD object.

FlatField

public FlatField(FunctionType type,
                 Set domain_set,
                 CoordinateSystem range_coord_sys,
                 CoordinateSystem[] range_coord_syses,
                 Set[] range_sets,
                 Unit[] units)
          throws VisADException
Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, coordinate systems for the range components, sampling sets for the range components, and units for the range components. This is the most general constructor.
Parameters:
type - The type of the function.
domain_set - The sampling set of the domain. May be null, in which case the sampling set is set to the default sampling set of the function domain (i.e. type.getDomain().getDefaultSet()).
range_coord_sys - Optional coordinate system for the range. May be null. If non-null , then the range of the function shall be a RealTuple (i.e. type.getRange() instanceof RealTuple shall be true) and the reference coordinate system of the range coordinate system shall be the same as the reference coordiinate system of the function range (i.e. range_coord_sys().getReference().equals( ((RealTuple)type.getRange()).getReference()) shall be true).
range_coord_syses - Optional coordinate systems for the range components. May be null. If the ith component of the range is a RealTuple, then range_coord_syses[i] may be non-null and, if so, is the coordinate system for that component and shall have the same reference coordinate system as the corresponding component in the range of the function type.
range_sets - The sampling sets of the (flat) range components. May be null, in which case the default sampling sets of the range component RealType-s are used (i.e. ((RealType)type.getFlatRange().getComponent(i)) .getDefaultSet() for all i in the flat range). If non-null, then the ith flat range component values are stored in bytes if range_sets[i].getLength() < 256, stored in shorts if range_sets[i].getLength() < 65536, etc.
units - The units of the (flat) range components. May be null, in which case the default units of the flat range RealType-s are used.
Throws:
SetException - if range_sets is non-null and either one of its elements is null or an element's dimension is not one.
VisADException - Couldn't create necessary VisAD object.
Method Detail

getRangeCoordinateSystem

public CoordinateSystem[] getRangeCoordinateSystem()
                                            throws TypeException
Returns the range CoordinateSystem assuming that the range type is a RealTupleType (and throws a TypeException if its not). This may differ from default CoordinateSystem of range RealTupleType, but must be convertable; the index has length = 1 (since all samples have the same Units).
Returns:
The CoordinateSystem of the RealTuple range. Will not be null and will be of length 1.
Throws:
TypeException - The type of the range is neither RealType nor RealTupleType.
Overrides:
getRangeCoordinateSystem in class FieldImpl

getRangeSets

public Set[] getRangeSets()
Returns the sampling set of each flat component.
Specified by:
getRangeSets in interface FlatFieldIface
Returns:
The sampling set of each component in the flat range.

getRangeCoordinateSystem

public CoordinateSystem[] getRangeCoordinateSystem(int i)
                                            throws TypeException
Returns the CoordinateSystem of a component of the range. The MathType of the range shall be a TupleType.
Parameters:
i - The index of the component. The value shall be greater than or equal to zero and less that the number of components in the TupleType of the range.
Returns:
The CoordinateSystem of the i-th component. Won't be null and will be of length 1. The single element might be null.
Throws:
TypeException - The type of the range is either RealType or RealTupleType.
Overrides:
getRangeCoordinateSystem in class FieldImpl

getRangeUnits

public Unit[][] getRangeUnits()
return array of Units associated with each RealType component of range; these may differ from default Units of range RealTypes, but must be convertable; the second index has length = 1 (since all samples have the same Units)
Overrides:
getRangeUnits in class FieldImpl

getRangeErrors

public ErrorEstimate[] getRangeErrors()
return array of ErrorEstimates associated with each RealType component of range; each ErrorEstimate is a mean error for all samples of a range RealType component
Specified by:
getRangeErrors in interface FlatFieldIface

setRangeErrors

public void setRangeErrors(ErrorEstimate[] errors)
                    throws FieldException
Sets the ErrorEstimates associated with each RealType component of the range. errors[i] is the ErrorEstimate for the i-th RealType component.
Specified by:
setRangeErrors in interface FlatFieldIface
Parameters:
errors - The error estimates for the range values.
Throws:
FieldException - if errors is non-null and errors.length != getRangeDimension().

setSamples

public void setSamples(Data[] range,
                       boolean copy)
                throws VisADException,
                       RemoteException
set the range values of the function; the order of range values must be the same as the order of domain indices in the DomainSet; copy argument included for consistency with Field, but ignored
Overrides:
setSamples in class FieldImpl

setSamples

public void setSamples(double[][] range)
                throws VisADException,
                       RemoteException
set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet
Overrides:
setSamples in class FieldImpl

setSamples

public void setSamples(float[][] range)
                throws VisADException,
                       RemoteException
set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet
Overrides:
setSamples in class FieldImpl

setSamples

public void setSamples(double[][] range,
                       boolean copy)
                throws VisADException,
                       RemoteException
set range array as range values of this FlatField; the array is dimensioned double[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true
Specified by:
setSamples in interface FlatFieldIface

setSamples

public void setSamples(float[][] range,
                       boolean copy)
                throws VisADException,
                       RemoteException
set range array as range values of this FlatField; the array is dimensioned float[number_of_range_components][number_of_range_samples]; the order of range values must be the same as the order of domain indices in the DomainSet; copy array if copy flag is true
Specified by:
setSamples in interface FlatFieldIface

setSamples

public void setSamples(double[][] range,
                       ErrorEstimate[] errors,
                       boolean copy)
                throws VisADException,
                       RemoteException
set the range values of the function including ErrorEstimate-s; the order of range values must be the same as the order of domain indices in the DomainSet
Specified by:
setSamples in interface FlatFieldIface

setSamples

public void setSamples(int start,
                       double[][] range)
                throws VisADException,
                       RemoteException
update a subset of a FlatField's range samples, where start is the index of the first sample to update and range[0].length is the number of samples to update; the array is dimensioned double[number_of_range_components][number_of_range_samples]
Specified by:
setSamples in interface FlatFieldIface

setSamples

public void setSamples(int[] indices,
                       double[][] range)
                throws VisADException,
                       RemoteException

setSamples

public void setSamples(float[][] range,
                       ErrorEstimate[] errors,
                       boolean copy)
                throws VisADException,
                       RemoteException
set the range values of the function including ErrorEstimate-s; the order of range values must be the same as the order of domain indices in the DomainSet
Specified by:
setSamples in interface FlatFieldIface

grabBytes

public byte[][] grabBytes()
Specified by:
grabBytes in interface FlatFieldIface

unpackValues

public double[][] unpackValues()
                        throws VisADException
unpack an array of doubles from field sample values according to the RangeSet-s; returns a copy

unpackFloats

public float[][] unpackFloats()
                       throws VisADException
unpack an array of floats from field sample values according to the RangeSet-s; returns a copy

getFloats

public float[][] getFloats()
                    throws VisADException
Returns the range values in their default units as floats.
Returns:
The range values in their default units as determined by the MathType of the range. Element [i][j] is the jth sample value of the ith component of the range.
Throws:
VisADException - if a VisAD object couldn't be created.
Overrides:
getFloats in class FieldImpl

getFloats

public float[][] getFloats(boolean copy)
                    throws VisADException
Returns the range values in their default units as floats.
Parameters:
copy - Whether or not the returned array might be the actual range array. If true, then the returned array will not be the actual range array.
Returns:
The range values in their default units as determined by the MathType of the range. Element [i][j] is the jth sample value of the ith component of the range.
Throws:
VisADException - if a VisAD object couldn't be created.
Overrides:
getFloats in class FieldImpl

getValues

public double[][] getValues()
                     throws VisADException
Returns the range values in their default units as doubles.
Returns:
The range values in their default units as determined by the MathType of the range. Element [i][j] is the jth sample value of the ith component of the range.
Throws:
VisADException - if a VisAD object couldn't be created.
Overrides:
getValues in class FieldImpl

getValues

public double[][] getValues(boolean copy)
                     throws VisADException
Returns the range values in their default units as doubles.
Parameters:
copy - Whether or not the returned array might be the actual range array. If true, then the returned array will not be the actual range array.
Returns:
The range values in their default units as determined by the MathType of the range. Element [i][j] is the jth sample value of the ith component of the range.
Throws:
VisADException - if a VisAD object couldn't be created.
Overrides:
getValues in class FieldImpl

getStringValues

public String[][] getStringValues()
                           throws VisADException,
                                  RemoteException
Get String values for Text components
Returns:
null (there are none for FlatFields)
Throws:
VisADException - but doesn't happen
RemoteException - but doesn't happen
Overrides:
getStringValues in class FieldImpl

getValues

public double[] getValues(int s_index)
                   throws VisADException
Get values for 'Flat' components in default range Unit-s.
Specified by:
getValues in interface FlatFieldIface
Returns:
The range values in their default units as determined by the MathType of the range. Element [i] is the value of the ith component of the flattened range.
Throws:
VisADException - if a VisAD object couldn't be created.

getDefaultRangeUnits

public Unit[] getDefaultRangeUnits()
Get default range Unit-s for 'Flat' components.
Returns:
array of the default Units for each of the RealTypes components in the flattened range.
Overrides:
getDefaultRangeUnits in class FieldImpl

getSample

public Data getSample(int index)
               throws VisADException,
                      RemoteException
Get the range value at the index-th sample. FlatField does not override evaluate, but the correctness of FlatField.evaluate depends on overriding getSample
Returns:
Data object (Real, RealTuple, or Tuple) corresponding to the range at the index-th sample.
Throws:
VisADException - problem getting data
RemoteException - problem getting data from remote object
Overrides:
getSample in class FieldImpl

getSample

public Data getSample(int index,
                      boolean metadataOnly)
               throws VisADException,
                      RemoteException
A stub routine which simply invokes getSample to override FieldImpl.getSample
Parameters:
index - index of requested range sample
Throws:
VisADException - if a VisAD object couldn't be created.
RemoteException - if the Remote object couldn't be created.
Overrides:
getSample in class FieldImpl

setSample

public void setSample(int index,
                      Data range,
                      boolean copy)
               throws VisADException,
                      RemoteException
Set the range value at the index-th sample
Parameters:
index - index to set
range - range value to set
copy - flag to copy values - meaningless for FlatField
Throws:
VisADException - if range's MathType is incompatible or some other error.
RemoteException - if the Remote object couldn't be created.
Overrides:
setSample in class FieldImpl

setSample

public void setSample(int index,
                      Data range)
               throws VisADException,
                      RemoteException
Set the range value at the index-th sample
Parameters:
index - index to set
range - range value to set
copy - flag to copy values - meaningless for FlatField
Throws:
VisADException - if range's MathType is incompatible or some other error.
RemoteException - if the Remote object couldn't be created.
Overrides:
setSample in class FieldImpl

isMissing

public boolean isMissing()
Test whether range values are missing
Returns:
true if the range values have not been set
Overrides:
isMissing in class FieldImpl

clearMissing

public void clearMissing()
Mark this FlatField as non-missing
Specified by:
clearMissing in interface FlatFieldIface

binary

public Data binary(Data data,
                   int op,
                   MathType new_type,
                   int sampling_mode,
                   int error_mode)
            throws VisADException,
                   RemoteException
Return new Field with value 'this op data'. test for various relations between types of this and data; note return type may not be FlatField, in case data is a Field and this matches its range
Parameters:
data - object to operate on
op - operation to perform (e.g. ADD, SUB, MULT)
new_type - MathType of new object
sampling_mode - sampling mode to use (e.g., NEAREST_NEIGHBOR, WEIGHTED_AVERAGE)
error_mode - error estimate mode (e.g., NO_ERROR, DEPENDENT, independent)
Returns:
new Field corresponding to the requested operation
Throws:
VisADException - couldn't create new VisAD object
RemoteException - couldn't create new Remote object
Overrides:
binary in class FieldImpl

unary

public Data unary(int op,
                  MathType new_type,
                  int sampling_mode,
                  int error_mode)
           throws VisADException
Return new FlatField with value 'this op'.
Parameters:
op - operation to perform (e.g., NOP, ABS, COS)
new_type - MathType of new object
sampling_mode - sampling mode to use (e.g., NEAREST_NEIGHBOR, WEIGHTED_AVERAGE)
error_mode - error estimate mode (e.g., NO_ERROR, DEPENDENT, independent)
Returns:
new FlatField corresponding to the requested operation
Throws:
VisADException - couldn't create new VisAD object
RemoteException - couldn't create new Remote object
Overrides:
unary in class FieldImpl

makeRational

protected static void makeRational(double[][] values,
                                   Unit[] units,
                                   ErrorEstimate[] errors)
                            throws UnitException
Ensure that numeric values and units are in rational form, i.e. one in which ratios of data values make sense (e.g. Temperature values in Kelvin rather than Celsius). Additionally, if an input unit is a non-unity dimensionless unit, then the associated values will be converted to the dimensionless unity unit (this conditions the values for operations like exp() and pow()). All conversions are done in-place.
Parameters:
values - The numeric values. On output, values[i] will have been replaced if necessary.
units - The units for the values and error estimates. It's length shall be values.length. On output, units[i] will have been replaced with the absolute form of the input unit if necessary.
errors - The error estimates. It's length shall be values.length. On output, errors[i] will have been replaced if necessary.
Throws:
UnitException - Unit conversion error.

makeRational

protected static void makeRational(float[][] values,
                                   Unit[] units,
                                   ErrorEstimate[] errors)
                            throws UnitException

extract

public Field extract(int component)
              throws VisADException,
                     RemoteException
extract field from this[].component; this is OK, when we get around to it
Overrides:
extract in class FieldImpl

derivative

public Data derivative(RealTuple location,
                       RealType[] d_partial_s,
                       MathType[] derivType_s,
                       int error_mode)
                throws VisADException,
                       RemoteException
Overrides:
derivative in class FieldImpl

derivative

public Data derivative(int error_mode)
                throws VisADException,
                       RemoteException
Overrides:
derivative in class FieldImpl

derivative

public Data derivative(MathType[] derivType_s,
                       int error_mode)
                throws VisADException,
                       RemoteException
Overrides:
derivative in class FieldImpl

derivative

public Function derivative(RealType d_partial,
                           int error_mode)
                    throws VisADException,
                           RemoteException
Overrides:
derivative in class FieldImpl

derivative

public Function derivative(RealType d_partial,
                           MathType derivType,
                           int error_mode)
                    throws VisADException,
                           RemoteException
Overrides:
derivative in class FieldImpl

resample

public Field resample(Set set,
                      int sampling_mode,
                      int error_mode)
               throws VisADException,
                      RemoteException
Resamples the range to domain samples of a given set. Resampling is either by nearest neighbor or mulit-linear interpolation. NOTE: This code is very similar to FieldImpl.resample(Set,int,int).
Parameters:
set - The set of points at which to resample this field.
sampling_mode - Resampling mode: Data.NEAREST_NEIGHBOR or Data.WEIGHTED_AVERAGE
error_mode - Error estimation mode: Data.DEPENDENT, Data.INDEPENDENT, or Data.NO_ERRORS.
Returns:
Field of resampled data. RangeSet objects in result are set to DoubleSet. NOTE: May return this (i.e., not a copy).
Overrides:
resample in class FieldImpl

convertToField

public Field convertToField()
                     throws VisADException,
                            RemoteException
convert this FlatField to a (non-Flat) FieldImpl
Specified by:
convertToField in interface FlatFieldIface

computeRanges

public DataShadow computeRanges(ShadowType type,
                                DataShadow shadow)
                         throws VisADException
Overrides:
computeRanges in class FieldImpl

adjustSamplingError

public Data adjustSamplingError(Data error,
                                int error_mode)
                         throws VisADException,
                                RemoteException
return a FlatField that clones this, except its ErrorEstimate-s are adjusted for sampling errors in error
Overrides:
adjustSamplingError in class FieldImpl

isFlatField

public boolean isFlatField()
Overrides:
isFlatField in class FieldImpl

clone

public Object clone()
Clones this instance. Immutable fields are shallow copied. Range values, however, are deep copied.

Note that it is possible to simultaneously modify the domain-set of both this instance and the clone by modifying the values in the array returned by invoking getSamples(false) on the domain-set of either this instance or the clone. Don't do this unless you enjoy debugging.

Returns:
A clone of this instance.
Throws:
RuntimeException - if a VisADException occurs.
Overrides:
clone in class FieldImpl

valuesString

String valuesString()
              throws VisADException

toString

public String toString()
Overrides:
toString in class DataImpl

longString

public String longString(String pre)
                  throws VisADException
Overrides:
longString in class FieldImpl

getRangeDimension

public int getRangeDimension()
Gets the number of components in the "flat" range.
Specified by:
getRangeDimension in interface FlatFieldIface
Returns:
The number of components in the "flat" range.

equals

public boolean equals(Object obj)
Overrides:
equals in class FieldImpl

makeField

public static FlatField makeField(FunctionType type,
                                  int length,
                                  boolean irregular)
                           throws VisADException,
                                  RemoteException
construct a FlatField of given type; used for testing

fillField

public static void fillField(FlatField image,
                             double step,
                             double half)
                      throws VisADException,
                             RemoteException

makeField1

public static FlatField makeField1(FunctionType type,
                                   double first1,
                                   double last1,
                                   int length1,
                                   double first2,
                                   double last2,
                                   int length2)
                            throws VisADException,
                                   RemoteException
construct a FlatField with a 2-D domain and a 1-D range; used for testing

makeField2

public static FlatField makeField2(FunctionType type,
                                   double first1,
                                   double last1,
                                   int length1,
                                   double first2,
                                   double last2,
                                   int length2)
                            throws VisADException,
                                   RemoteException
construct a FlatField with a 2-D domain and a 2-D range; used for testing

makeRandomField2

static FlatField makeRandomField2(FunctionType type,
                                  double first1,
                                  double last1,
                                  int length1,
                                  double first2,
                                  double last2,
                                  int length2)
                           throws VisADException,
                                  RemoteException
construct a FlatField with a 2-D domain and a 2-D range and random values; used for testing

main

public static void main(String[] args)
                 throws VisADException,
                        RemoteException
run 'java visad.FlatField' to test the FlatField class