# Detailed description of the procedures for cssgrid

## CSSGRID - interpolation on a sphere

CSSGRID is called to interpolate data randomly spaced on a sphere.

CSSGRID uses tension splines to construct an interpolatory surface. As a first step, CSSGRID creates a Delaunay triangulation of the input data points; the companion entry CSSTRI is provided only for those times when you want to calculate the triangulation for independent inspection.

Various aspects of the interpolation algorithm can be changed by using the parmater access routines CSSETI and CSSETR to change values for the cssgrid control parematers.

```------------------------------------------------------------------
Argument | Type                |  Mode  | Dimension
------------------------------------------------------------------
CALL CSSGRID N,       | Integer             | Input  |
RLAT,    | Real                | Input  | N
RLON,    | Real                | Input  | N
F,       | Real                | Input  | N
NI,      | Integer             | Input  |
NJ,      | Integer             | Input  |
PLAT,    | Real                | Input  | NI
PLON,    | Real                | Input  | NJ
FF,      | Real                | Output | NI x NJ
IWK,     | Integer             | Input  | 27*N
RWK,     | Double precision    | Input  | 13*N
IER)     | Integer             | Output |
------------------------------------------------------------------
```
N
The number of input data points (N > 2).
RLAT,RLON
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
F
Array containing data values. F(I) is a functional value at (RLAT(I),RLON(I)) for I = 1 to N.
NI
The number of rows in the uniform output grid. NI can be 1.
NJ
The number of columns in the uniform output grid. NJ can be 1.
PLAT,PLON
Arrays of length NI and NJ, respectively, containing the latitudes and longitudes of the grid lines. The values for PLAT and PLON should be in degrees.
FF
An NI by NJ array containing the desired interpolated values. FF(I,J) is the interpolated value at the coordinate specified by PLAT(I) and PLON(J) for I = 1 to NI and J = 1 to NJ.
IWK
An integer workspace of length 27*N.
RWK
A DOUBLE PRECISION workspace of length at least 13*N. A common source of error in using CSSGRID is failing to type RWK as double precision.
IER
An error return value. If IER is returned as 0, then no errors were detected. If IER is non-zero, then refer to the error list in the error table for details.

## CSSTRI - calculates a Delaunay triangulation

CSSTRI is called to find a Delaunay triangulation of data randomly positioned on the surface of a sphere.
```-------------------------------------------------------------------
Argument | Type                |  Mode  | Dimension
-------------------------------------------------------------------
CALL CSSTRI (N,       | Integer             | Input  |
RLAT,    | Real                | Input  | N
RLON,    | Real                | Input  | N
NT,      | Integer             | Output |
NTRI,    | Integer             | Output | 3 x NT where NT=2*N
IWK,     | Integer             | Input  | 27*N
RWK,     | Double precision    | Input  | 13*N
IER)     | Integer             | Output |
-------------------------------------------------------------------
```
N
The number of input data points (N > 2).
RLAT,RLON
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
NT
The number of triangles in the triangulation, unless IER .NE. 0, in which case NT = 0. Let NB be the number of boundary points on the convex hull of the data. If NB .GE. 3, then NT = 2N-NB-2, otherwise NT=2N-4.
NTRI
A two-dimensional integer array dimensioned for 3 x NT where NT is the number of triangles in the triangulation (NT is at most 2*N). NTRI contains the triangulation data. The vertices of the Kth triangle are:
```         (PLAT(NTRI((1,K)),PLON(NTRI(1,K))
(PLAT(NTRI((2,K)),PLON(NTRI(2,K))
(PLAT(NTRI((3,K)),PLON(NTRI(3,K))
```
IWK
An integer workspace of length 27*N.
RWK
A DOUBLE PRECISION workspace of length at least 13*N. A common source of error in using CSSTRI is failing to type RWK as double precision.
IER
An error return value. If IER is returned as 0, then no errors were detected. If IER is non-zero, then refer to the error list in the error table for details.

## CSS2C - convert from lat/lon coordinates to Cartesian coordinates.

CSS2C is called to find the equivalent Cartesian coordinates on a unit sphere to specified latitude and longitude coordinates. The coordinate of 0. latitude and 0. longitude is converted to Cartesian coordinate (1.,0.,0.). Latitudes and longitudes are assumed to be in degrees.
```------------------------------------------------------------------
Argument | Type    |  Mode  | Dimension
------------------------------------------------------------------
CALL CSS2C (N,       | Integer | Input  |
RLAT,    | Real    | Input  | N
RLON,    | Real    | Input  | N
X,       | Real    | Output | N
Y,       | Real    | Output | N
Z)       | Real    | Output | N
------------------------------------------------------------------
```
N
The number of input lat/lon coordinates.
RLAT
An array containing the latitudes of the input coordinates, expressed in degrees.
RLON
An array containing the longitudes of the input coordinates, expressed in degrees.
X,Y,Z
Arrays containing the Cartesian coordinates of the output points. (X(I),Y(I),Z(I)) is the Cartesian coordinate corresponding to the lat/lon coordinate (RLAT(I),RLON(I)) for I=1 to N. X(I)**2 + Y(I)**2 + Z(I)**2 = 1 for I = 1 to N.

## CSC2S - convert from Cartesian coordinates on a unit sphere to lat/lon coordinates

