++ + +
#include "rsl.h"
+
+main()
+{
+Radar *radar;
+Volume *dz_copy;
+Sweep *s1_copy;
+Ray r33_copy;
+
+radar = RSL_wsr88d_to_radar("nex.file.2", "KMLB");
+
+/* Copy of Volume for DZ. */
+dz_copy = RSL_copy_volume(radar->v[DZ_INDEX]);
+
+/* Copy of Sweep 1. */
+s1_copy = RSL_copy_sweep(dz_copy->sweep[0]);
+
+/* Copy of Ray 33. */
+r33_copy = RSL_copy_ray(s1_copy->ray[32]);
+}
+
+
+
diff --git a/doc/Makefile.am b/doc/Makefile.am
new file mode 100644
index 0000000..6acc059
--- /dev/null
+++ b/doc/Makefile.am
@@ -0,0 +1,12 @@
+AUTOMAKE_OPTIONS = foreign
+
+docdir = $(prefix)/doc/$(PACKAGE)
+doc_DATA = *.html *.gif *.jpg
+
+EXTRA_DIST = $(doc_DATA) *.fig
+
+install-exec-hook:
+ -mkdir $(prefix)/doc
+ -mkdir $(docdir)
+ $(INSTALL) -m 444 ../README $(docdir)
+ $(INSTALL) -m 444 ../CHANGES $(docdir)
diff --git a/doc/RSL_Er_loc_struct.html b/doc/RSL_Er_loc_struct.html
new file mode 100644
index 0000000..f62bfe3
--- /dev/null
+++ b/doc/RSL_Er_loc_struct.html
@@ -0,0 +1,16 @@
+
+
+
+
+
++ + +
typedef struct
+{
+float elev; /* elevation angle */
+float srange; /* slant range !!! */
+}
+Er_loc;
+
+
diff --git a/doc/RSL_add_dbz_offset.html b/doc/RSL_add_dbz_offset.html
new file mode 100644
index 0000000..813bb41
--- /dev/null
+++ b/doc/RSL_add_dbz_offset.html
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+
++
+RSL_add_dbz_offset...
+ ++
+Synopsis
+#include "rsl.h" +void RSL_add_dbz_offset_to_ray(Ray *r, float dbz_offset); +
void RSL_add_dbz_offset_to_sweep(Sweep *s, float dbz_offset); +
void RSL_add_dbz_offset_to_volume(Volume *v, float dbz_offset); + +
+
+Description
+ +RSL_add_dbz_offset_to_ray Adds a calibration factor 'dbz_offset' to a ray's range bins +containing valid values. Valid values are those other than NOECHO. ++
+ RSL_add_dbz_offset_to_sweep Calls RSL_add_dbz_offset_to_ray for each ray in the sweep. +
+
+ RSL_add_dbz_offset_to_volume Calls RSL_add_dbz_offset_to_sweep for each sweep in the volume. +
+
+
+Return value
+None. ++
+
+ +
Author: Mike Kolander. + + diff --git a/doc/RSL_allocate_histogram.html b/doc/RSL_allocate_histogram.html new file mode 100644 index 0000000..4748290 --- /dev/null +++ b/doc/RSL_allocate_histogram.html @@ -0,0 +1,25 @@ +
+ + + +
++ + +
RSL_allocate_histogram
+ ++ +
Synopsis
+#include "rsl.h"+Histogram *RSL_allocate_histogram(int low, int hi); +
+ +
Description
+Allocate space for the structure Histogram. low and hi specify the low and high dBZ bin values. The bin spacing is 1 dBZ. ++ +
Return value
+Upon successful completion, Vallocate_histogram returns a pointer to the structure Histogram. Otherwise, NULL is returned and errno is set. +Author: David B. Wolff + diff --git a/doc/RSL_anyformat_to_radar.html b/doc/RSL_anyformat_to_radar.html new file mode 100644 index 0000000..880f339 --- /dev/null +++ b/doc/RSL_anyformat_to_radar.html @@ -0,0 +1,87 @@ + + + + + +
++
+
+RSL_anyformat_to_radar
+ ++
+Synopsis
+#include "rsl.h" +Radar *RSL_anyformat_to_radar(char +*infile [, char *callid_or_first_file]); +
+
+
+Description
+Reads radar input files. The format of the input file is automatically +determined by using magic numbers. The input file may be compressed (with +old unix compress or GNU gzip) and the magic numbers are +obtained by passing the data through the GNU gzip decompression +filter. Magic numbers are standard for the following file formats and, +thus, are recognized by RSL_anyformat_to_radar: ++
WSR-88D (NEXRAD) +
HDF (TSDIS format) +
LASSEN (version 1.3 and version 1.4 files) +
Universal Format (UF) +
NSIG (SIGMET version 1 and version 2 raw product files) +
MCGILL +
RSL output format +
RAPIC (Berrimah Austrailia) +
RADTEC (SPANDAR, requires PKWARE compression tools) +
EDGE +
DORADE +
For TOGA and KWAJALEIN files, there is no standard magic information +available. It may not be possible for RSL_anyformat_to_radar to recognize +them. The optional second argument is valid for reading wsr88d files. See +RSL_wsr88d_to_radar. +Once the file type is determined, the appropriate ingest routine is called. +
In order to reduce the memory requirements during ingest, you can call +RSL_select_fields +to specify the field types. For instance, you can select to read only DZ +from the input file. The input file may contain other fields, but, they +will be ignored. +
PKWARE compression tools are required for the RADTEC module. The
+data has been
+
compressed with implode and must be uncompressed with explode
+.
+
+
+
+Return value
+Upon successful completion, RSL_anyformat_to_radar returns a pointer to +the structure Radar. Otherwise, NULL is returned. ++
+
+See also
+RSL_wsr88d_to_radar, RSL_lassen_to_radar +, +RSL_read_radar, +RSL_uf_to_radar +, +RSL_toga_to_radar, +RSL_nsig_to_radar +, +RSL_nsig2_to_radar, +RSL_mcgill_to_radar +RSL_kwaj_to_radar, +RSL_rapic_to_radar +, +RSL_radtec_to_radar. ++
+
Author: John H. Merritt. + + diff --git a/doc/RSL_area_of_ray.html b/doc/RSL_area_of_ray.html new file mode 100644 index 0000000..9946085 --- /dev/null +++ b/doc/RSL_area_of_ray.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_area_of_ray
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_area_of_ray(Ray *r, float lo, float hi, float min_range, float max_range); + +
+
Description
+Compute the volumetric area of a sweep given a range of dBZ, a minimum range and a maximum range in km. Ranges are specified in km. lo and hi are the minimum and maximum dBZ values within which the fractional area is computed. The name of this routine is unfortunately misleading. The area is really a volume. The total volume for pixels present within the range of lo to hi is computed and returned. This routine is used by the routine RSL_fractional_area_of_sweep.
++ +
Return value
+Upon successful completion, a valid floating point number is returned. ++ +
See also
+RSL_fractional_area_of_sweep ++ +
Author: John H. Merritt + diff --git a/doc/RSL_azimuth_hash_struct.html b/doc/RSL_azimuth_hash_struct.html new file mode 100644 index 0000000..c945b18 --- /dev/null +++ b/doc/RSL_azimuth_hash_struct.html @@ -0,0 +1,13 @@ +
+ + + +
++ + +
typedef struct _azimuth_hash {
+ Ray *ray;
+ struct _azimuth_hash *next,*ray_high,*ray_low;
+} Azimuth_hash;
+
diff --git a/doc/RSL_bscan.html b/doc/RSL_bscan.html
new file mode 100644
index 0000000..4c98b6a
--- /dev/null
+++ b/doc/RSL_bscan.html
@@ -0,0 +1,35 @@
+
+
+
+
+
++ + +
RSL_bscan_...
+ ++ +
Synopsis
+#include "rsl.h"+void RSL_bscan_ray(Ray *r, FILE *fp);
+void RSL_bscan_sweep(Sweep *s, char *outfile);
+void RSL_bscan_volume(Volume *v, char *basename); + +
+
Description
+Output image format is PPM. If basename is "bscan", RSL_bscan_volume outputs filenames bscan.01.gif, bscan.02.gif, etc. as PPM images. These are simple ray dumps; aka, B-SCANS. The output file is specified as the outfile parameter to RSL_bscan_sweep. These routines assume the color table has been loaded, otherwise you will get a black image. The output image dimensions are nbins by nrays which are determined from sweep and first-ray-of-the-sweep header information.
++ +
Return value
+None. ++ +
See also
+RSL_sweep_to_gif, RSL_sweep_to_pict, RSL_sweep_to_pgm, RSL_sweep_to_ppm,+RSL_load_color_table, RSL_load_green_table, RSL_load_red_table, RSL_load_blue_table,
+RSL_load_refl_color_table, RSL_load_sw_color_table, RSL_load_vel_color_table +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_cappi_at_h.html b/doc/RSL_cappi_at_h.html new file mode 100644 index 0000000..3156f63 --- /dev/null +++ b/doc/RSL_cappi_at_h.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_cappi_at_h
+ ++ +
Synopsis
+#include "rsl.h"+Cappi *RSL_cappi_at_h(Volume *v, float h, float max_range); + +
+
Description
+Produce a Constant Altitude PPI at h out to the maximum ground range max_range. h and max_range are expressed in km. Memory is allocated using the system calloc routine. A Sweep structure is used to store the data of the cappi. Thus, it is easy to make images by using RSL_sweep_to_gif.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+RSL_free_cappi, RSL_cappi_to_carpi. + ++
Author: John H. Merritt + diff --git a/doc/RSL_cappi_struct.html b/doc/RSL_cappi_struct.html new file mode 100644 index 0000000..5b44c01 --- /dev/null +++ b/doc/RSL_cappi_struct.html @@ -0,0 +1,26 @@ + + + + +
++ + +
typedef struct {
+ int month; /* Begin time for this Cappi; month (1-12). */
+ int day; /* Begin time for this Cappi; day (1-31). */
+ int year; /* Begin time for this Cappi; year (eg. 1993). */
+ int hour; /* Begin date for this Cappi; hour (0-23). */
+ int minute; /* Begin date for this Cappi; minute (0-59).*/
+ float sec; /* Begin date for this Cappi; second + fraction of second. */
+ float height; /* Height for this Cappi. */
+ float lat;
+ float lon; /* Lat/lon of lower left corner of Carpi. */
+ int field_type;
+ char radar_type[50]; /* Value of Constant radar->h.radar_type */
+ int interp_method; /* ??? string describing interpolation method. */
+ Er_loc *loc; /* elevation and range coordinate array */
+ Sweep *sweep; /* Pointers to rays of data */
+} Cappi;
+
+
diff --git a/doc/RSL_cappi_to_carpi.html b/doc/RSL_cappi_to_carpi.html
new file mode 100644
index 0000000..65859be
--- /dev/null
+++ b/doc/RSL_cappi_to_carpi.html
@@ -0,0 +1,31 @@
+
+
+
+
+
++ + +
RSL_cappi_to_carpi
+ ++ +
Synopsis
+#include "rsl.h"+Carpi *RSL_cappi_to_carpi(Cappi *cappi, float dx, float dy, float lat, float lon, int nx, int ny, int radar_x, int radar _y); + +
+
Description
+Produce a Constant Altitude Rectangular from Polar Image at h out to the maximum ground range grnd_range. h and grnd_range are expressed in km. The dimensions of the Carpi are given by nx and ny. radar_x and radar_y are the location of the radar within the Carpi structure (the rectangular grid). lat and lon represent the lower left corner (SE) of the rectangular grid. The routine allocates space for the resulting Carpi.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+RSL_free_cappi, RSL_volume_to_carpi, Carpi, Cappi, RSL_new_cappi. + ++
Author: Mike Kolander + diff --git a/doc/RSL_carpi_struct.html b/doc/RSL_carpi_struct.html new file mode 100644 index 0000000..aa2b388 --- /dev/null +++ b/doc/RSL_carpi_struct.html @@ -0,0 +1,29 @@ + + + + +
++ + +
typedef struct {
+ int month; /* (1-12). */
+ int day; /* (1-31). */
+ int year; /* (eg. 1993). */
+ int hour; /* (0-23). */
+ int minute; /* (0-59).*/
+ float sec; /* second + fraction of second. */
+ float dx, dy; /* Size of cell in km. */
+ int nx, ny; /* Number of cells. */
+ int radar_x, radar_y; /* Location of center of radar. */
+ float height; /* Height of this Carpi. */
+ float lat, lon; /* Lat/lon of lower left corner of Carpi. */
+ char radar_type[50]; /* Radar types. */
+ int field_type; /* Same as for Radar. */
+ int interp_method; /* ??? string describing interpolation method. */
+ float (*f)(Carpi_value x); /* Data conversion function. f(x). */
+ Carpi_value (*invf)(float x); /* Data conversion function. invf(x). */
+ Carpi_value **data; /* data[ny][nx] */
+} Carpi;
+
+
diff --git a/doc/RSL_carpi_value.html b/doc/RSL_carpi_value.html
new file mode 100644
index 0000000..6b83837
--- /dev/null
+++ b/doc/RSL_carpi_value.html
@@ -0,0 +1,8 @@
+
+
+
+
+t
++ypedef Range Carpi_value; + diff --git a/doc/RSL_carpi_value_struct.html b/doc/RSL_carpi_value_struct.html new file mode 100644 index 0000000..6b83837 --- /dev/null +++ b/doc/RSL_carpi_value_struct.html @@ -0,0 +1,8 @@ + + + + +t
++ypedef Range Carpi_value; + diff --git a/doc/RSL_clear.html b/doc/RSL_clear.html new file mode 100644 index 0000000..ab8e55d --- /dev/null +++ b/doc/RSL_clear.html @@ -0,0 +1,34 @@ + + + + +
++ + +
RSL_clear_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_clear_ray(Ray *r);
+Sweep *RSL_clear_sweep(Sweep *s);
+Volume *RSL_clear_volume(Volume *v); + +
+
Description
+RSL_clear_volume calls RSL_clear_sweep for the number of sweeps. RSL_clear_sweep calls RSL_clear_ray for the number of rays. And RSL_clear_ray clears the array of Range of size nbins. All header information is preserved. This may or may not be a desired capability.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. ++ +
See also
+Example+RSL_free_volume, RSL_free_sweep, RSL_free_ray +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_color_table.html b/doc/RSL_color_table.html new file mode 100644 index 0000000..040089d --- /dev/null +++ b/doc/RSL_color_table.html @@ -0,0 +1,77 @@ + + +
+ + + + +
++
+RSL_get_color_table
+RSL_set_color_table
+
+
+
+
+
++Synopsis
+#include "rsl.h" +void RSL_get_color_table(int icolor, char buffer[256], int *ncolors) +
void RSL_set_color_table(int icolor, char buffer[256], int ncolors) +
+
+
Description
+RSL_get_color_table: Given a color table index, one of RSL_RED_TABLE,
+RSL_GREEN_TABLE or RSL_BLUE_TABLE, return up to 256 color
+indexes each containing the color intensity for that color at each index.
+The number of colors in the table is indicated in *ncolors.
+RSL_set_color_table: Given a color table index icolor, one of +RSL_RED_TABLE, RSL_GREEN_TABLE or RSL_BLUE_TABLE, +and a character buffer, at most 256 color indexes long, and the number +of indexes in the character buffer, set the color table. Each color +index in buffer contains the color intensity for that color. +Range of color intensities is 0 to 255. +
You must make three calls to both the get and set functions to change +the entire color table entry for a particular index. For example, +to change the 5th index of the color table to cyan (Red=0, Green=255, +Blue=255), perform the following (provided a color table is already loaded): +
char r[256], g[256], b[256];
+
RSL_get_color_table(RSL_RED_TABLE, r, &ncolors);
+
RSL_get_color_table(RSL_GREEN_TABLE, g, &ncolors);
+
RSL_get_color_table(RSL_BLUE_TABLE, b, &ncolors);
+
r[4] = (char)0; /* [4] is the 5-th index */
+
g[4] = (char)255;
+
b[4] = (char)255;
+
RSL_set_color_table(RSL_RED_TABLE, r, ncolors);
+
RSL_set_color_table(RSL_GREEN_TABLE, g, ncolors);
+
RSL_set_color_table(RSL_BLUE_TABLE, b, ncolors);
+
+
+
+
+
+Return value
+None. ++
+See also
+RSL_rebin_velocity_ray, RSL_rebin_velocity_sweep, +RSL_rebin_velocity_volume, +RSL_sweep_to_gif, RSL_sweep_to_pict, +Vsweep_to_pgm, +Vsweep_to_ppm, +
RSL_load_color_table, RSL_load_green_table, +RSL_load_red_table, +RSL_load_blue_table, +
RSL_load_refl_color_table, +RSL_load_sw_color_table, +RSL_load_vel_color_table, +
RSL_volume_to_gif, RSL_volume_to_pict, +RSL_volume_to_pgm, +RSL_volume_to_ppm. +
+
Author: John H. Merritt + + diff --git a/doc/RSL_copy.html b/doc/RSL_copy.html new file mode 100644 index 0000000..7a182a8 --- /dev/null +++ b/doc/RSL_copy.html @@ -0,0 +1,34 @@ +
+ + + +
++ + +
RSL_copy_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_copy_ray(Ray *r);
+Sweep *RSL_copy_sweep(Sweep *s);
+Volume *RSL_copy_volume(Volume *v); + +
+
Description
+RSL_copy_volume calls RSL_copy_sweep for the number of sweeps. RSL_copy_sweep calls RSL_copy_ray for the number of rays. And RSL_copy_ray copies the array of Range of size nbins. All header information is preserved. This may or may not be a desired capability.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. ++ +
See also
+Example+RSL_free_volume, RSL_free_sweep, RSL_free_ray +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_copyright.html b/doc/RSL_copyright.html new file mode 100644 index 0000000..6d0d85a --- /dev/null +++ b/doc/RSL_copyright.html @@ -0,0 +1,36 @@ + + +
+ + + + + ++ + + diff --git a/doc/RSL_cube_struct.html b/doc/RSL_cube_struct.html new file mode 100644 index 0000000..13668bd --- /dev/null +++ b/doc/RSL_cube_struct.html @@ -0,0 +1,19 @@ + + + + +
+ + NASA/TRMM, Code 910.1. + This is the TRMM Office Radar Software Library. + Copyright (C) 1996-1999 + John H. Merritt + Space Applications Corporation + Vienna, Virginia + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ + +
typedef struct
+ {
+ float lat, lon;
+ float dx, dy, dz;
+ int nx, ny, nz;
+ char *data_type;
+ Carpi **carpi;
+ }
+Cube;
+
+
diff --git a/doc/RSL_edge_to_radar.html b/doc/RSL_edge_to_radar.html
new file mode 100644
index 0000000..9441cbe
--- /dev/null
+++ b/doc/RSL_edge_to_radar.html
@@ -0,0 +1,48 @@
+
+
+
+
+
+
+
+
++
+RSL_edge_to_radar
+ ++
+Synopsis
+#include "rsl.h" +Radar *RSL_edge_to_radar(char +*infile); +
+
+Description
+Reads the EDGE format and returns a pointer to the structure +Radar. +The input file is specified by the string infile. If infile +is NULL, then stdin is read. The input file may be compressed. If the data +is compressed, it is passed through the GNU gunzip filter. Thus, +compressed data can be any format that gzip understands. However, +the EDGE format uses the lzw compression and requires a supporting +library to decode the file. The supporting library is called ETOR +and is distributed separately, since it is not free software. Contact +Enterprise Electronics Corporation to obtain the ETOR library that decodes +the EDGE format. + Enterprise Electronics Corporation, Enterprise,
+Alabama, USA 36330 (334) 347-3478.
+
+
+
+Return value
+Upon successful completion, RSL_edge_to_radar returns a pointer to the +structure Radar. Otherwise, NULL is returned and errno is set. ++
+See also
+RSL_anyformat_to_radar ++
Author: Don Burrows @ Enterprise Electronics Corporation + + diff --git a/doc/RSL_enum_sorted_type.html b/doc/RSL_enum_sorted_type.html new file mode 100644 index 0000000..21a18e6 --- /dev/null +++ b/doc/RSL_enum_sorted_type.html @@ -0,0 +1,10 @@ +
+ + + +
++ + +
enum Sorted_type { NOT_SORTED, SORTED_BY_ANGLE, SORTED_BY_TIME};
+
diff --git a/doc/RSL_fill_cappi.html b/doc/RSL_fill_cappi.html
new file mode 100644
index 0000000..b27b10c
--- /dev/null
+++ b/doc/RSL_fill_cappi.html
@@ -0,0 +1,31 @@
+
+
+
+
+
++ + +
RSL_fill_cappi
+ ++ +
Synopsis
+#include "rsl.h"+int *RSL_fill_cappi(Volume *v, Cappi *cap, int method); + +
+
Description
+Using data from v, and information from cap, this routine fill the cappi structure cap with values from the rays in v. The argument cap is modified. The method passed indicates the interpolation used, however, no interpolation is used, yet. Normally, you should not call this routine unless you're writing an RSL routine, instead, call RSL_cappi_at_h.
++ +
Return value
+Upon successful completion, 1 is returned. -1 is returned upon failure. The argument cap is modified. ++ +
See also
+RSL_free_cappi, RSL_cappi_to_carpi, RSL_get_value_from_cappi, RSL_new_cappi + ++
Author: John H. Merritt + diff --git a/doc/RSL_find_rng_azm.html b/doc/RSL_find_rng_azm.html new file mode 100644 index 0000000..dc026b2 --- /dev/null +++ b/doc/RSL_find_rng_azm.html @@ -0,0 +1,28 @@ + + + + +
++ + +
RSL_find_rng_azm
++ +
Synopsis
+#include "rsl.h"+void RSL_find_rng_azm(float *r, float *ang, float x, float y); + +
+
Description
+Convert Cartesian coords (x, y) to polar (rng,angle); 0<angle<360.
++ +
Return value
+None. ++ +
See also
+ +Author: Mike Kolander + diff --git a/doc/RSL_fix_time.html b/doc/RSL_fix_time.html new file mode 100644 index 0000000..8defa7c --- /dev/null +++ b/doc/RSL_fix_time.html @@ -0,0 +1,39 @@ + + + + + + +
++
+RSL_fix_time
+ ++
+Synopsis
+#include "rsl.h" +void RSL_fix_time(Ray *ray); +
+
+Description
+Fixes possible overflow values in month, day, year, +hh, mm, ss. Normally, ss should be the +overflow. This code ensures end of month, year +and century are handled correctly by using the Unix time(2) functions. ++
+
+Return value
+None. ++
+
+See also
+mktime(3) ++
+ +
Author: John H. Merritt. + + diff --git a/doc/RSL_fraction_of.html b/doc/RSL_fraction_of.html new file mode 100644 index 0000000..ce5b4e2 --- /dev/null +++ b/doc/RSL_fraction_of.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_fraction_of...
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_fraction_of_ray(Ray *r, float lo, float hi, float range);
+float RSL_fraction_of_sweep(Sweep *s, float lo, float hi, float range);
+float RSL_fraction_of_volume(Volume *v, float lo, float hi, float range); + +
+
Description
+Compute the fraction of the Volume, Sweep, or Ray that contain values between lo and hi out to the range range. This is just a percentage.
++ +
Return value
+Upon successful completion, a valid floating point number is returned. ++ +
See also
+ +Author: John H. Merritt + diff --git a/doc/RSL_fractional_area_of_sweep.html b/doc/RSL_fractional_area_of_sweep.html new file mode 100644 index 0000000..7a28d45 --- /dev/null +++ b/doc/RSL_fractional_area_of_sweep.html @@ -0,0 +1,31 @@ + + + + +
++ + +
RSL_fractional_area_of_sweep
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_fractional_area_of_sweep(Sweep *s, float lo, float hi, float min_rng, float max_rng); + +
+
Description
+Computes the fractional area, of dBz values, between lo and hi, from min_rng to max_rng. This is the fractional area of the 360 degrees. The algorithm used is to compute conic volumes based on beam width and range of the pixels. The routine RSL_area_of_ray computes these volumes. The name of that routine is unfortunate.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, NULL is returned. ++ +
See also
+RSL_area_of_ray, RSL_fraction_of_sweep. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_free.html b/doc/RSL_free.html new file mode 100644 index 0000000..49b732c --- /dev/null +++ b/doc/RSL_free.html @@ -0,0 +1,33 @@ +
+ + + +
++ + +
RSL_free_...
+ ++ +
Synopsis
+#include "rsl.h"+void RSL_free_ray(Ray *r);
+void RSL_free_sweep(Sweep *s);
+void RSL_free_volume(Volume *v); + +
+
Description
+RSL_free_volume calls RSL_free_sweep for the number of sweeps, then frees the array of Sweep pointers, then frees itself. RSL_free_sweep calls RSL_free_ray for the number of rays, then frees the array of Ray pointers, then frees itself. Finally, RSL_free_ray frees the array of Range, then frees itself. Checks are made that non NULL pointers are freed.
++ +
Return value
+None. ++ +
See also
+RSL_clear_volume, RSL_clear_sweep, RSL_clear_ray. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_free_cappi.html b/doc/RSL_free_cappi.html new file mode 100644 index 0000000..a2de9b5 --- /dev/null +++ b/doc/RSL_free_cappi.html @@ -0,0 +1,40 @@ + + +
+
+
RSL_free_cappi +
+ +
Synopsis
+ +#include "rsl.h"
+void RSL_free_cappi(Cappi *c);
+
+
Description
+
+Free the data structure Cappi, previously allocated via RSL_new_cappi, +from memory. +
+ +
Return value
+ +None. +
+ +
See also
+ +RSL_new_cappi, RSL_cappi_to_carpi. + +
+ +
Author: John H. Merritt
+ + + diff --git a/doc/RSL_free_histogram.html b/doc/RSL_free_histogram.html new file mode 100644 index 0000000..2f87c06 --- /dev/null +++ b/doc/RSL_free_histogram.html @@ -0,0 +1,26 @@ + + + + +
++ + +
RSL_free_histogram
+ ++
+ +
Synopsis
+#include "rsl.h"+void RSL_free_histogram(Histogram *histogram); +
+ +
Description
+Deallocate the structure pointed to by histogram. Space for the structure Histogram was previously obtained via RSL_allocate_histogram. ++ +
Return value
+None. +Author: David B. Wolff + diff --git a/doc/RSL_free_radar.html b/doc/RSL_free_radar.html new file mode 100644 index 0000000..d2526a9 --- /dev/null +++ b/doc/RSL_free_radar.html @@ -0,0 +1,30 @@ + + + + +
++ + +
RSL_free_radar
++ +
Synopsis
+#include "rsl.h"+void RSL_free_radar(Radar *r); + +
+
Description
+Frees the space allocated to the Radar structure radar. It frees all substructures, Volume, Sweep, Ray, Range, by calling RSL_free_volume, RSL_free_sweep, RSL_free_ray respectively.
++ +
Return value
+None. ++ +
See also
+ +RSL_free_volume, RSL_free_sweep, RSL_free_ray + +
Author: John H. Merritt + diff --git a/doc/RSL_get_closest_ray_from_sweep.html b/doc/RSL_get_closest_ray_from_sweep.html new file mode 100644 index 0000000..5c2656d --- /dev/null +++ b/doc/RSL_get_closest_ray_from_sweep.html @@ -0,0 +1,32 @@ +
+ + + +
++ + +
RSL_get_closest_ray_from_sweep
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_closest_ray_from_sweep(Sweep *s,float ray_angle,float limit); + +
+
Description
+Return the closest ray within a sweep. Closeness is determined by the minimum absolute difference of ray_angle and the azimuth angle of the ray. The difference must be less than limit. If no such ray can be found, return NULL.
++ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_ray, RSL_get_ray_from_sweep, RSL_get_ray_above, RSL_get_ray_below, RSL_get_first_ray_of_sweep, RSL_get_first_ray_of_volume. ++ +
Author: Dennis Flanigan Jr. + + diff --git a/doc/RSL_get_closest_sweep.html b/doc/RSL_get_closest_sweep.html new file mode 100644 index 0000000..a6c0170 --- /dev/null +++ b/doc/RSL_get_closest_sweep.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_get_closest_sweep
+ ++ +
Synopsis
+#include "rsl.h"+Sweep *RSL_get_closest_sweep(Volume *v,float sweep_angle,float limit); + +
+
Description
+Return the closest sweep within a volume. Closeness is determined by the minimum absolute difference of sweep_angle and the elevation angle of the ray. The difference must be less than limit. If no such ray can be found, return NULL.
++ +
Return value
+Upon successful completion, a pointer to the Sweep structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_sweep ++ +
Author: Dennis Flanigan Jr. + diff --git a/doc/RSL_get_first_ray_of.html b/doc/RSL_get_first_ray_of.html new file mode 100644 index 0000000..045cc49 --- /dev/null +++ b/doc/RSL_get_first_ray_of.html @@ -0,0 +1,32 @@ +
+ + + +
++ + +
RSL_get_first_ray_of_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_first_ray_of_sweep(Sweep *s);
+Ray *RSL_get_first_ray_of_volume(Volume *v); + +
+
Description
+RSL_get_first_ray_of_sweep returns a pointer to the first ray pointer in the Sweep structure *s, if one exist. Otherwise NULL is returned. Similiarly, for RSL_get_first_ray_of_volume; it finds the first sweep and returns the first ray of that sweep.
++ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_first_sweep_of_volume ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_first_sweep_of_volume.html b/doc/RSL_get_first_sweep_of_volume.html new file mode 100644 index 0000000..a4db680 --- /dev/null +++ b/doc/RSL_get_first_sweep_of_volume.html @@ -0,0 +1,32 @@ +
+ + + +
++ + +
RSL_get_first_sweep_of_volume
+ ++ +
Synopsis
+#include "rsl.h"+Sweep *RSL_get_first_sweep_of_volume(Volume *v); + +
+
Description
+RSL_get_first_sweep_of_volume returns a pointer to the first sweep pointer in the Volume structure *v, if one exist. Otherwise NULL is returned.
++ +
Return value
+Upon successful completion, a pointer to the Sweep structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_first_ray_of_sweep+RSL_get_first_ray_of_volume +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_get_gr_slantr_h.html b/doc/RSL_get_gr_slantr_h.html new file mode 100644 index 0000000..a65b3b6 --- /dev/null +++ b/doc/RSL_get_gr_slantr_h.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_get_gr_slantr_h
+ ++ +
Synopsis
+#include "rsl.h"+void RSL_get_gr_slantr_h(Ray *ray, int i, float *gr, float *slantr, float *h) + +
+
Description
+Given a Ray ray and the range index i, calculate the ground range, slant range, and height; gr, slantr and h respectively.
++ +
Return value
+None. ++ +
See also
+RSL_get_groundr_and_h ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_groundr_and_h.html b/doc/RSL_get_groundr_and_h.html new file mode 100644 index 0000000..e557253 --- /dev/null +++ b/doc/RSL_get_groundr_and_h.html @@ -0,0 +1,30 @@ +
+ + + +
++ + +
RSL_get_groundr_and_h
++ +
Synopsis
+#include "rsl.h"+void RSL_get_groundr_and_h(float slant_r, float elev, float *gr, float *h); + +
+
Description
+Given slant range, slant_r, and the elevation angle, elev, compute the ground range, gr, and height, h. Range and height units are in km. Angles are in degrees. This is the inverse fuction of RSL_get_slantr_and_elev.
++ +
Return value
+None. ++ +
See also
+RSL_get_slantr_and_elev, RSL_get_slantr_and_h ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_histogram_from.html b/doc/RSL_get_histogram_from.html new file mode 100644 index 0000000..0dc9f1f --- /dev/null +++ b/doc/RSL_get_histogram_from.html @@ -0,0 +1,33 @@ +
+ + + +
++ + +
RSL_get_histogram_from_...
+ ++ +
Synopsis
+#include "rsl.h"+Histogram *RSL_get_histogram_from_ray(Ray *ray, Histogram *histogram, int low, int hi, int min_range, int max_range);
+Histogram *RSL_get_histogram_from_sweep(Sweep *sweep, Histogram *histogram, int low, int hi, int min_range, int max_range);
+Histogram *RSL_get_histogram_from_volume(Volume *volume, Histogram *histogram, int low, int hi, int min_range, int max_range); +
+ +
Description
+Load histogram with the histogram from a Ray, Sweep, or Volume. If histogram is NULL, then space is automatically allocated by RSL_allocate_histogram. Notice that a histogram pointer is passed into the routines. The argument histogram is used as an accumulator. For instance, getting the histogram for an entire sweep involves getting the histogram for ray #1, then adding the histograms for ray #2 through #n. Although, the argument histogram is modified, a pointer to that histogram is returned so that the function interface, that is commonly used throughout the RSL, is maintained. ++ +
Return value
+Upon successful completion, a pointer to Histogram is returned. NULL is returned if an error occurs and errno is set. ++ +
See also
+RSL_read_histogram, RSL_write_histogram, RSL_print_histogram, RSL_free_histogram ++ +
Author: David B. Wolff + diff --git a/doc/RSL_get_linear_value.html b/doc/RSL_get_linear_value.html new file mode 100644 index 0000000..3f2d24b --- /dev/null +++ b/doc/RSL_get_linear_value.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_get_linear_value
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_get_linear_value(Volume *v, float srange, float azimuth, float elev, float limit); + +
+
+ +
Description
+Find a linearly interpolated value in the Volume, v, at the polar coordinate specification (srange, azimuth, elev). The four surrounding data values that are azimuthally within +/- limit degrees are used for the interpolation. Limit is measured in degrees. Srange is the slant range in KM. Azimuth and elev are measured in degrees. ++ +
Return value
+Upon successful completion, a valid floating point number is returned. Note, the value could be BADVAL. ++ +
See also
+RSL_get_value +Author: Dennis Flanigan, Jr. + diff --git a/doc/RSL_get_next_cwise_ray.html b/doc/RSL_get_next_cwise_ray.html new file mode 100644 index 0000000..2604bdd --- /dev/null +++ b/doc/RSL_get_next_cwise_ray.html @@ -0,0 +1,35 @@ + + + + +
++ + +
RSL_get_next_cwise_ray
+ + +RSL_get_next_ccwise_ray
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_next_cwise_ray(Sweep *s, Ray *r);
+Ray *RSL_get_next_ccwise_ray(Sweep *s, Ray *r); + +
+
Description
+cwise, means clockwise and it is defined to mean "in the direction of increasing azimuth angle (don't ask)." ccwise means counter-clockwise and it is defined to mean "in the direction of decreasing azimuth angle." Dennis Flanigan defined cwise and ccwise.
++ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_ray_from_sweep, RSL_get_ray_above, RSL_get_ray_below, RSL_get_first_ray_of_sweep, RSL_get_first_ray_of_volume. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_nyquist_from_radar.html b/doc/RSL_get_nyquist_from_radar.html new file mode 100644 index 0000000..5188433 --- /dev/null +++ b/doc/RSL_get_nyquist_from_radar.html @@ -0,0 +1,32 @@ +
+ + + +
++ + +
RSL_get_nyquist_from_radar
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_get_nyquist_from_radar(Radar *radar) + + +
+
Description
+Find a velocity volume. Find first sweep in that volume. Find first ray in that sweep. Return the nyquist velocity, a member of Ray.
++ +
Return value
+Upon successful completion, a valid floating point number is returned. ++ +
See also
+ ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_range_of_range_index.html b/doc/RSL_get_range_of_range_index.html new file mode 100644 index 0000000..7589bcf --- /dev/null +++ b/doc/RSL_get_range_of_range_index.html @@ -0,0 +1,27 @@ +
+ + + +
++ + +
RSL_get_range_of_range_index
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_get_range_of_range_index (Ray *ray, int index); + +
+
Description
+index represents the bin number of the Ray's range. The geographic range is calculated from the range of the first bin and the bin size.
++ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
Author: Dennis Flanigan. + diff --git a/doc/RSL_get_ray.html b/doc/RSL_get_ray.html new file mode 100644 index 0000000..7a97321 --- /dev/null +++ b/doc/RSL_get_ray.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_get_ray
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_ray(Volume volume, float elev, float azimuth); + +
+
Description
+Extract a Ray from a Volume. Returns a pointer to a Ray. You must copy the Ray returned with RSL_copy_ray, if you want to modify the contents of the Ray without destroying the original Ray. elev is the elevation angle in degrees and is used to find the appropriate Sweep using the routine RSL_get_sweep. The azimuth angle within the appropriate Sweep must be within +/- 1/2 horizontal beam width of the target angle, azimuth.
++ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_ray_from_sweep, RSL_get_ray_above, RSL_get_ray_below, RSL_get_first_ray_of_sweep, RSL_get_first_ray_of_volume. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_ray_above-below.html b/doc/RSL_get_ray_above-below.html new file mode 100644 index 0000000..6b1ead8 --- /dev/null +++ b/doc/RSL_get_ray_above-below.html @@ -0,0 +1,35 @@ +
+ + + +
++ + +
RSL_get_ray_above
+RSL_get_ray_below
+
++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_ray_above(Volume *v, Ray *current_ray);
+Ray *RSL_get_ray_below(Volume *v, Ray *current_ray); + +
+
+
+
Description +Returns a Ray that is either above or below the current_ray. The elevation angle is extracted from the current_ray and 1.0 is added or subtracted to/from it and the function RSL_get_sweep is called. This algorithm is simple and may not be robust enough; it has already been inadequate for the GT quality control. +
+ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_ray_from_sweep, RSL_get_first_ray_of_sweep, RSL_get_first_ray_of_volume, RSL_get_ray, RSL_get_sweep. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_ray_from_sweep.html b/doc/RSL_get_ray_from_sweep.html new file mode 100644 index 0000000..7457a5a --- /dev/null +++ b/doc/RSL_get_ray_from_sweep.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_get_ray_from_sweep
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_ray_from_sweep(Sweep *s, float azim); + +
+
Description
+Return a pointer to a Ray that is in the Sweep *s, for the azimuth angle azim. The search is to find a ray that is within one beam width of the desired angle. The search is +/- 1/2 horizontal beam width.
++ +
Return value
+Upon successful completion, a pointer to the Ray structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_ray, RSL_get_ray_above, RSL_get_ray_below, RSL_get_first_ray_of_sweep, RSL_get_first_ray_of_volume. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_slantr_and_elev.html b/doc/RSL_get_slantr_and_elev.html new file mode 100644 index 0000000..834e0b5 --- /dev/null +++ b/doc/RSL_get_slantr_and_elev.html @@ -0,0 +1,30 @@ +
+ + + +
++ + +
RSL_get_slantr_and_elev
++ +
Synopsis
+#include "rsl.h"+void RSL_get_slantr_and_elev(float gr, float h, float *slant_r, float *elev); + +
+
Description
+Given ground range, gr, and height, h, compute the slant range, slant_r and elevation angle, elev. Range and height units are in km. Angles are in degrees. This is the inverse function of RSL_get_groundr_and_h.
++ +
Return value
+None. ++ +
See also
+RSL_get_slantr_and_h, RSL_get_groundr_and_h ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_slantr_and_h.html b/doc/RSL_get_slantr_and_h.html new file mode 100644 index 0000000..020a6f2 --- /dev/null +++ b/doc/RSL_get_slantr_and_h.html @@ -0,0 +1,30 @@ +
+ + + +
++ + +
RSL_get_slantr_and_h
++ +
Synopsis
+#include "rsl.h"+void RSL_get_slantr_and_h(float gr, float elev, float *slant_r, float *h); + +
+
Description
+Given ground range, gr, and elevation angle, elev, compute the slant range, slant_r and height, h. Range and height units are in km. Angles are in degrees.
++ +
Return value
+None. ++ +
See also
+RSL_get_slantr_and_elev, RSL_get_groundr_and_h ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_slice_from_cube.html b/doc/RSL_get_slice_from_cube.html new file mode 100644 index 0000000..f287e62 --- /dev/null +++ b/doc/RSL_get_slice_from_cube.html @@ -0,0 +1,33 @@ +
+ + + +
++ + +
RSL_get_slice_from_cube
+ ++ +
Synopsis
+#include "rsl.h"+Slice *RSL_get_slice_from_cube(Cube *cube, int x, int y, int z); + +
+
Description
+Given a Cube structure, extract one slice from it. x, y and z define the plane of the required slice. Two of the three parameters must equal -1 and the third must be nonnegative; eg, the vertical plane y=100 is specified by the parameters x=-1, y=100, z=-1. Assumes valid ranges for x, y, z are: +0 <= x <= nx-1, 0 <= y <= ny-1, 1 <= z <= nz
+nx, ny and nz specify the dimensions of the cube structure and are members of it. The range of z starts at 1 , since a cappi (or carpi) at height z=0 makes no sense. +
+ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+RSL_volume_to_cube + ++
Author: Mike Kolander + diff --git a/doc/RSL_get_sweep.html b/doc/RSL_get_sweep.html new file mode 100644 index 0000000..a3cea6b --- /dev/null +++ b/doc/RSL_get_sweep.html @@ -0,0 +1,33 @@ + + + + +
++ + +
RSL_get_sweep
+ ++ +
Synopsis
+#include "rsl.h"+Sweep *RSL_get_sweep(Volume *v, float elev); + +
+
Description
+Looks in Volume *v for a sweep that has an elevation angle +/- beam width vertically. If found, then that sweep pointer is returned, else NULL is returned.
++ +
Return value
+Upon successful completion, a pointer to the Sweep structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_get_volume, RSL_get_ray, RSL_get_first_sweep_of_volume, RSL_get_ray_from_sweep, +RSL_get_closest_sweep, +RSL_get_next_closest_sweep ++ +
Author: John H. Merritt + diff --git a/doc/RSL_get_sweep_index_from_volume.html b/doc/RSL_get_sweep_index_from_volume.html new file mode 100644 index 0000000..43f73b5 --- /dev/null +++ b/doc/RSL_get_sweep_index_from_volume.html @@ -0,0 +1,29 @@ +
+ + + +
++ + +
RSL_get_sweep_index_from_volume
+ ++ +
Synopsis
+#include "rsl.h"+int RSL_get_sweep_index_from_volume(Volume *v, float elev,int *next_closest); + +
+
Description
+Return the index of the closest sweep. Also, returns the next closest sweep index. Use the index returned, if called i, in v->sweep[i].
++ +
Return value
+Upon successful completion, a valid index into the v->sweep[i] structure is returned. Otherwise, -1 is returned and *next_closest is undefined. ++ +
See also
+RSL_get_sweep, RSL_get_ray +Author: Dennis Flanigan Jr. + diff --git a/doc/RSL_get_value.html b/doc/RSL_get_value.html new file mode 100644 index 0000000..0dcc4d1 --- /dev/null +++ b/doc/RSL_get_value.html @@ -0,0 +1,43 @@ + + + + +
++ + +
RSL_get_value...
+ ++ +
Synopsis
+#include "rsl.h"+float RSL_get_value(Volume *v, float elev, float azimuth, float range);
+float RSL_get_value_at_h(Volume *v, float azim, float grnd_r, float h);
+float RSL_get_value_from_ray(Ray *ray, float r);
+float RSL_get_value_from_sweep(Sweep *s, float azim, float r); + +
+
+ +
+
Description
+RSL_get_value: Find a value in the Volume v using polar coordinate specification. The search returns the closest point. Although there is no restriction concerning azimuth values, other functions rely on the range being 0 to +360. This may change. Nexrad happened to use this range so I use it for now.
+
+RSL_get_value_at_h: Returns a value when the coordinate is specified by ground range and height. Both ground range and height are specified in km. + +
RSL_get_value_from_ray: Return a value for the slant range r. Basically, r is converted to an index based on the gate size. + +
Vget_value_from_sweep: Get a value from a Sweep, s, given the azimuth azim and range r. + +
+
+ +
Return value
+Upon successful completion, a valid floating point number is returned. Note, the value could be BADVAL. ++ +
See also
+ +Author: John H. Merritt + diff --git a/doc/RSL_get_value_from_cappi.html b/doc/RSL_get_value_from_cappi.html new file mode 100644 index 0000000..fea024b --- /dev/null +++ b/doc/RSL_get_value_from_cappi.html @@ -0,0 +1,31 @@ + + + + +
++ + +
RSL_get_value_from_cappi
+ ++ +
Synopsis
+#include "rsl.h"+float *RSL_get_value_from_cappi(Cappi *cap, float rng, float azm); + +
+
Description
+This routine uses RSL_get_value_from_sweep to get the value.
++ +
Return value
+Upon successful completion, a valid floating point number is returned. If no value can be found, BADVAL is returned. ++ +
See also
+RSL_get_value_from_sweep + ++
Author: John H. Merritt + diff --git a/doc/RSL_get_volume.html b/doc/RSL_get_volume.html new file mode 100644 index 0000000..2095214 --- /dev/null +++ b/doc/RSL_get_volume.html @@ -0,0 +1,69 @@ + + + + +
++ + +
RSL_get_volume
+ ++ +
Synopsis
+#include "rsl.h"+Volume *RSL_get_volume(Radar *r, int type_wanted); + +
+
Description
+RSL_get_volume extracts the desired volume from the Radar *r. type_wanted can be one of: DZ_INDEX, VR_INDEX, SW_INDEX, CZ_INDEX, ZT_INDEX, DR_INDEX or LR_INDEX. Only the pointer is copied for the returned value. If you want to optain a seperate copy of the volume, from the Radar *r, for modification purposes, then use RSL_copy_volume. The different indexes are described as follows:
+
+DZ Reflectivity (dBZ), may contain some DZ_INDEX + signal-processor level QC and/or + filters. This field would contain + Darwin's CZ, or WSR88D's standard + reflectivity. In other words, unless + the field is described otherwise, it + should always go here. In essence, this + is the "cleanest" reflectivity field + for a radar. + + VR Radial Velocity (m/s) VR_INDEX + + SW Spectral Width (m2/s2) SW_INDEX + + CZ QC Reflectivity (dBZ), contains + post-processed QC'd data CZ_INDEX + + ZT Total Reflectivity (dBZ) ZT_INDEX + May be uncommon, but important + + DR Differential reflectivity DR_INDEX + DR and LR are for dual-polarization + radars only. Unitless or in dB. + + LR Another form of differential ref LR_INDEX + called LDR, not sure of units + +This function is a one line C function. Observe the following: + +
Radar *radar; +Volume *v; +/* The following two lines are identical. */ +v = Vget_volume(radar, DZ_INDEX); +v = radar->v[DZ_INDEX]; ++
+ +
Return value
+Upon successful completion, a pointer to the Volume structure is returned; only the pointer is copyied. ++ +
See also
+RSL_get_sweep, RSL_get_ray+RSL_copy_volume, RSL_copy_sweep, RSL_copy_ray
+RSL_free_volume, RSL_free_sweep, RSL_free_ray +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_get_win.html b/doc/RSL_get_win.html new file mode 100644 index 0000000..e5019df --- /dev/null +++ b/doc/RSL_get_win.html @@ -0,0 +1,34 @@ +
+ + + +
++ + +
RSL_get_window_from_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_get_window_from_ray(Ray *r, float min_range, float max_range, float low_azim, float hi_azim);
+Sweep *RSL_get_window_from_sweep(Sweep *s, float min_range, float max_range, float low_azim, float hi_azim);
+Volume *RSL_get_window_from_volume(Volume *v, float min_range, float max_range, float low_azim, float hi_azim);
+Radar *RSL_get_window_from_radar(Radar *r, float min_range, float max_range, float low_azim, float hi_azim); + +
+
Description
+RSL_get_window_from_radar calls RSL_get_window_from_volume for the number of volumes. RSL_get_window_from_volume calls RSL_get_window_from_sweep for the number of sweeps. RSL_get_window_from_sweep calls RSL_get_window_from_ray for the number of rays. And RSL_get_window_from_ray gets window, between low_azim and hi_azim, from min_range to max_range.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. ++ +
See also
+Example ++ +
Author: John H. Merritt + diff --git a/doc/RSL_hash_table_struct.html b/doc/RSL_hash_table_struct.html new file mode 100644 index 0000000..8d1fbde --- /dev/null +++ b/doc/RSL_hash_table_struct.html @@ -0,0 +1,15 @@ +
+ + + +
++ + +
typedef struct {
+ Azimuth_hash **indexes;
+ int nindexes;
+} Hash_table;
+
+
+
diff --git a/doc/RSL_hdf_to_radar.html b/doc/RSL_hdf_to_radar.html
new file mode 100644
index 0000000..ec6304f
--- /dev/null
+++ b/doc/RSL_hdf_to_radar.html
@@ -0,0 +1,59 @@
+
+
+
+
++ +
RSL_hdf_to_radar
+RSL_hdf_to_radar_unQC
+
++
+ +
Synopsis
+ +#include "rsl.h"
+Radar *RSL_hdf_to_radar(char *infile);
+
+Radar *RSL_hdf_to_radar_unQC(char
+*infile);
+
+ +
Description
+ +Reads an HDF file and returns a pointer to the structure Radar. +The input file is specified by the string infile. If infile +is NULL, then no action is taken. This is different from other ingest routines +where stdin is read. HDF files cannot be stdin, because they require seeking.. +The input file may not be compressed.
+ +RSL_hdf_to_radar_unQC differs from RSL_hdf_to_radar in +that both DZ (original uncorrected reflectivity) and CZ (corrected) volumes +are extracted from the HDF file. Normally, RSL_hdf_to_radar +returns CZ only. Call one or the other, for ingest efficiency.
+ +The radar structure is, essentially, an array of Volumes. The number +and type of volumes allocated is automatically determined from the input +HDF file. +
+ +
Return value
+ +Upon successful completion, RSL_hdf_to_radar returns a pointer +to the structure Radar. Otherwise, NULL is returned and errno is +set. +
+ +
See also
+ ++ +
Author: Mike Kolander.
+ + + diff --git a/doc/RSL_histogram_struct.html b/doc/RSL_histogram_struct.html new file mode 100644 index 0000000..00576d5 --- /dev/null +++ b/doc/RSL_histogram_struct.html @@ -0,0 +1,17 @@ + + + + +
++ + +
typedef struct {
+ int nbins;
+ int low;
+ int hi;
+ int ucount;
+ int ccount;
+ int *data;
+} Histogram;
+
diff --git a/doc/RSL_lassen_to_radar.html b/doc/RSL_lassen_to_radar.html
new file mode 100644
index 0000000..96d4d25
--- /dev/null
+++ b/doc/RSL_lassen_to_radar.html
@@ -0,0 +1,33 @@
+
+
+
+
+
++ + +
RSL_lassen_to_radar
+ ++ +
Synopsis
+#include "rsl.h"+Radar *RSL_lassen_to_radar(char *infile); +
+ +
Description
+Reads a LASSEN (data from Darwin Austrailia) file and returns a pointer to the structure Radar. The input file is specified by the string infile. If infile is NULL, then stdin is read. The input file may be compressed. If the data is compressed, it is passed through the GNU gunzip filter. Thus, compressed data can be any format that gzip understands. + +The radar structure is, essentially, an array of Volumes. These volumes represent the reflectivity, velocity and spectrum width fields. +
+ +
Return value
+Upon successful completion, lassen_to_radar returns a pointer to the structure Radar. Otherwise, NULL is returned and errno is set. ++ +
See also
+RSL_anyformat_to_radar ++ +
Author: John H. Merritt. + diff --git a/doc/RSL_load_color_table.html b/doc/RSL_load_color_table.html new file mode 100644 index 0000000..f1ba8c9 --- /dev/null +++ b/doc/RSL_load_color_table.html @@ -0,0 +1,72 @@ + + +
+ + + + +
++
+RSL color table routines
+ ++
+Synopsis
+#include "rsl.h" +void RSL_load_color_table(char *infile, char buffer[256], int *ncolors); +
void RSL_load_green_table(char *infile); +
void RSL_load_blue_table(char *infile); +
void RSL_load_red_table(char *infile); +
void RSL_load_refl_color_table(); +
void RSL_load_sw_color_table(); +
void RSL_load_vel_color_table(); +
void RSL_load_zdr_color_table(); +
void RSL_load_rainfall_color_table(); +
void RSL_load_height_color_table(); +
+
+
Description
+These are the color table routines. The color table is use when making
+images and is merely 256 bytes in size representing red, green and blue
+color indexes. The routines RSL_load_refl_color_table, RSL_load_sw_color_table,
+RSL_load_vel_color_table,and RSL_load_zdr_color_table each call
+the three routines RSL_load_red_table, RSL_load_green_table,
+and RSL_load_blue_table with a hard coded (defined during software
+installation) color input file. Under normal usage, you only have to call
+these routines once prior to any image generation function calls.
+The routines RSL_load_rainfall_color_table and RSL_load_height_color_table +use the default files defined during installation. These routines exist +to simplify the interface when generating height or rainfall images. +
The default input file names are defined in volume.h. When you don't +want to use the default color tables for reflectivity, spectrum width, +or velocity, and have your own color tables, you can use RSL_load_red_table, +RSL_load_green_table, +and RSL_load_blue_table directly. Be sure to call all three routines. +The most general of the routines, and one you should not normally use, +is RSL_load_color_table. It manages a static global color table +array and it is how the color table is remembered throughout your application. +
The organization of the input color table files is binary. They contain, +at most, 256 bytes with no delimeters and represent the color ramp from +index 0 to 255. +
+
+Return value
+None. ++
+See also
+RSL_sweep_to_gif, RSL_sweep_to_pict, +RSL_sweep_to_pgm, +RSL_sweep_to_ppm, +RSL_bscan_ray, RSL_bscan_sweep, +RSL_bscan_volume, +
RSL_volume_to_gif, RSL_volume_to_pict, +RSL_volume_to_pgm, +RSL_volume_to_ppm, +
RSL_get_color_table, RSL_set_color_table. +
+
+
Author: John H. Merritt + + diff --git a/doc/RSL_mcgill_to_radar.html b/doc/RSL_mcgill_to_radar.html new file mode 100644 index 0000000..d3c0d35 --- /dev/null +++ b/doc/RSL_mcgill_to_radar.html @@ -0,0 +1,34 @@ +
+ + + +
++ + +
RSL_mcgill_to_radar
+ ++ +
Synopsis
+#include "rsl.h"+Radar *RSL_mcgill_to_radar(char *infile); +
+ +
Description
+Reads a McGill file and returns a pointer to the Radar structure. The input file is specified by the string infile. The input file may be compressed. If the data is compressed, it is passed through the GNU gunzip filter. Thus, compressed data can be any format that gzip understands. + +The radar structure is, essentially, an array of Volumes. These volumes represent the reflectivity, velocity and spectrum width fields. +
+ +
Return value
+Upon successful completion, RSL_mcgill_to_radar returns a pointer to the structure Radar. Otherwise, NULL is returned. ++ +
See also
+RSL_anyformat_to_radar ++ +
Author: Mike Kolander + + diff --git a/doc/RSL_new.html b/doc/RSL_new.html new file mode 100644 index 0000000..cb15e9b --- /dev/null +++ b/doc/RSL_new.html @@ -0,0 +1,48 @@ +
+ + + +
++ + +
RSL_new_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_new_ray(int max_bins);
+Sweep *RSL_new_sweep(int max_rays);
+Volume *RSL_new_volume(int max_sweeps);
+Radar *RSL_new_radar(int nvolumes); + +
+
Description
+RSL_new_radar allocates memory for a Radar. It allocates space for it's header and space for nvolumes pointers to Volume, it does not assign anything to the new header. It does not allocate any volumes, just the pointers. You have to perform the allocation of volumes yourself. Do this by looping on nvolumes and calling RSL_new_volume.
+
+nvolumes does not represent the number of volumes in the radar structure. It represents the number of volume index slots or the maximum volume index. Reserved values DZ_INDEX, VR_INDEX, SW_INDEX, CZ_INDEX, ZT_INDEX, DR_INDEX, and LR_INDEX are the numbers 0 through 6. They are volume indexes. If you have 2 volumes (non NULL pointers) that are SW_INDEX and ZT_INDEX, you must be sure that nvolumes is, at least, ZT_INDEX+1. All the other volume pointers are NULL. It is perfectly valid to have NULL volume pointers. + +
RSL_new_volume allocates memory for a Volume. It allocates space for it's header and space for nsweep pointers to Sweep, it does not assign anything to the new header. It does not allocate any sweeps, just the pointers. You have to perform the allocation of sweeps yourself. Do this by looping on nsweeps and calling RSL_new_sweep. + +
nsweeps does not represent the number of non NULL sweep pointers. It is the number of index slots or the maximum sweep index. It is valid to have NULL sweep pointers. + +
RSL_new_sweep allocates memory for a Sweep. It allocates space for it's header and space for nrays pointers to Ray. It does not allocate any rays, just the pointers, nor does it assign any values to the new header. You have to perform the allocation of rays yourself. Do this by looping on nrays and calling RSL_new_ray. + +
nrays does not represent the number of non NULL ray pointers. It is the number of index slots or the maximum ray index. It is valid to have NULL ray pointers. + +
RSL_new_ray allocates memory for a Ray. It allocates space for it's header and space for a Range array of size nbins. It does not assign any values to the header. Since, the Range type is not a pointer, this function allocates an array of Range of size nbins. Currently, Range is just an alias for unsigned char. +
+ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+Example+RSL_free_volume, RSL_free_sweep, RSL_free_ray
+RSL_copy_volume, RSL_copy_sweep, RSL_copy_ray +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_new_cappi.html b/doc/RSL_new_cappi.html new file mode 100644 index 0000000..f74c1b6 --- /dev/null +++ b/doc/RSL_new_cappi.html @@ -0,0 +1,33 @@ +
+ + + +
++ + +
RSL_new_cappi
+ ++ +
Synopsis
+#include "rsl.h"+Cappi *RSL_new_cappi(Sweep *sweep, float height); + +
+
Description
+RSL_new_cappi allocates memory for a Cappi. It allocates space for it's header and space for for a Sweep structure. The Sweep allocated is a copy of sweep with all the data cleared. The height argument is copied to the height member of Cappi. No values are assigned to the rays in the sweep. That is done in the routine RSL_fill_cappi. This routine is not, normally, called unless you are developing a new cappi routine for RSL. Call RSL_cappi_at_h instead.
+
++
+ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+RSL_free_cappi, RSL_cappi_at_h, RSL_fill_cappi, RSL_get_value_from_cappi + ++
Author: John H. Merritt + diff --git a/doc/RSL_new_carpi.html b/doc/RSL_new_carpi.html new file mode 100644 index 0000000..82fdb8d --- /dev/null +++ b/doc/RSL_new_carpi.html @@ -0,0 +1,31 @@ + + + + +
++ + +
RSL_new_carpi
+ ++ +
Synopsis
+#include "rsl.h"+Carpi *RSL_new_carpi(int xdim, int ydim); + +
+
Description
+Allocates xdim by ydim of Carpi_value. The entire structure is initialized to 0.
+
++
+ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+ +Author: Mike Kolander + diff --git a/doc/RSL_nsig_to_radar.html b/doc/RSL_nsig_to_radar.html new file mode 100644 index 0000000..8232ce9 --- /dev/null +++ b/doc/RSL_nsig_to_radar.html @@ -0,0 +1,57 @@ + + + +
+
+
+ +
RSL_nsig_to_radar
+ ++
+ +
Synopsis
+ +#include "rsl.h"
+Radar *RSL_nsig_to_radar(char *infile);
+
+Radar *RSL_nsig2_to_radar(char *infile);
+
+
+ +
Description
+ +Reads a new SIGMET (aka nsig) file and returns a pointer to the structure +Radar. The input file is specified by the string infile. +If infile is NULL, then stdin is read. The input file may be compressed. +If the data is compressed, it is passed through the GNU gunzip filter. +Thus, compressed data can be any format that gzip understands. Two +versions of SIGMET files exist: Version 1 files, and Version 2 files. +RSL_nsig_to_radar is used to read version 1 files, and, RSL_nsig2_to_radar +is used to read version 2 files.
+ +The radar structure is, essentially, an array of Volumes. The number +and type of volumes allocated is automatically determined from the input +nsig file. +
+ +
Return value
+ +Upon successful completion, RSL_nsig_to_radar returns a pointer to the +structure Radar. Otherwise, NULL is returned and errno is set. +
+ +
See also
+ ++ +
Author: Paul Kucera.
+ + + diff --git a/doc/RSL_print_histogram.html b/doc/RSL_print_histogram.html new file mode 100644 index 0000000..49d22e4 --- /dev/null +++ b/doc/RSL_print_histogram.html @@ -0,0 +1,31 @@ + + + + +
++ + +
RSL_print_histogram
+ ++
+ +
Synopsis
+#include "rsl.h"+void RSL_print_histogram(Histogram *histogram, int min_range, int max_range, char *filename); +
+ +
Description
+Print the structure pointed to by histogram to stdout. min_range and max_range specify the minimum and maximum range of the radar that was used to generate the histogram. ++ +
Return value
+None. ++ +
See also
+RSL_allocate_histogram, RSL_read_histogram, RSL_write_histogram, RSL_get_histogram_from_ray, RSL_get_histogram_from_sweep, RSL_get_histogram_from_volume + +
Author: David B. Wolff + diff --git a/doc/RSL_print_version.html b/doc/RSL_print_version.html new file mode 100644 index 0000000..10be6a4 --- /dev/null +++ b/doc/RSL_print_version.html @@ -0,0 +1,40 @@ + +
+
++ +
RSL_print_version
+ ++
+ +
Synopsis
+ +#include "rsl.h"
+
void RSL_print_version();
+
+
Description
+
+Print the current version of the RSL library. Output to stdout.
+ ++
+ +
Return value
+ +None. +
+ +
See also
+ ++
Author: John H. Merritt + + + diff --git a/doc/RSL_prune.html b/doc/RSL_prune.html new file mode 100644 index 0000000..cd7a90d --- /dev/null +++ b/doc/RSL_prune.html @@ -0,0 +1,35 @@ + + + + +
++ + +
RSL_prune_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_prune_ray(Ray *ray);
+Sweep *RSL_prune_sweep(Sweep *s);
+Volume *RSL_prune_volume(Volume *v);
+Radar *RSL_prune_radar(Radar *radar); + +
+
Description
+These routines eliminates dataless substructures. A search is conducted for any substructures that contain only header information and, when found, are set to NULL. During the initial allocation step for ingest of a data format, substructure header information is minimially filled. It is not generally known if, for instance, a volume is NULL until it can be determined if there have been no rays assigned to it. In such a case, all sweep pointers have been allocated but no ray pointers assigned. Pruning this volume will result in setting the volume to NULL. A ray is pruned if h.nbins is 0. A sweep is pruned if h.nrays is 0. A volume is pruned if h.nsweeps is 0. A radar is pruned if h.nvolumes is 0.
++ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned. ++ +
See also
+RSL_new_radar, RSL_new_volume, RSL_new_sweep, RSL_new_ray,+RSL_copy_volume, RSL_copy_sweep, RSL_copy_ray +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_radar_file_format.html b/doc/RSL_radar_file_format.html new file mode 100644 index 0000000..92e435f --- /dev/null +++ b/doc/RSL_radar_file_format.html @@ -0,0 +1,14 @@ +
+ + + +
++ + +
The radar file format is not yet documented. Nor is it supported.
+It is unclear if it will be supported because we will output UF or HDF. ++ +
Author: John H. Merritt + diff --git a/doc/RSL_radar_header_struct.html b/doc/RSL_radar_header_struct.html new file mode 100644 index 0000000..b752bed --- /dev/null +++ b/doc/RSL_radar_header_struct.html @@ -0,0 +1,41 @@ + + +
+ + + + +
++
typedef struct {
+ int month, day, year;
+ int hour, minute;
+ float sec; /* Second plus fractional part. */
+ char radar_type[50]; /* Type of radar. Use for QC-ing the data.
+ * Supported types are:
+ * "wsr88d", "lassen", "uf",
+ * "nsig", "nsig2", "mcgill",
+ * "kwajalein", "rsl", "toga".
+ * Set by appropriate ingest routine.
+ */
+ int nvolumes;
+ int number; /* arbitrary number of this radar site */
+ char name[8]; /* Nexrad site name */
+ char radar_name[8]; /* Radar name. */
+ char project[24]; /* Project assocated with data. */
+ char city[15]; /* nearest city to radaar site */
+ char state[2]; /* state of radar site */
+ int latd; /* degrees of latitude of site */
+ int latm; /* minutes of latitude of site */
+ int lats; /* seconds of latitude of site */
+ int lond; /* degrees of longitude of site */
+ int lonm; /* minutes of longitude of site */
+ int lons; /* seconds of longitude of site */
+ int height; /* height of site in meters above sea level*/
+ int spulse; /* length of short pulse (ns)*/
+ int lpulse; /* length of long pulse (ns) */
+ int vcp; /* Volume Coverage Pattern (for WSR-88D only) */
+} Radar_header;
+
+
+
diff --git a/doc/RSL_radar_intro.html b/doc/RSL_radar_intro.html
new file mode 100644
index 0000000..7838d5b
--- /dev/null
+++ b/doc/RSL_radar_intro.html
@@ -0,0 +1,112 @@
+
+
+
+
+
+
+
+
++
+
+
+The Radar Software Library (RSL)
+Introduction
+ +
+By John H. Merritt and David
+B. Wolff; NASA/TRMM Office
+Software Verson 1.40 (released 10/10/2008)
+
+This library is an object oriented programming environment to keep +application programming simple, for the casual C programmer, as well as +for analysis software applicable to all RADAR data related to the TRMM +GV effort. This library reads the wsr88d, lassen, kwajalein, mcgill, toga, +UF, RAPIC and native RSL file formats. The most important functions provided +are those which load any one of the radar file formats into memory; see +RSL_anyformat_to_radar. Additional +functions are provide to mainpulate the RSL objects. Nearly all of the +functions return objects. When they don't, they usually perform actions +like output, making images, etc. The most general object in RSL is Radar. +The structure Radar is the method used to define the ideal or universal +radar representation in RAM while keeping the natural resolution of the +data unchanged. More simply, Radar represents the super set of all +radar file formats. The Radar structure +is hierarchically defined such that it is composed of Volumes, each +containing one field type. Volumes are composed of Sweeps. +Sweeps are composed of Rays and Rays contains a vector +of the field type. Some field types are Reflectivity(DZ), Velocity(VR), +Spectrum Width(SW), etc. There are approximately 20 field types. See the +Users Guide and the what's +new for more information. +
An example of a function that returns the Radar object is the +Lassen ingest function. The function allocates all memory required +to store the values from the lassen file in RAM. +
Radar *radar; radar = RSL_lassen_to_radar("lassen.file.22"); +
Syntactically, the object returned is a pointer. However, the functions +provided in RSL treat this pointer as an object. +
The names of the functions in the library are very descriptive of the +function they perform. In the previous example, you may infer that some +conversion from lassen to radar is taking place. Knowing +that lassen is a file format for the Darwin RADAR datasets and that +radar +refers to the data structure Radar helps you understand that the +function ingests lassen files and loads it into the Radar +data structure. +
The data structure Radar is composed of other objects called +Volumes. +You will notice that throughout this discussion, the natural vocabulary +of the scientists who talk about the different components of the data received +from a RADAR is used. This vocabulary is used to describe each component +of the data structure. The Radar data structure holds RADAR measurements +of a volume of physical space for the smallest unit of time possible. Typically +a RADAR can produce a volume of data in 5 to 8 minutes; that becomes the +smallest unit of time for a volume. This volume of space measured is referred +to as Volume, in the RSL, and represents one particular measurement +type or field type. The types of measurements are: reflectivity, velocity, +spectrum width, quality controlled reflectivity, total reflectivity, differential +reflectivity and LDR (another form of differential reflectivity). Normally, +the RADAR records as many fields that it is designed to record and that +really is one volume. However, I have split the fields into seperate volumes +so that you can concentrate on only one field type. Thus, the Radar +datatype is composed of an array of Volumes; one to the number of +fields. +
The Volume data structure, a single field type, is composed of +several 360 degree revolutions of the RADAR. These revolutions are refered +to as sweeps. The first sweep for a volume, commonly known as the base +scan, is the sweep made by the RADAR pointing nearly horizontally and directing +a RADAR beam toward the horizon. Then, the RADAR is tilted upwards slightly +and another revolution is performed. This process continues 10 to 16 times, +depending on the RADAR. These sweeps are referred to as Sweep in +the RSL. Thus, a Volume is simply composed of an array of Sweeps; +one to the number of elevation steps. +
Similiarly, a Sweep is defined as a collection of rays throughout +the 360 degree revolution. The RADAR takes measurements continually while +it is sweeping. The number of rays collected is typically a function of +the beamwidth. A beam width of .95 degrees will yield 379 rays for each +sweep. For nexrad data the number of rays collected for each sweep is approximately +366. These rays are referred to as Ray in the RSL. Thus, a Sweep +is simply an array of Rays; one to the number of rays. +
And, a Ray is one ray measurement from the RADAR. A ray is a +series of measurements from the minimum to the maximum range of the RADAR. +Think of it as a meaurement from zero to the maximum range while the RADAR +is at one azimuthal angle. In reality, the radar is revolving continuously. +The number of data values in a ray is represented in KM and it defines +the resolution of the RADAR. NEXRAD is typcally 1.0KM and the new SIGMET +RADAR is .25 KM. Thus, a Ray is simply an array of Range +values; one to the number of bin. The number of bins is defined by the +range of measured space divided by the resolution of a measurement less +any to the minimum range. +
Finally, a Range value is simply a floating point number that +represents the data. +
It should be obvious that the Radar data structure is an array +of Volumes which is an array of Sweeps which is an array +of Rays which is and array of Ranges. Whew! This hierarchial +description is easy to understand, when you only think of each object as +an array of the next subobject. Thinking of it as a 4 or 5 dimensional +array is very difficult. + + diff --git a/doc/RSL_radar_struct.html b/doc/RSL_radar_struct.html new file mode 100644 index 0000000..8e3ee7c --- /dev/null +++ b/doc/RSL_radar_struct.html @@ -0,0 +1,92 @@ +
+ + + +
++ + +
typedef struct {
+ Radar_header h;
+ Volume **v; /* Array 0..nvolumes-1 of pointers to Volumes.
+ * 0 = DZ_INDEX = reflectivity.
+ * 1 = VR_INDEX = velocity.
+ * 2 = SW_INDEX = spectrum_width.
+ * 3 = CZ_INDEX = corrected reflectivity.
+ * 4 = ZT_INDEX = total reflectivity.
+ * 5 = DR_INDEX = differential refl.
+ * 6 = LR_INDEX = another differential refl.
+ * 7 = ZD_INDEX = another refl form.
+ * 8 = DM_INDEX = recieved power.
+ * 9 = RH_INDEX = Rho coefficient.
+ *10 = PH_INDEX = Phi (MCTEX parameter).
+ *11 = XZ_INDEX = X-band reflectivity.
+ *12 = CR_INDEX = Corrected DR.
+ *13 = MZ_INDEX = DZ mask for 1C-51 HDF.
+ *14 = MR_INDEX = DR mask for 1C-51 HDF.
+ *15 = ZE_INDEX = Edited reflectivity.
+ *16 = VE_INDEX = Edited velocity.
+ *17 = KD_INDEX = KDP (unknown) for MCTEX data.
+ *18 = TI_INDEX = TIME (unknown) for MCTEX data.
+ */
+} Radar;
+
+/*
+ * DZ Reflectivity (dBZ), may contain some DZ_INDEX
+ * signal-processor level QC and/or
+ * filters. This field would contain
+ * Darwin's CZ, or WSR88D's standard
+ * reflectivity. In other words, unless
+ * the field is described otherwise, it
+ * should always go here. In essence, this
+ * is the "cleanest" reflectivity field
+ * for a radar.
+ *
+ * VR Radial Velocity (m/s) VR_INDEX
+ *
+ * SW Spectral Width (m2/s2) SW_INDEX
+ *
+ * CZ QC Reflectivity (dBZ), contains
+ * post-processed QC'd data CZ_INDEX
+ *
+ * ZT Total Reflectivity (dBZ) ZT_INDEX
+ * May be uncommon, but important
+ * This is UZ in UF files.
+ *
+ * DR Differential reflectivity DR_INDEX
+ * DR and LR are for dual-polarization
+ * radars only. Unitless or in dB.
+ *
+ * LR Another form of differential ref LR_INDEX
+ * called LDR, not sure of units
+ *
+ * ZD ZDR: Reflectivity Depolarization Ratio ZD_INDEX
+ * ZDR = 10log(ZH/ZV) (dB)
+ *
+ * DM Received power measured by the radar. DM_INDEX
+ * Units are dBm.
+ *
+ * RH Rho : Correlation coefficient (MCTEX) RH_INDEX
+ *
+ * PH Phi (MCTEX parameter) PH_INDEX
+ *
+ * XZ X-band reflectivity XZ_INDEX
+ *
+ * CD Corrected ZD reflectivity (differential) CD_INDEX
+ * contains QC'ed data
+ *
+ * MZ DZ mask volume for HDF 1C-51 product. MZ_INDEX
+ *
+ * MD ZD mask volume for HDF 1C-51 product. MD_INDEX
+ *
+ * ZE Edited Reflectivity. ZE_INDEX
+ *
+ * VE Edited Velocity. VE_INDEX
+ *
+ * KD KDP (unknown) for MCTEX data. KD_INDEX
+ *
+ * TI TIME (unknown) for MCTEX data. TI_INDEX
+ */
+
+
+
diff --git a/doc/RSL_radar_to_hdf.html b/doc/RSL_radar_to_hdf.html
new file mode 100644
index 0000000..0b3de96
--- /dev/null
+++ b/doc/RSL_radar_to_hdf.html
@@ -0,0 +1,50 @@
+
+
+
+
++ +
RSL_radar_to_hdf
+ ++
+ +
Synopsis
+ +#include "rsl.h"
+int RSL_radar_to_hdf(Radar *radar,
+char *outfile);
+
+ +
Description
+ +Writes HDF files. The output file is specified by outfile. +The organization of the data within the HDF file is specified in NASA +document TSDIS-P907. This is also known as TSDIS ICS Volume 3 (Release +3/Draft). You must preceed the call to RSL_radar_to_hdf with a call to +RSL_set_hdf_qc_parameters.
+ ++
+ +
Return value
+ +Upon successful completion, RSL_radar_to_hdf returns 0. Upon failure, +-1 is returned. +
+ +
See also
+ + + ++ +
Author: Mike Kolander.
+ + + diff --git a/doc/RSL_radar_to_uf.html b/doc/RSL_radar_to_uf.html new file mode 100644 index 0000000..483e865 --- /dev/null +++ b/doc/RSL_radar_to_uf.html @@ -0,0 +1,39 @@ + + + + +
++ + +
RSL_radar_to_uf
+ + +RSL_radar_to_uf_fp
+ + +RSL_radar_to_uf_gzip
+ ++ +
Synopsis
+#include "rsl.h"+void RSL_radar_to_uf(Radar *r, char *outfile);
+void RSL_radar_to_uf_fp(Radar *r, FILE *fp);
+void RSL_radar_to_uf_gzip(Radar *r, char *outfile); + +
+
Description
+Output the Radar structure, pointed to by r, to disk. The output filename is specified in outfile. The output UF file incorporates the NON-UF conforming NCAR record structure. Each UF record is surrounded by a 4 byte integer leading the UF buffer and a 4 byte integer trailing the UF buffer. The integer value represents the number of bytes for the UF buffer. This comes from the unformatted Fortran record descriptors. No UF library needed; the UF code in part of RSL. The routine RSL_radar_to_uf_fp takes a file pointer and is called by RSL_radar_to_uf and RSL_radar_to_uf_gzip. RSL_radar_to_uf_gzip passes the UF output through the GNU gzip compression filter; basically compressing the output on the fly.
++ +
Return value
+None. ++ +
See also
+RSL_uf_to_radar, RSL_write_radar ++ +
Author: John H. Merritt + diff --git a/doc/RSL_radar_verbose.html b/doc/RSL_radar_verbose.html new file mode 100644 index 0000000..8c3f53d --- /dev/null +++ b/doc/RSL_radar_verbose.html @@ -0,0 +1,29 @@ +
+ + + +
++ + +
RSL_radar_verbose...
++ +
Synopsis
+#include "rsl.h"+void RSL_radar_verbose_on(void);
+void RSL_radar_verbose_off(void); +
+ +
Description
+Control the verbosity of messages while using the RSL. After calling radar_verbose_off, the default, the library is quiet. After calling radar_verbose_on, the library writes to stdout informative messages about the current progress. This is useful when using the RSL interactively, since some of the functions take time; it assure you that nothing is hung. ++ +
Return value
+None. ++ +
See also
+ +Author: John Merritt + diff --git a/doc/RSL_radtec_to_radar.html b/doc/RSL_radtec_to_radar.html new file mode 100644 index 0000000..2355bf8 --- /dev/null +++ b/doc/RSL_radtec_to_radar.html @@ -0,0 +1,43 @@ + + + + + + +
++
+RSL_radtec_to_radar
+ ++
+Synopsis
+#include "rsl.h" +Radar *RSL_radtec_to_radar(char +*infile); +
+
+Description
+Reads a RADTEC (SPANDAR) file and returns a pointer to the Radar +structure. The input file is specified by the string infile. If +infile is NULL, then stdin is read. The data is compressed +with PKWARE implode. RSL needs to be installed with -DHAVE_PKWARE +in order to used RSL_radtec_to_radar. + +The radar structure is, essentially, an array of Volumes. These volumes +represent the reflectivity, velocity and spectrum width fields. +
+
+Return value
+Upon successful completion, RSL_radtec_to_radar returns a pointer to the +structure Radar. Otherwise, NULL is returned. A valid Radar +structure will be returned if the infile is valid. ++
+See also
+RSL_anyformat_to_radar ++ +
Author: John H. Merritt. + + diff --git a/doc/RSL_range_struct.html b/doc/RSL_range_struct.html new file mode 100644 index 0000000..206ace6 --- /dev/null +++ b/doc/RSL_range_struct.html @@ -0,0 +1,20 @@ + + +
+
+
If #define USE_TWO_BYTE_PRECISION when building and installing RSL, +then + +
typedef unsigned short Range;+ +
else,
+ +typedef unsigned char Range;+ + + diff --git a/doc/RSL_rapic_to_radar.html b/doc/RSL_rapic_to_radar.html new file mode 100644 index 0000000..245fbea --- /dev/null +++ b/doc/RSL_rapic_to_radar.html @@ -0,0 +1,44 @@ + + + + + + +
++
+RSL_rapic_to_radar
+ ++
+Synopsis
+#include "rsl.h" +Radar *RSL_rapic_to_radar(char +*infile); +
+
+Description
+Reads a RAPIC (data from Berrimah Austrailia) file and returns a pointer +to the structure Radar. The input file is specified by the string +infile. If infile is NULL, then stdin is read. The input +file may be compressed. If the data is compressed, it is passed through +the GNU gunzip filter. Thus, compressed data can be any format that +gzip understands. + +The radar structure is, essentially, an array of Volumes. These volumes +represent several field types, including but not limited to, reflectivity, +velocity and spectrum width fields. +
+
+Return value
+Upon successful completion, RSL_rapic_to_radar returns a pointer to the +structure Radar. Otherwise, NULL is returned and errno is set. ++
+See also
+RSL_anyformat_to_radar ++ +
Author: John H. Merritt. + + diff --git a/doc/RSL_ray_header_struct.html b/doc/RSL_ray_header_struct.html new file mode 100644 index 0000000..2065762 --- /dev/null +++ b/doc/RSL_ray_header_struct.html @@ -0,0 +1,19 @@ + + +
+ + + + +
+
++
typedef struct {
int month; /* Date for this ray; month (1-12). */
int day; /* Date for this ray; day (1-31). */
int year; /* Date for this ray; year (eg. 1993). */
int hour; /* Time for this ray; hour (0-23). */
int minute;/* Time for this ray; minute (0-59).*/
float sec; /* Time for this ray; second + fraction of second. */
float unam_rng; /* Unambiguous range. (KM). */
float azimuth; /* Azimuth angle. (degrees). Must be positive
* 0=North, 90=east, -90/270=west.
* This angle is the mean azimuth for the whole ray.
* Eg. for NSIG the beginning and end azimuths are
* averaged.
*/
int ray_num; /* Ray no. within elevation scan. */
float elev; /* Elevation angle. (degrees). */
int elev_num; /* Elevation no. within volume scan. */
int range_bin1; /* Range to first gate.(meters) */
int gate_size; /* Data gate size (meters)*/
float vel_res; /* Doppler velocity resolution */
float sweep_rate; /* Sweep rate. Full sweeps/min. */
int prf; /* Pulse repitition frequency, in Hz. */
float azim_rate; /* Sweep rate in degrees/second.*/
float fix_angle; /* Elevation angle for the sweep. (degrees). */
float pitch; /* Pitch angle. */
float roll; /* Roll angle. */
float heading; /* Heading. */
float pitch_rate; /* (angle/sec) */
float roll_rate; /* (angle/sec) */
float heading_rate; /* (angle/sec) */
float lat; /* Latitude (degrees) */
float lon; /* Longitude (degrees) */
int alt; /* Altitude (m) */
float rvc; /* Radial velocity correction (m/sec) */
float vel_east; /* Platform velocity to the east (m/sec) */
float vel_north; /* Platform velocity to the north (m/sec) */
float vel_up; /* Platform velocity toward up (m/sec) */
float pulse_count; /* Pulses used in a single dwell time. */
float pulse_width; /* Pulse width (micro-sec). */
float beam_width; /* Beamwidth in degrees. */
float frequency; /* Bandwidth MHz. */
float wavelength; /* Wavelength. Meters. */
float nyq_vel; /* Nyquist velocity. m/s */
float (*f)(Range x); /* Data conversion function. f(x). */
Range (*invf)(float x); /* Data conversion function. invf(x). */
int nbins; /* Number of array elements for 'Range'. */
} Ray_header;
+ + + diff --git a/doc/RSL_ray_struct.html b/doc/RSL_ray_struct.html new file mode 100644 index 0000000..036ecdf --- /dev/null +++ b/doc/RSL_ray_struct.html @@ -0,0 +1,18 @@ + + + + +
++ + +
typedef struct {
+ Ray_header h;
+ Range *range; /* range[0..nbins-1] */
+ /* For wsr88d file:
+ * 0..460 for reflectivity, 0..920 for velocity and
+ * spectrum width. You must allocate this space.
+ */
+} Ray;
+
+
diff --git a/doc/RSL_read.html b/doc/RSL_read.html
new file mode 100644
index 0000000..e016545
--- /dev/null
+++ b/doc/RSL_read.html
@@ -0,0 +1,41 @@
+
+
+
+
+
++ + +
RSL_read_...
+ ++ +
Synopsis
+#include "rsl.h"+Ray *RSL_read_ray(FILE *fp);
+Sweep *RSL_read_sweep(FILE *fp);
+Volume *RSL_read_volume(FILE *fp); + +
+
Description
+RSL_read_volume reads an entire volume structure from the input stream fp. fp is usually assigned inside the routine RSL_read_radar, however, you can assign the stream fp via fopen. RSL_read_volume calls RSL_read_sweep for the number of sweeps, vol->h.nsweeps, as determined from reading fp. Memory is allocated via RSL_new_volume.
+
+RSL_read_sweep reads an entire sweep structure from the input stream fp. RSL_read_sweep calls RSL_read_ray for the number of rays, sweep->h.nrays, as determined by reading fp. Memory is allocated via RSL_new_sweep. + +
RSL_read_ray reads an entire ray structure from the input stream fp. RSL_read_ray ingests an entire ray of data and sets ray->h.nbins. Memory is allocated via RSL_new_ray. +
+ +
Return value
+Upon successful completion, a pointer to the appropriate structure is returned. Otherwise, a NULL pointer is returned and errno is set. ++ +
See also
+Example+RSL_new_volume, RSL_new_sweep, RSL_new_ray,
+RSL_write_volume, RSL_write_sweep, RSL_write_ray,
+RSL_read_radar, RSL_write_radar,
+File format. +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_read_histogram.html b/doc/RSL_read_histogram.html new file mode 100644 index 0000000..194874a --- /dev/null +++ b/doc/RSL_read_histogram.html @@ -0,0 +1,31 @@ +
+ + + +
++ + +
RSL_read_histogram
+ ++ +
Synopsis
+#include "rsl.h"+Histogram *RSL_read_histogram(char *infile); +
+ +
Description
+Read the structure Histogram from the disk file infile. ++ +
Return value
+ +Upon successful completion, a pointer to Histogram is returned. NULL is returned if an error occurs and errno is set. ++
See also
+RSL_write_histogram ++ +
Author: David B. Wolff + diff --git a/doc/RSL_read_radar.html b/doc/RSL_read_radar.html new file mode 100644 index 0000000..3e5ab3d --- /dev/null +++ b/doc/RSL_read_radar.html @@ -0,0 +1,33 @@ +
+ + + +
++ + +
RSL_read_radar
+ ++ +
Synopsis
+#include "rsl.h"+Radar *RSL_read_radar(char *filename); + +
+
Description
+Read the Radar structure from disk. This is the inverse function of RSL_write_radar. The input file may be compressed. If the data is compressed, it is passed through the GNU gunzip filter. Thus, compressed data can be any format that gzip understands. Space for the Radar structure is obtained via calls to the volume routines: RSL_new_volume, RSL_new_sweep, and RSL_new_ray, which obtain their space via the routine malloc.
++ +
Return value
+Upon successful completion, a Radar structure is returned. Otherwise, NULL. ++ +
See also
+RSL_read_volume, RSL_read_sweep, RSL_read_ray,+RSL_write_volume, RSL_write_sweep, RSL_write_ray,
+RSL_read_radar, File format, RSL_anyformat_to_radar +
+ +
Author: John H. Merritt + diff --git a/doc/RSL_read_these_sweeps.html b/doc/RSL_read_these_sweeps.html new file mode 100644 index 0000000..0b690ba --- /dev/null +++ b/doc/RSL_read_these_sweeps.html @@ -0,0 +1,64 @@ + +
+ + + + +
++
+
+
+RSL_read_these_sweeps
+ ++
+Synopsis
+#include "rsl.h" +void RSL_read_these_sweeps(char *sweep#, [char *sweep#...], NULL); +
+
+
+Description
+Call this routine prior to any ingest routine and only the sweeps specified +will be stored in memory. This drastically reduces memory requirements +and speeds up the ingest, especially, if you're only interesed in a few +sweeps. This function is useful, for instance, when you're making +images of the base sweeps. Why bother reading the entire file when +you only need the first sweep? By default, all sweeps are ingested. +The sweep# is a character string representing the sweep number, "4" for +instance. Order does not matter. Specify NULL as the last argument. +This signals this routine when to stop parsing for sweep numbers. +The first sweep is "0". + +The list of possible sweep numbers is: "all", "none", "0", "1", ... + +
Action or side-effects: A second call to this function over-rides any +previous settings. In other words, multiple calls are not additive. +Therefore, you must list all the sweeps you want in a single call. + +
RSL_read_these_sweeps("1", "2", NULL); + +
which reads the second and third sweep is not the same as: + +
RSL_read_these_sweeps("1", NULL);
+
RSL_read_these_sweeps("2", NULL);
+
+
wherein, only the third (index 2) sweep is ingested.
+
+
+
+
+
+Return value
+Upon successful completion, RSL_read_these_sweeps silently sets a hidden +array that each of the specific radar format ingest routines access. ++
+
+See also
+RSL_anyformat_to_radar. ++
Author: John H. Merritt. + + diff --git a/doc/RSL_rebin.html b/doc/RSL_rebin.html new file mode 100644 index 0000000..356483c --- /dev/null +++ b/doc/RSL_rebin.html @@ -0,0 +1,52 @@ + + + + +
++
+RSL_rebin_...
+ ++
+Synopsis
+#include "rsl.h" +void RSL_rebin_ray(Ray *r, int +width); +
void RSL_rebin_sweep(Sweep *s, +int width); +
void RSL_rebin_volume(Volume +*v, int width); +
+
+
Description
+Rebin the data from -width to +width, centered at 0, to a positive value,
+such that -width corresponds to 1, and +width corresponds to the value
+2*width+1.
+
+NOTE: This function modifies its argument: Ray, Sweep, or Volume. Use +this function prior RSL_sweep_to_cart. +The actual binning is done in RSL_rebin_ray. +
+
+Return value
+None. ++
+See also
+RSL_sweep_to_gif, RSL_sweep_to_pict, +RSL_sweep_to_pgm, RSL_sweep_to_ppm, +RSL_load_color_table, RSL_load_green_table, +RSL_load_red_table, RSL_load_blue_table, +
RSL_load_refl_color_table, +RSL_load_sw_color_table, RSL_load_vel_color_table, +
RSL_volume_to_gif, RSL_volume_to_pict, +RSL_volume_to_pgm, RSL_volume_to_ppm. +
+ +
Author: David B. Wolff + + diff --git a/doc/RSL_rebin_velocity.html b/doc/RSL_rebin_velocity.html new file mode 100644 index 0000000..1083086 --- /dev/null +++ b/doc/RSL_rebin_velocity.html @@ -0,0 +1,49 @@ + + +
+ + + + +
++
+RSL_rebin_velocity...
+ ++
+Synopsis
+#include "rsl.h" +void RSL_rebin_velocity_ray(Ray +*r); +
void RSL_rebin_velocity_sweep(Sweep +*s); +
void RSL_rebin_velocity_volume(Volume +*v); +
+
+
Description
+Rebin the velocity data to the range -nyquist, +nyquist. 14 bins are created
+centered at 0. It sets the proper color look up indexes. This function
+modifies Volume v. Use this function prior RSL_sweep_to_cart.
+The binning is done in RSL_rebin_velocity_ray.
++
+Return value
+None. ++
+See also
+RSL_sweep_to_gif, RSL_sweep_to_pict, +RSL_sweep_to_pgm, RSL_sweep_to_ppm, +RSL_load_color_table, RSL_load_green_table, +RSL_load_red_table, RSL_load_blue_table, +
RSL_load_refl_color_table, +RSL_load_sw_color_table, RSL_load_vel_color_table, +
RSL_volume_to_gif, RSL_volume_to_pict, +RSL_volume_to_pgm, RSL_volume_to_ppm, +
RSL_get_color_table, RSL_set_color_table. +
+
Author: John H. Merritt + + diff --git a/doc/RSL_return_eth_sweep.html b/doc/RSL_return_eth_sweep.html new file mode 100644 index 0000000..6ab7b02 --- /dev/null +++ b/doc/RSL_return_eth_sweep.html @@ -0,0 +1,48 @@ + +
+ + + +
++ +
RSL_return_eth_sweep
+ ++ +
Synopsis
+#include "rsl.h"+Sweep *RSL_return_eth_sweep.html( +Vertical_structure *vs,int index); + + +
+
Description
+Given a Vertical_structure data structure created by +RSL_get_vertical_structure and a threshold index, return a Sweep data structure that contains echo top values. The threshold index corresponds +to the original set of threshold values used to create the +Vertical_structure. Index 0 is the first index. ++ +
Return Value
+Upon seccesful completion, a pointer to a Sweep data structure is +returned. Otherwise a NULL pointer is returned. + ++ +
See also
+RSL_return_zmax_sweep, +RSL_return_hzmax_sweep, +RSL_get_vertical_structure, +RSL_free_vertical_structure, +RSL_get_column, + + ++ +
Author: Dennis Flanigan Jr. + + +