CSC2S is called to find an equivalent latitude and longitude coordinates on a sphere to a specified Cartesian coordinate on the unit sphere. The coordinate (1.,0.,0.) is mapped to the latitude/longitude coordinate (0.,0.). The latitude/longitude coordinates are returned in degrees, latitudes between -90. and 90. (inclusive) and longitudes between -180. and 180. (inclusive).
```------------------------------------------------------------------
Argument | Type    |  Mode  | Dimension
------------------------------------------------------------------
CALL CSC2S (N,       | Integer | Input  |
X,       | Real    | Input  |  N
Y,       | Real    | Input  |  N
Z,       | Real    | Input  |  N
RLAT,    | Real    | Output |  N
RLON)    | Real    | Output |  N
------------------------------------------------------------------
```
N
The number of input (X,Y,Z) coordinates.
X,Y,Z
The Cartesian coordinates of the input points, X(I)**2 + Y(I)**2 + Z(I)**2 = 1 for I = 1 to N.
RLAT
The latitudes of the output coordinates, in degrees.
RLON
The longitudes of the output coordinates, in degrees.

## CSVORO - calculate Voronoi polygons.

CSVORO is called if you want to determine the Voronoi polygons for data randomly positioned on a sphere. Each call to CSVORO calculates the vertices for the Voronoi polygon surrounding a specified input point.
```------------------------------------------------------------------
Argument | Type              |  Mode  | Dimension
------------------------------------------------------------------
CALL CSVORO (NPTS,    | Integer           | Input  |
RLATI,   | Real              | Input  | N
RLONI,   | Real              | Input  | N
NI,      | Integer           | Input  |
NF,      | Integer           | Input  |
IWK,     | Integer           | Input  | 27*NPTS
RWK,     | Double precision  | Input  | 9*NPTS
NC,      | Integer           | Input  |
RLATO,   | Real              | Input  | NC
RLONO,   | Real              | Input  | NC
RC,      | Real              | Output | NC
NCA,     | Integer           | Output |
NUMV,    | Integer           | Output |
NV,      | Integer           | Output | NPTS
IER)     | Integer           | Output |
------------------------------------------------------------------
```
NPTS
The number of input data points (NPTS > 3).
RLATI
An array, dimensioned for NPTS, containing the latitudes of the input coordinates, in degrees.
RLONI
An array, dimensioned for NPTS, containing the longitudes of the input coordinates, in degrees.
NI
The index of the input coordinate for which you want to determine the Voronoi polygon (1 .LE. NI .LE. NPTS).
NF
Flag indicating if this is the first call to CSVORO to retrieve Voronoi polygons for this dataset (1=yes, 0=no). Calls subsequent to the first call for a given dataset are much faster than the first call.
IWK
Integer work space dimensioned for 27*NPTS.
RWK
DOUBLE PRECISION work space dimensioned for 9*NPTS.
NC
The maximum size of the output arrays RLATO, RLONO, and RC. NC should be 2*NPTS.
RLATO
An array of latitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. RLATO is returned in degrees.
RLONO
An array of longitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. RLONO is returned in degrees.
RC
Array containing circumradii (arc lengths in degrees of the angle between a circumcenter and its associated triangle vertices).
NCA
The actual number of circumcenters returned in RLATO and RLONO. This number may be larger than NPTS if the input dataset has boundary points since certain "pseudo points" may have been added to the original dataset in order to complete the Voronoi polygon set.
NUMV
The number of vertices in the Voronoi polygon enclosing the coordinate (RLATI(NI),RLONI(NI)).
NV
An array (dimensioned for NPTS) containing NUMV indices for the Voronoi polygon enclosing the coordinate (RLATI(NI),RLONI(NI)). The indices returned in this array refer to the coordinates returned in RLATO, RLONO, and RC. For example, if the integer "J" is an element of the NV array, then (RLATO(J),RLONO(J)) is a vertex of the Voronoi polygon enclosing (RLATI(NI),RLONI(NI)). The indices in NV list out the vertices of the Voronoi polygon in counter-clockwise order.
IER
An error return value. If IER is returned as 0, then no errors were detected. If IER is non-zero, then refer to the error list in the error table for details.

## CSSETI - set INTEGER parameter values

CSSETI is used to set values for any of the cssgrid control parameters that take integer values. The values set by CSSETI remain in effect until changed by subsequent calls to CSSETI.
```-----------------------------------------------------
Argument | Type      |  Mode  | Dimension
-----------------------------------------------------
CALL CSSETI (PNAM,   | Character | Input  |
IVAL)   | Integer   | Input  |
-----------------------------------------------------
```
PNAM
The name of the control parameter to be set.
IVAL
The value to be assigned to the parameter.

## CSGETI - retrieve values for INTEGER parameters

CSGETI is a called to obtain current values for any of the INTEGER valued cssgrid control parameters.
```-----------------------------------------------------
Argument | Type      |  Mode  | Dimension
-----------------------------------------------------
CALL CSGETI (PNAM,   | Character | Input  |
IVAL)   | Integer   | Output |
-----------------------------------------------------
```
PNAM
The name of the control parameter whose value is to be retrieved.
IVAL
The current value assigned to the control parameter.

## CSSETR - set REAL parameter values

CSSETR is used to set values for any of the cssgrid control parameters that take REAL values. The values set by CSSETR remain in effect until changed by subsequent calls to CSSETR.
```-----------------------------------------------------
Argument | Type      |  Mode  | Dimension
-----------------------------------------------------
CALL CSSETR (PNAM,   | Character | Input  |
RVAL)   | Real      | Input  |
-----------------------------------------------------
```
PNAM
The name of the control parameter to be set.
RVAL
The value to be assigned to the parameter.

## CSGETR - retrieve values for REAL parameters

CSGETR is a called to obtain current values for any of the REAL valued cssgrid control parameters.
```-----------------------------------------------------
Argument | Type      |  Mode  | Dimension
-----------------------------------------------------
CALL CSGETR (PNAM,   | Character | Input  |
RVAL)   | Real      | Output |
-----------------------------------------------------
```
PNAM
The name of the control parameter whose value is to be retrieved.
RVAL
The current value assigned to the control parameter.

## CSSETD - set DOUBLE PRECISION parameter values

CSSETD is used to set values for any of the cssgrid control parameters that take DOUBLE PRECISION values. The values set by CSSETD remain in effect until changed by subsequent calls to CSSETD.
```---------------------------------------------------------------
Argument | Type               |  Mode  | Dimension
---------------------------------------------------------------
CALL CSSETD (PNAM,   | Character          | Input  |
DVAL)   | Double precision   | Input  |
---------------------------------------------------------------
```
PNAM
The name of the control parameter to be set.
DVAL
The value to be assigned to the parameter.

## CSGETD - retrieve values for DOUBLE PRECISION parameters

CSGETD is a called to obtain current values for any of the REAL valued cssgird control parameters.
```------------------------------------------------------------------
Argument | Type                  |  Mode  | Dimension
------------------------------------------------------------------
CALL CSGETD (PNAM,   | Character             | Input  |
DVAL)   | Double precision      | Output |
------------------------------------------------------------------
```
PNAM
The name of the control parameter whose value is to be retrieved.
DVAL
The current value assigned to the control parameter.

## CSSGRIDD - interpolation on a sphere

CSSGRIDD is called to interpolate data randomly spaced on a sphere. CSSGRIDD is a double precision version of CSSGRID.

CSSGRIDD uses tension splines to construct an interpolatory surface. As a first step, CSSGRIDD creates a Delaunay triangulation of the input data points; the companion entry CSSTRI is provided only for those times when you want to calculate the triangulation for independent inspection.

Various aspects of the interpolation algorithm can be changed by using the parmater access routines CSSETI and CSSETD to change values for the cssgridd control parematers.

```------------------------------------------------------------------
Argument | Type                |  Mode  | Dimension
------------------------------------------------------------------
CALL CSSGRIDD N,       | Integer             | Input  |
RLAT,    | Double precision    | Input  | N
RLON,    | Double precision    | Input  | N
F,       | Double precision    | Input  | N
NI,      | Integer             | Input  |
NJ,      | Integer             | Input  |
PLAT,    | Double precision    | Input  | NI
PLON,    | Double precision    | Input  | NJ
FF,      | Double precision    | Output | NI x NJ
IWK,     | Integer             | Input  | 27*N
RWK,     | Double precision    | Input  | 13*N
IER)     | Integer             | Output |
------------------------------------------------------------------
```
N
The number of input data points (N > 2).
RLAT,RLON
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
F
Array containing data values. F(I) is a functional value at (X(I),Y(I),Z(I)) for I = 1 to N.
NI
The number of rows in the uniform output grid. NI can be 1.
NJ
The number of columns in the uniform output grid. NJ can be 1.
PLAT,PLON
Arrays of length NI and NJ, respectively, containing the latitudes and longitudes of the grid lines. The values for PLAT and PLON should be in radians.
FF
An NI by NJ array containing the desired interpolated values. FF(I,J) is the interpolated value at the coordinate specified by PLAT(I) and PLON(J) for I = 1 to NI and J = 1 to NJ.
IWK
An integer workspace of length 27*N.
RWK
A DOUBLE PRECISION workspace of length at least 13*N.
IER
An error return value. If IER is returned as 0, then no errors were detected. If IER is non-zero, then refer to the error list in the error table for details.

## CSSTRID - calculates a Delaunay triangulation

CSSTRID is called to find a Delaunay triangulation of data randomly positioned on the surface of a sphere. CSSTRID is a double precision version of CSSTRI.
```-------------------------------------------------------------------
Argument | Type                |  Mode  | Dimension
-------------------------------------------------------------------
CALL CSSTRID (N,       | Integer             | Input  |
RLAT,    | Double precision    | Input  | N
RLON,    | Double precision    | Input  | N
NT,      | Integer             | Output |
NTRI,    | Integer             | Output | 3 x NT where NT=2*N
IWK,     | Integer             | Input  | 27*N
RWK,     | Double precision    | Input  | 13*N
IER)     | Integer             | Output |
-------------------------------------------------------------------
```
N
The number of input data points (N > 2).
RLAT,RLON
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
NT
The number of triangles in the triangulation, unless IER .NE. 0, in which case NT = 0. Let NB be the number of boundary points on the convex hull of the data. If NB .GE. 3, then NT = 2N-NB-2, otherwise NT=2N-4. The input data are considered to be bounded if they all lie in one hemisphere.
NTRI
A two-dimensional integer array dimensioned for 3 x NT where NT is the number of triangles in the triangulation (NT is at most 2*N). NTRI contains the triangulation data. The vertices of the Kth triangle are:
```         (PLAT(NTRI((1,K)),PLON(NTRI(1,K))
(PLAT(NTRI((2,K)),PLON(NTRI(2,K))
(PLAT(NTRI((3,K)),PLON(NTRI(3,K))
```
IWK
An integer workspace of length 27*N.
RWK
A DOUBLE PRECISION workspace of length at least 13*N.
IER
An error return value. If IER is returned as 0, then no errors were detected. If IER is non-zero, then refer to the error list in the error table for details.

## CSS2CD - convert from lat/lon coordinates to Cartesian coordinates.

CSS2CD is called to find the equivalent Cartesian coordinates on a unit sphere to specified latitude and longitude coordinates. The coordinate of 0. latitude and 0. longitude is converted to Cartesian coordinate (1.,0.,0.). Latitudes and longitudes are assumed to be in degrees. CSS2CD is a double precision version of CSS2C.
```------------------------------------------------------------------
Argument | Type             |  Mode  | Dimension
------------------------------------------------------------------
CALL CSS2CD (N,       | Integer          | Input  |
RLAT,    | Double precision | Input  | N
RLON,    | Double precision | Input  | N
X,       | Double precision | Output | N
Y,       | Double precision | Output | N
Z)       | Double precision | Output | N
------------------------------------------------------------------
```
N
The number of input lat/lon coordinates.
RLAT
An array containing the latitudes of the input coordinates, expressed in degrees.
RLON
An array containing the longitudes of the input coordinates, expressed in degrees.
X,Y,Z
Arrays containing the Cartesian coordinates of the output points. (X(I),Y(I),Z(I)) is the Cartesian coordinate corresponding to the lat/lon coordinate (RLAT(I),RLON(I)) for I=1 to N. X(I)**2 + Y(I)**2 + Z(I)**2 = 1 for I = 1 to N.

## CSC2SD - convert from Cartesian coordinates on a unit sphere to lat/lon coordinates

CSC2SD is called to find an equivalent latitude and longitude coordinates on a sphere to a specified Cartesian coordinate on the unit sphere. The coordinate (1.,0.,0.) is mapped to the latitude/longitude coordinate (0.,0.). The latitude/longitude coordinates are returned in degrees, latitudes between -90. and 90. (inclusive) and longitudes between -180. and 180. (inclusive). CSC2SD is a double precision version of CSC2S.
```------------------------------------------------------------------
Argument | Type             |  Mode  | Dimension
------------------------------------------------------------------
CALL CSC2SD (N,       | Integer          | Input  |
X,       | Double precision | Input  |  N
Y,       | Double precision | Input  |  N
Z,       | Double precision | Input  |  N
RLAT,    | Double precision | Output |  N
RLON)    | Double precision | Output |  N
------------------------------------------------------------------
```
N
The number of input (X,Y,Z) coordinates.
X,Y,Z
The Cartesian coordinates of the input point, X(I)**2 + Y(I)**2 + Z(I)**2 = 1 for I = 1 to N.
RLAT
The latitude of the output coordinates, in degrees.
RLON
The longitude of the output coordinates, in degrees.

## CSVOROD - calculate Voronoi polygons.

CSVOROD is called if you want to determine the Voronoi polygons for data randomly positioned on a sphere. Each call to CSVOROD calculates the vertices for the Voronoi polygon surrounding a specified input point. CSVOROD is a double precision version of CSVORO.
```------------------------------------------------------------------
Argument | Type             |  Mode  | Dimension
------------------------------------------------------------------
CALL CSVOROD (NPTS,    | Integer          | Input  |
RLATI,   | Double precision | Input  | N
RLONI,   | Double precision | Input  | N
NI,      | Integer          | Input  |
NF,      | Integer          | Input  |
IWK,     | Integer          | Input  | 27*NPTS
RWK,     | Double precision | Input  | 9*NPTS
NC,      | Integer          | Input  |
RLATO,   | Double precision | Input  | NC
RLONO,   | Double precision | Input  | NC
RC,      | Double precision | Output | NC
NCA,     | Integer          | Output |
NUMV,    | Integer          | Output |
NV,      | Integer          | Output | NPTS
IER)     | Integer          | Output |
------------------------------------------------------------------
```
NPTS
The number of input data points (NPTS > 3).
RLATI
An array, dimensioned for NPTS, containing the latitudes of the input coordinates, in degrees.
RLONI
An array, dimensioned for NPTS, containing the longitudes of the input coordinates, in degrees.
NI
The index of the input coordinate for which you want to determine the Voronoi polygon (1 .LE. NI .LE. NPTS).
NF
Flag indicating if this is the first call to CSVORO to retrieve Voronoi polygons for this dataset (1=yes, 0=no). Calls subsequent to the first call for a given dataset are much faster than the first call.
IWK
Integer work space dimensioned for 27*NPTS.
RWK
DOUBLE PRECISION work space dimensioned for 9*NPTS.
NC
The maximum size of the output arrays RLATO, RLONO, and RC. NC should be 2*NPTS.
RLATO
An array of latitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. RLATO is returned in degrees.
RLONO
An array of longitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. RLONO is returned in degrees.
RC
Array containing circumradii (arc lengths in degrees of the angle between a circumcenter and its associated triangle vertices).
NCA
The actual number of circumcenters returned in RLATO and RLONO. This number may be larger than NPTS if the input dataset has boundary points since certain "pseudo points" may have been added to the original dataset in order to complete the Voronoi polygon set.
NUMV
The number of vertices in the Voronoi polygon enclosing the coordinate (RLATI(NI),RLONI(NI)).
NV
An array (dimensioned for NPTS) containing NUMV indices for the Voronoi polygon enclosing the coordinate (RLATI(NI),RLONI(NI)). The indices returned in this array refer to the coordinates returned in RLATO, RLONO, and RC. For example, if the integer "J" is an element of the NV array, then (RLATO(J),RLONO(J)) is a vertex of the Voronoi polygon enclosing (RLATI(NI),RLONI(NI)). The indices in NV list out the vertices of the Voronoi polygon in counter-clockwise order.
IER
An error return value. If IER is returned as 0, then no errors were detected. If IER is non-zero, then refer to the error list in the error table for details.

## c_cssgrid - interpolation on a sphere

c_cssgrid is called to interpolate function values starting with data randomly spaced on a sphere.

c_cssgrid uses tension splines to construct an interpolatory surface. As a first step, c_cssgrid creates a Delaunay triangulation of the input data points; the companion entry c_csstri is provided only for those times when you want to calculate the triangulation for independent inspection.

Various aspects of the interpolation algorithm can be changed by using the parmater access routines c_csseti and c_cssetr to change values for the cssgrid control parematers.

Function prototype:

```  float *c_cssgrid(int, float [], float [], float [],
int, int, float [], float [], int *);
```

Usage:

```-------------------------------------------------
Argument | Type     |  Size
-------------------------------------------------
float *c_cssgrid (n,       | int      |
rlat,    | float [] | n
rlon,    | float [] | n
f,       | float [] | n
nlat,    | int      |
nlon,    | int      |
plat,    | float [] | ni
plon,    | float [] | nj
ier      | int *    |
);
-------------------------------------------------
```
n
The number of input data points, n > 2.
rlat,rlon
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
f
Array containing data values. f[i] is the functional value at (rlat[i],rlon[i]) for i = 0 to n-1.
ni
The number of latitudes in the interpolated grid.
nj
The number of longitudes in the interpolated grid. ni and nj can both be 1, allowing for interpolation at a single point.
plat
An array containing the latitudes of the points where interpolated values are to be computed. The values in plat should be in degrees.
plon
An array containing the longitudes of the points where interpolated values are to be computed. The values in plon should be in degrees.
ier
An error return value. If *ier is returned as 0, then no errors were detected. If *ier is non-zero, then refer to the error list in the error table for details.
Return value:

c_cssgrid returns a pointer to a linear array of data that contains interpolated values at user-specified lat/lon pairs. The returned array stores its values as if they were a 2-dimensional C array with latitude being the first dimension and longitude the second dimension. That is, if out is declared as

```  float *out;
```
and we set:
```  out = c_cssgrid(n, rlat, rlon, f, nlat, nlon, plat, plon, &ier);
```
then out[i*nlon+j] is the interpolated function value at coordinate point (plat[i], plon[j]) for 0 <= i < nlat and 0 <= j < nlon. The space for out is allocated internal to c_cssgrid and is nlat * nlon floats in size.

## c_csstri - calculates a Delaunay triangulation

c_csstri is called to find a Delaunay triangulation of data randomly positioned on the surface of a sphere.

Function prototype:

```  int   *c_csstri(int, float [], float [], int *, int *);

```
Usage:
```
-------------------------------------------------
Argument | Type     |  Size
-------------------------------------------------
int *c_csstri (n,       | int      |
rlat,    | float [] | n
rlon,    | float [] | n
nt,      | int *    |
ier      | int *    |
);
-------------------------------------------------
```
n
The number of input data points, n > 2.
rlat,rlon
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
nt
*nt is the number of triangles in the triangulation, unless *ier is non-zero, in which case *nt = 0. Where nb is the number of boundary points on the convex hull of the data, if nb is greater than 3, then *nt = 2n-nb-2, otherwise *nt = 2n-4. The input data are considered to be bounded if they all lie in one hemisphere.
ier
An error return value. If *ier is returned as 0, then no errors were detected. If *ier is non-zero, then refer to the error list in the error table for details.
Return value:

c_csstri returns a pointer to a linear array that contains a sequence of integer triples. The elements of a triple are indices of vertices of a triangle. Each index references an original data point as it occurs in sequence in the input data set (numbering starts at 0). For example, if the triple <5,0,2> were in the list of triples, then (rlat[5],rlon[5]), (rlat[0],rlon[0]), and (rlat[2],rlon[2]) would be vertices of a triangle in the Delaunay triangulation.

## c_css2c - converts from lat/lon to Cartesian coordinates

c_css2c is called to find the equivalent Cartesian coordinates on a unit sphere to specified latitude and longitude coordinates on a sphere. The coordinate of 0. latitude and 0. longitude is converted to Cartesian coordinate (1.,0.,0.). Latitudes and longitudes are assumed to be in degrees.

Function prototype:

```  void   c_css2c(int, float *, float *, float *, float *, float *);

```
Usage:
```
-------------------------------------------------
Argument | Type     |  Size
-------------------------------------------------
void c_css2c (n,       | int      |
plat,    | float *  | n
plon,    | float *  | n
x,       | float *  | n
y,       | float *  | n
z        | float *  | n
);
-------------------------------------------------
```
n
The number of coordinates to be converted.
plat
Contains the latitudes of the input coordinates.
plon
Contains the longitudes of the input coordinates.
x,y,z
Contains the Cartesian coordinates of the output points. These lie on the unit sphere.

## c_csc2s - convert from Cartesian coordinates to lat/lon coordinates

c_csc2s converts Cartesian coordinates on a unit sphere to lat/lon coordinates. The coordinate (1.,0.,0.) is mapped to the latitude/longitude coordinate (0.,0.). The latitude/longitude coordinates are returned in degrees.

Function prototype:

```     void   c_csc2s(int, float *, float *, float *, float *, float *);
```
Usage:
```--------------------------------------------
Argument | Type     | Size
--------------------------------------------
void c_csc2s (n,       | int      |
x,       | float *  |
y,       | float *  |
z,       | float *  |
plat,    | float *  |
plon,    | float *  |
)
--------------------------------------------
```
n
The number of coordinates to be converted.
x,y,z
Cartesian coordinates on the unit sphere.
plat, plon
(plat[i], plon[i]) is the latitude/longitude coordinate equivalent to (x[i],y[i],z[i]) for i equal 0 to n-1. plat and plon are in degrees.

## c_csvoro - calculate Voronoi polygons

c_csvoro is called if you want to determine the Voronoi polygons for data randomly positioned on a sphere. Each call to c_csvoro calculates the vertices for the Voronoi polygon surrounding a specified input point.

Function prototype:

```void   c_csvoro(int, float [], float [], int, int,
float [], float [], float [], int *,
int *, int [], int *);
```
Usage:
```-------------------------------------------------
Argument | Type     |  Size
-------------------------------------------------
void *c_csvoro (n,       | int      |
rlat,    | float [] | n
rlon,    | float [] | n
ni,      | int      |
nf,      | int      |
plat,    | float [] | 2*n
plon,    | float [] | 2*n
rc,      | float [] | 2*n
nca,     | int *    |
numv,    | int *    |
nv,      | int []   | n
ier      | int *    |
);
-------------------------------------------------
```
n
The number of input data points (n > 3).
rlat
An array containing the latitudes of the input coordinates, in degrees.
rlon
An array containing the longitudes of the input coordinates, in degrees.
ni
The index of the input coordinate for which you want to determine the Voronoi polygon (0 <= ni < n-1).
nf
Flag indicating if this is the first call to c_csvoro to retrieve Voronoi polygons for this dataset (1=yes, 0=no). Calls subsequent to the first call for a given dataset are much faster than the first call.
plat
An array of latitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. plat is returned in degrees.
plon
An array of longitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. plon is returned in degrees.
rc
Array containing circumradii (arc lengths in degrees of the angle between a circumcenter and its associated triangle vertices).
nca
*nca is the actual number of circumcenters returned in plat and plon. This number may be larger than n if the input dataset has boundary points, since certain "pseudo points" may have been added to the original dataset in order to complete the Voronoi polygon set.
numv
*numv is the number of vertices in the Voronoi polygon enclosing the coordinate (rlat[ni],rlon[ni]).
nv
An array containing numv indices for the Voronoi polygon enclosing the coordinate (rlat[ni],rlon[ni]). The indices returned in this array refer to the coordinates returned in plat and plon. For example, if the integer "j" is an element of the nv array, then (plat[j],plon[j]) is a vertex of the Voronoi polygon enclosing (rlat[ni],rlon[ni]). The indices in nv list out the vertices of the Voronoi polygon in counter-clockwise order.
ier
An error return value. If *ier is returned as 0, then no errors were detected. If *ier is non-zero, then refer to the error list in the error table for details.

## c_csseti - Set int valued parameters

c_csseti is used to set values for any of the cssgrid control parameters that take int values. The values set by c_csseti remain in effect until changed by subsequent calls to c_csseti.

Function prototype:

```  void c_csseti(char *, int);
```
Argument description:
```-------------------------------------------
Argument | Type    |  Size
-------------------------------------------
void c_csseti (pnam,   | char *  |
ival);  | int     |
-------------------------------------------
```
pnam
The name of the control parameter to be assigned an int value.
ival
The value to be assigned to the control parameter whose name is pointed to by pnam.

## c_csgeti - Retrieve an int valued parameter

c_csgeti is a called to obtain current values for any of the int valued cssgrid control parameters.

Function prototype:

```  void c_csgeti(char *, int *);
```
Argument description:
```-------------------------------------------
Argument | Type    |  Size
-------------------------------------------
void c_csgeti (pnam,   | char *  |
ival);  | int  *  |
-------------------------------------------
```
pnam
The name of the control parameter whose value is to be retrieved.
ival
*ival will be the value currently assigned to the control parameter whose name is pointed to by pnam.

## c_cssetr - Set float valued parameters

c_cssetr is used to set values for any of the cssgrid control parameters that take float values. The values set by c_cssetr remain in effect until changed by subsequent calls to c_cssetr.

Function prototype:

```  void c_cssetr(char *, float);
```
Argument description:
```-------------------------------------------
Argument | Type    |  Size
-------------------------------------------
void c_cssetr (pnam,   | char *  |
fval);  | float   |
-------------------------------------------
```
pnam
The name of the control parameter to be assigned a float value.
fval
The value to be assigned to the control parameter whose name is pointed to by pnam.

## c_csgetr - Retrieve a float valued parameter

c_csgetr is a called to obtain current values for any of the float valued cssgrid control parameters.

Function prototype:

```  void c_csgetr(char *, float *);
```
Argument description:
```-------------------------------------------
Argument | Type    |  Size
-------------------------------------------
void c_csgetr (pnam,   | char *  |
fval);  | float * |
-------------------------------------------
```
pnam
The name of the control parameter whose value is to be retrieved.
fval
*fval will be the value currently assigned to the control parameter whose name is pointed to by pnam.

## c_cssetd - Set double precision valued parameters

c_cssetd is used to set values for any of the cssgrid control parameters that take double precision values. The values set by c_cssetd remain in effect until changed by subsequent calls to c_cssetd.

Function prototype:

```  void c_cssetd(char *, double);
```
Argument description:
```-------------------------------------------
Argument | Type     |  Size
-------------------------------------------
void c_cssetd (pnam,   | char *   |
dval);  | double   |
-------------------------------------------
```
pnam
The name of the control parameter to be assigned a float value.
dval
The value to be assigned to the control parameter whose name is pointed to by pnam.

## c_csgetd - Retrieve a float valued parameter

c_csgetd is a called to obtain current values for any of the double precision valued cssgrid control parameters.

Function prototype:

```  void c_csgetd(char *, double *);
```
Argument description:
```-------------------------------------------
Argument | Type     |  Size
-------------------------------------------
void c_csgetd (pnam,   | char *   |
dval);  | double * |
-------------------------------------------
```
pnam
The name of the control parameter whose value is to be retrieved.
dval
*dval will be the value currently assigned to the control parameter whose name is pointed to by pnam.

## c_cssgridd - interpolation on a sphere

c_cssgridd is called to interpolate function values starting with data randomly spaced on a sphere. c_cssgridd is a double precision version of c_cssgrid.

c_cssgridd uses tension splines to construct an interpolatory surface. As a first step, c_cssgridd creates a Delaunay triangulation of the input data points; the companion entry c_csstrid is provided only for those times when you want to calculate the triangulation for independent inspection.

Various aspects of the interpolation algorithm can be changed by using the parmater access routines c_csseti and c_cssetd to change values for the cssgrid control parematers.

Function prototype:

```  float *c_cssgridd(int, double [], double [], double [],
int, int, double [], double [], int *);
```

Usage:

```-------------------------------------------------
Argument | Type      |  Size
-------------------------------------------------
float *c_cssgridd (n,       | int       |
rlat,    | double [] | n
rlon,    | double [] | n
f,       | double [] | n
nlat,    | int       |
nlon,    | int       |
plat,    | double [] | ni
plon,    | double [] | nj
ier      | int *     |
);
-------------------------------------------------
```
n
The number of input data points, n > 2.
rlat,rlon
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
f
Array containing data values. f[i] is the functional value at (rlat[i],rlon[i]) for i = 0 to n-1.
ni
The number of latitudes in the interpolated grid.
nj
The number of longitudes in the interpolated grid. ni and nj can both be 1, allowing for interpolation at a single point.
plat
An array containing the latitudes of the points where interpolated values are to be computed. The values in plat should be in degrees.
plon
An array containing the longitudes of the points where interpolated values are to be computed. The values in plon should be in degrees.
ier
An error return value. If *ier is returned as 0, then no errors were detected. If *ier is non-zero, then refer to the error list in the error table for details.
Return value:

c_cssgridd returns a pointer to a linear array of data that contains interpolated values at user-specified lat/lon pairs. The returned array stores its values as if they were a 2-dimensional C array with latitude being the first dimension and longitude the second dimension. That is, if out is declared as

```  double *out;
```
and we set:
```  out = c_cssgridd(n, rlat, rlon, f, nlat, nlon, plat, plon, &ier);
```
then out[i*nlon+j] is the interpolated function value at coordinate point (plat[i], plon[j]) for 0 <= i < nlat and 0 <= j < nlon. The space for out is allocated internal to c_cssgridd and is nlat * nlon floats in size.

## c_csstrid - calculates a Delaunay triangulation

c_csstrid is called to find a Delaunay triangulation of data randomly positioned on the surface of a sphere. c_csstrid is a double precision version of c_csstri.

Function prototype:

```  int   *c_csstrid(int, double [], double [], int *, int *)

```
Usage:
```
-------------------------------------------------
Argument | Type      |  Size
-------------------------------------------------
int *c_csstrid (n,       | int       |
rlat,    | double [] | n
rlon,    | double [] | n
nt,      | int *     |
ier      | int *     |
);
-------------------------------------------------
```
n
The number of input data points, n > 2.
rlat,rlon
Arrays containing latitude and longitude coordinates, expressed in degrees, of the input data. The first three points must not be collinear (lie on a common great circle).
nt
*nt is the number of triangles in the triangulation, unless *ier is non-zero, in which case *nt = 0. Where nb is the number of boundary points on the convex hull of the data, if nb is greater than 3, then *nt = 2n-nb-2, otherwise *nt = 2n-4. The input data are considered to be bounded if they all lie in one hemisphere.
ier
An error return value. If *ier is returned as 0, then no errors were detected. If *ier is non-zero, then refer to the error list in the error table for details.
Return value:

c_csstrid returns a pointer to a linear array that contains a sequence of integer triples. The elements of a triple are indices of vertices of a triangle. Each index references an original data point as it occurs in sequence in the input data set (numbering starts at 0). For example, if the triple <5,0,2> were in the list of triples, then (rlat[5],rlon[5]), (rlat[0],rlon[0]), and (rlat[2],rlon[2]) would be vertices of a triangle in the Delaunay triangulation.

## c_css2cd - converts from lat/lon to Cartesian coordinates

c_css2cd is called to find the equivalent Cartesian coordinates on a unit sphere to specified latitude and longitude coordinates on a sphere. The coordinate of 0. latitude and 0. longitude is converted to Cartesian coordinate (1.,0.,0.). Latitudes and longitudes are assumed to be in degrees. c_css2cd is a double precision version of c_css2c.

Function prototype:

```  void   c_css2cd(int, double *, double *, double *, double *, double *);

```
Usage:
```
-------------------------------------------------
Argument | Type      |  Size
-------------------------------------------------
void c_css2cd (n,       | int       |
plat,    | double *  | n
plon,    | double *  | n
x,       | double *  | n
y,       | double *  | n
z        | double *  | n
);
-------------------------------------------------
```
n
The number of coordinates to be converted.
plat
Contains the latitudes of the input coordinates.
plon
Contains the longitudes of the input coordinates.
x,y,z
Contains the Cartesian coordinates of the output points. These lie on the unit sphere.

## c_csc2sd - convert from a Cartesian to a lat/lon coordinate

c_csc2sd converts Cartesian coordinates on a unit sphere to lat/lon coordinates. The coordinate (1.,0.,0.) is mapped to the latitude/longitude coordinate (0.,0.). The latitude/longitude coordinate is returned in degrees. c_csc2sd is a double precision version of c_csc2s.

Function prototype:

```     void   c_csc2sd(int, double *, double *, double *, double *, double *);
```
Usage:
```--------------------------------------------
Argument | Type      | Size
--------------------------------------------
void c_csc2sd (n,       | int       |
x,       | double *  |
y,       | double *  |
z,       | double *  |
plat,    | double *  |
plon,    | double *  |
)
--------------------------------------------
```
n
The number of coordinates to be converted.
x,y,z
Cartesian coordinates on the unit sphere.
plat, plon
(plat[i], plon[i]) is the latitude/longitude coordinate equivalent to (x[i],y[i],z[i]) for i equal 0 to n-1. plat and plon are in degrees.

## c_csvorod - calculate Voronoi polygons

c_csvorod is called if you want to determine the Voronoi polygons for data randomly positioned on a sphere. Each call to c_csvorod calculates the vertices for the Voronoi polygon surrounding a specified input point. c_csvorod is a double precision version of c_csvoro.

Function prototype:

```void   c_csvorod(int, double [], double [], int, int,
double [], double [], double [], int *,
int *, int [], int *);
```
Usage:
```-------------------------------------------------
Argument | Type      |  Size
-------------------------------------------------
void *c_csvorod (n,       | int       |
rlat,    | double [] | n
rlon,    | double [] | n
ni,      | int       |
nf,      | int       |
plat,    | double [] | 2*n
plon,    | double [] | 2*n
rc,      | double [] | 2*n
nca,     | int *     |
numv,    | int *     |
nv,      | int []    | n
ier      | int *     |
);
-------------------------------------------------
```
n
The number of input data points (n > 3).
rlat
An array containing the latitudes of the input coordinates, in degrees.
rlon
An array containing the longitudes of the input coordinates, in degrees.
ni
The index of the input coordinate for which you want to determine the Voronoi polygon (0 <= ni < n).
nf
Flag indicating if this is the first call to c_csvorod to retrieve Voronoi polygons for this dataset (1=yes, 0=no). Calls subsequent to the first call for a given dataset are much faster than the first call.
plat
An array of latitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. plat is returned in degrees.
plon
An array of longitude values for the Voronoi indices. These are circumcenters of circles passing through the Delaunay triangles. If a coordinate is a boundary point, then the circle may pass through certain "pseudo points" that have been added to the original dataset in order to complete the Voronoi polygon. RLONO is returned in degrees.
rc
Array containing circumradii (arc lengths in degrees of the angle between a circumcenter and its associated triangle vertices).
nca
*nca is the actual number of circumcenters returned in plat and plon. This number may be larger than n if the input dataset has boundary points, since certain "pseudo points" may have been added to the original dataset in order to complete the Voronoi polygon set.
numv
*numv is the number of vertices in the Voronoi polygon enclosing the coordinate (rlat[ni],rlon[ni]).
nv
An array containing numv indices for the Voronoi polygon enclosing the coordinate (rlat[ni],rlon[ni]). The indices returned in this array refer to the coordinates returned in plat and plon. For example, if the integer "j" is an element of the nv array, then (plat[j],plon[j]) is a vertex of the Voronoi polygon enclosing (rlat[ni],rlon[ni]). The indices in nv list out the vertices of the Voronoi polygon in counter-clockwise order.
ier
An error return value. If *ier is returned as 0, then no errors were detected. If *ier is non-zero, then refer to the error list in the error table for details.

home | contents | defs | procedures | examples | errors