Pileus Git - ~andy/rsl/blob - rsl.h

   1 /*
   2     NASA/TRMM, Code 910.1.
   3     This is the TRMM Office Radar Software Library.
   4     Copyright (C) 1996  John H. Merritt
   5                         Space Applications Corporation
   6                         Vienna, Virginia, a NASA/GSFC on-site contractor.
   7
   8     This library is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU Library General Public
  10     License as published by the Free Software Foundation; either
  11     version 2 of the License, or (at your option) any later version.
  12
  13     This library is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16     Library General Public License for more details.
  17
  18     You should have received a copy of the GNU Library General Public
  19     License along with this library; if not, write to the Free
  20     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22 #ifndef _rsl_h
  23 #define _rsl_h
  24
  25 /* Are we building the library? */
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 /**********************************************************************/
  31 /* Configure: Define USE_TWO_BYTE_PRECISION to have RSL store internal*/
  32 /*            values with two bytes.  Otherwise, use one byte.        */
  33 /*            It is a good idea to use two byte precision.            */
  34 /*            See 'makefile' for an additional explaination.          */
  35 /*                                                                    */
  36 /**********************************************************************/
  37 #define USE_TWO_BYTE_PRECISION
  38
  39
  40 /**********************************************************************/
  41 /* Configure: Define the file name of the red,green, and blue color   */
  42 /*            color tables.  This maps reflectance to color.          */
  43 /*            This should be $(LIBDIR)/colors, from the makefile      */
  44 /*            so you shouldn't have to modify anything here.          */
  45 /**********************************************************************/
  46 #ifndef COLORDIR
  47 #define COLORDIR DATADIR "/colors"
  48 #endif
  49
  50 /* These are the color table indexes. See RSL_set/get_color_table. */
  51 #define RSL_RED_TABLE   0
  52 #define RSL_GREEN_TABLE 1
  53 #define RSL_BLUE_TABLE  2
  54
  55 /* The default color tables for reflectivity, velocity, spectral width,
  56  * height, rainfall, and zdr.
  57  */
  58 #define REFL_RED_FILE       COLORDIR "/red_reflectivity.clr"
  59 #define REFL_GREEN_FILE     COLORDIR "/grn_reflectivity.clr"
  60 #define REFL_BLUE_FILE      COLORDIR "/blu_reflectivity.clr"
  61 #define VEL_RED_FILE        COLORDIR "/red_velocity.clr"
  62 #define VEL_GREEN_FILE      COLORDIR "/grn_velocity.clr"
  63 #define VEL_BLUE_FILE       COLORDIR "/blu_velocity.clr"
  64 #define SW_RED_FILE         COLORDIR "/red_spectral_width.clr"
  65 #define SW_GREEN_FILE       COLORDIR "/grn_spectral_width.clr"
  66 #define SW_BLUE_FILE        COLORDIR "/blu_spectral_width.clr"
  67 #define HEIGHT_RED_FILE     COLORDIR "/red_height.clr"
  68 #define HEIGHT_GREEN_FILE   COLORDIR "/grn_height.clr"
  69 #define HEIGHT_BLUE_FILE    COLORDIR "/blu_height.clr"
  70 #define RAINFALL_RED_FILE   COLORDIR "/red_rainfall.clr"
  71 #define RAINFALL_GREEN_FILE COLORDIR "/grn_rainfall.clr"
  72 #define RAINFALL_BLUE_FILE  COLORDIR "/blu_rainfall.clr"
  73
  74 /* Added by D. Wolff 07/31/97 */
  75 #define ZDR_RED_FILE   COLORDIR "/red_zdr.clr"
  76 #define ZDR_GREEN_FILE COLORDIR "/grn_zdr.clr"
  77 #define ZDR_BLUE_FILE  COLORDIR "/blu_zdr.clr"
  78
  79 /*************************************************************************/
  80 /*  You should not have to change anything below this line.
  81  *  The rest is my fault.
  82  */
  83 /*************************************************************************/
  84 #include <stdio.h>
  85
  86 /*
  87  * Magic numbers.  These are used to uniquely identify the type of
  88  * values present in a particular structure: Volume, Sweep, Ray.
  89  * The magic numbers V_DZ, V_VR, V_SW, etc.  represent Volume magic
  90  * numbers for the field types DZ, VR, SW, etc.  Similiar magic numbers
  91  * are implimented for Sweep, and Ray.  The magic number is the first word
  92  * of the data structure.  These magic number may determine which conversion
  93  * function is used, see volume.c and the end of this file for the
  94  * conversion functions. (As of v0.39 -- NOT YET IMPLEMENTED.)
  95  */
  96 enum Rsl_magic_num {
  97   V_DZ, V_VR, V_SW, V_CZ, V_ZT, V_DR, V_LR,
  98   S_DZ, S_VR, S_SW, S_CZ, S_ZT, S_DR, S_LR,
  99   R_DZ, R_VR, R_SW, R_CZ, R_ZT, R_DR, R_LR
 100 };
 101
 102 /* File format types recognized by RSL. */
 103 enum File_type {UNKNOWN, WSR88D_FILE, UF_FILE, LASSEN_FILE,
 104                                 TOGA_FILE, NSIG_FILE_V1, NSIG_FILE_V2,
 105                                 RSL_FILE, MCGILL_FILE, HDF_FILE, RAPIC_FILE,
 106                 RADTEC_FILE, EDGE_FILE, DORADE_FILE, RAINBOW_FILE};
 107
 108 /* Pick a BADVAL that is out of range. That is, the range
 109  * of the conversion cannot include these reserved values.
 110  * Typically, pick a number that cannot be stored in the Range data type.
 111  */
 112 #ifdef USE_TWO_BYTE_PRECISION
 113   typedef unsigned short Range;
 114 #define BADVAL  (float)0x20000
 115 #else
 116   typedef unsigned char Range;
 117 #define BADVAL  (float)0500     /* non-meaningful value (500 octal) */
 118 #endif
 119
 120 #define RFVAL (BADVAL-1) /* Range folded value.  See rfival. */
 121 #define APFLAG (BADVAL-2)
 122 #define NOTFOUND_H (BADVAL-3)
 123 #define NOTFOUND_V (BADVAL-4)
 124 #define NOECHO (BADVAL-5) /* For nsig and UF -32, for kwaj -30 */
 125 #define RSL_SPEED_OF_LIGHT 299792458.0 /* m/s */
 126
 127 typedef struct {
 128   int   month; /* Time for this ray; month (1-12). */
 129   int   day;   /* Time for this ray; day (1-31).   */
 130   int   year;  /* Time for this ray; year (eg. 1993). */
 131   int   hour;  /* Date for this ray; hour (0-23). */
 132   int   minute;/* Date for this ray; minute (0-59).*/
 133   float sec;   /* Date for this ray; second + fraction of second. */
 134   float unam_rng;  /* Unambiguous range. (KM). */
 135   float azimuth;   /* Azimuth angle (degrees). Must be positive.
 136                     * 0=North, 90=east, -90/270=west.
 137                     * This angle is the mean azimuth for the whole ray.
 138                     * E.g. for NSIG the beginning and end azimuths are averaged.
 139                     */
 140   int   ray_num;    /* Ray no. within elevation scan. */
 141   float elev;       /* Elevation angle. (degrees). */
 142   int   elev_num;   /* Elevation no. within volume scan. */
 143
 144   int   range_bin1; /* Range to first gate.(meters) */
 145   int   gate_size;  /* Data gate size (meters)*/
 146
 147   float  vel_res;   /* Doppler velocity resolution */
 148   float sweep_rate; /* Sweep rate. Full sweeps/min. */
 149
 150   int prf;          /* Pulse repetition frequency, in Hz. */
 151   int prf2;         /* Second PRF, for Sigmet dual PRF */
 152   float azim_rate;  /* Sweep rate in degrees/sec. */
 153   float fix_angle;  /* Elevation angle for the sweep. (degrees). */
 154   float pitch;      /* Pitch angle. */
 155   float roll;       /* Roll  angle. */
 156   float heading;    /* Heading. */
 157   float pitch_rate; /* (angle/sec) */
 158   float roll_rate;  /* (angle/sec) */
 159   float heading_rate; /* (angle/sec) */
 160   float lat;          /* Latitude (degrees) */
 161   float lon;          /* Longitude (degrees) */
 162   int   alt;          /* Altitude (m) */
 163   float rvc;          /* Radial velocity correction (m/sec) */
 164   float vel_east;     /* Platform velocity to the east (negative for west) (m/sec) */
 165   float vel_north;    /* Platform velocity to the north (negative south) (m/sec) */
 166   float vel_up;       /* Platform velocity toward up (negative down) (m/sec) */
 167   int   pulse_count; /* Pulses used in a single dwell time. */
 168   float pulse_width; /* Pulse width (micro-sec). */
 169   float beam_width;  /* Beamwidth in degrees. */
 170   float frequency;   /* Carrier freq. GHz. */
 171   float wavelength;  /* Wavelength. Meters. */
 172   float nyq_vel;     /* Nyquist velocity. m/s */
 173   float (*f)(Range x);       /* Data conversion function. f(x). */
 174   Range (*invf)(float x);    /* Data conversion function. invf(x). */
 175   int   nbins;               /* Number of array elements for 'Range'. */
 176 } Ray_header;
 177
 178
 179 typedef struct {
 180    Ray_header h;
 181    Range *range;    /* range[0..nbins-1]
 182                      * For wsr88d file:
 183                      * 0..460 for reflectivity, 0..920 for velocity and
 184                      * spectrum width.
 185                      */
 186    } Ray;
 187
 188
 189 typedef struct _azimuth_hash {
 190   Ray *ray;
 191   struct _azimuth_hash *next, *ray_high, *ray_low;
 192 } Azimuth_hash;
 193
 194 typedef struct {
 195   Azimuth_hash **indexes;
 196   int nindexes;
 197 } Hash_table;
 198
 199
 200 typedef struct {
 201   int sweep_num;   /* Integer sweep number.  This may be redundant, since
 202                     * this will be the same as the Volume.sweep array index.*/
 203   float elev;      /* Elevation angle (mean) for the sweep. Value is -999 for
 204                     * RHI. */
 205   float azimuth;   /* Azimuth for the sweep (RHI). Value is -999 for PPI. */
 206   float beam_width;  /* This is in the ray header too. */
 207   float vert_half_bw;  /* Vertical beam width divided by 2 */
 208   float horz_half_bw;  /* Horizontal beam width divided by 2 */
 209
 210   int nrays;
 211   float (*f)(Range x);       /* Data conversion function. f(x). */
 212   Range (*invf)(float x);    /* Data conversion function. invf(x). */
 213 } Sweep_header;
 214
 215 typedef struct {
 216   Sweep_header h;
 217   Ray **ray;               /* ray[0..nrays-1]. */
 218 } Sweep;
 219
 220 typedef struct {
 221   char *type_str;  /* One of:'Reflectivity', 'Velocity' or 'Spectrum width' */
 222   int nsweeps;
 223   float calibr_const;        /* Calibration constant.  HDF specific. */
 224   float (*f)(Range x);       /* Data conversion function. f(x). */
 225   Range (*invf)(float x);    /* Data conversion function. invf(x). */
 226 } Volume_header;
 227
 228 typedef struct {
 229         Volume_header h;           /* Specific info for each elev. */
 230                                    /* Includes resolution: km/bin. */
 231         Sweep **sweep;             /* sweep[0..nsweeps-1]. */
 232 } Volume;
 233
 234
 235
 236 typedef Range Carpi_value;
 237 typedef Range Cappi_value;
 238
 239 typedef struct {
 240   int   month;            /* (1-12). */
 241   int   day;              /* (1-31).   */
 242   int   year;             /* (eg. 1993). */
 243   int   hour;             /* (0-23). */
 244   int   minute;           /* (0-59).*/
 245   float sec;              /* second + fraction of second. */
 246   float dx, dy;           /* Size of cell in km. */
 247   int   nx, ny;           /* Number of cells. */
 248   int   radar_x, radar_y; /* Location of center of radar. */
 249   float height;           /* Height of this Carpi. */
 250   float lat, lon;         /* Lat/lon of lower left corner of Carpi. */
 251   char  radar_type[50];   /* Radar types. */
 252   int   field_type;       /* Same as for Radar. */
 253   int   interp_method;    /* ??? string describing interpolation method. */
 254   float (*f)(Carpi_value x);    /* Data conversion function. f(x). */
 255   Carpi_value (*invf)(float x); /* Data conversion function. invf(x). */
 256   Carpi_value **data;     /* data[ny][nx] */
 257 } Carpi;
 258
 259 /** Cappi data structure info **/
 260 /*  Paul A. Kucera            **/
 261
 262 /* Element in location array of Cappi data structure.
 263  * Each element is elvation and range to data value.
 264  */
 265 typedef struct
 266    {
 267    float elev;        /* elevation angle */
 268    float srange;       /* slant range !!! */
 269    }
 270 Er_loc;
 271
 272 /* Cappi data structure.
 273  */
 274 typedef struct {
 275   int    month;       /* Begin time for this Cappi; month (1-12). */
 276   int    day;         /* Begin time for this Cappi; day (1-31).   */
 277   int    year;        /* Begin time for this Cappi; year (eg. 1993). */
 278   int    hour;        /* Begin date for this Cappi; hour (0-23). */
 279   int    minute;      /* Begin date for this Cappi; minute (0-59).*/
 280   float  sec;         /* Begin date for this Cappi; second + frac. of second.*/
 281   float  height;        /* Height for this Cappi in m */
 282   float  lat;
 283   float  lon;
 284   int    field_type;    /* Value of Constant ??_INDEX */
 285   char   radar_type[50];   /* Value of Constant radar->h.radar_type */
 286   int    interp_method; /* ??? string describing interpolation method. */
 287   Er_loc *loc;          /* elevation and range coordinate array */
 288   Sweep  *sweep;        /* Pointers to rays of data */
 289 } Cappi;
 290
 291 /* The Cube data type. */
 292
 293 typedef Range Cube_value;
 294 typedef Range Slice_value;
 295
 296 typedef struct
 297 {
 298         float lat, lon;
 299         float dx, dy, dz;
 300         int nx, ny, nz;
 301         char *data_type;
 302         Carpi **carpi;         /* Pointers to carpi[0] thru carpi[nz-1] */
 303 } Cube;
 304
 305 typedef struct
 306 {
 307         float dx, dy;
 308         int nx, ny;
 309         char *data_type;
 310   float (*f)(Slice_value x);    /* Data conversion function. f(x). */
 311   Slice_value (*invf)(float x); /* Data conversion function. invf(x). */
 312         Slice_value **data;           /* data[ny][nx]. */
 313 } Slice;
 314
 315 typedef struct {
 316   int nbins;
 317   int low;
 318   int hi;
 319   int ucount;
 320   int ccount;
 321   int *data;
 322 } Histogram;
 323
 324 enum scan_mode {PPI, RHI};
 325
 326 typedef struct {
 327   int month, day, year;
 328   int hour, minute;
 329   float sec; /* Second plus fractional part. */
 330   char radar_type[50]; /* Type of radar.  Use for QC-ing the data.
 331                             * Supported types are:
 332                         * "wsr88d", "lassen", "uf",
 333                         * "nsig", "mcgill",
 334                             * "kwajalein", "rsl", "toga",
 335                         * "rapic", (rapic is Berrimah Austrailia)
 336                                                 * "radtec", (SPANDAR radar at Wallops Is, VA)
 337                                                 * "EDGE",
 338                                                 * "dorade",
 339                                                 * "south_africa".
 340                         * Set by appropriate ingest routine.
 341                         */
 342   int nvolumes;
 343
 344   int number;        /* arbitrary number of this radar site */
 345   char name[8];      /* Nexrad site name */
 346   char radar_name[8]; /* Radar name. */
 347   char project[24];   /* Project identifier. */
 348   char city[15];     /* nearest city to  radar site */
 349   char state[3];     /* state of radar site */
 350   char country[15];
 351   int latd;   /* degrees of latitude of site */
 352   int latm;   /* minutes of latitude of site */
 353   int lats;   /* seconds of latitude of site */
 354   int lond;   /* degrees of longitude of site */
 355   int lonm;   /* minutes of longitude of site */
 356   int lons;   /* seconds of longitude of site */
 357   int height; /* height of site in meters above sea level*/
 358   int spulse; /* length of short pulse (ns)*/
 359   int lpulse; /* length of long pulse (ns) */
 360   int scan_mode; /* 0 = PPI, 1 = RHI */
 361   int vcp;    /* Volume Coverage Pattern (for WSR-88D only) */
 362 } Radar_header;
 363
 364
 365 typedef struct {
 366   Radar_header h;
 367   Volume **v;  /* Array 0..nvolumes-1 of pointers to Volumes.
 368                       * 0 = DZ_INDEX = reflectivity.
 369                       * 1 = VR_INDEX = velocity.
 370                       * 2 = SW_INDEX = spectrum_width.
 371                       * 3 = CZ_INDEX = corrected reflectivity.
 372                       * 4 = ZT_INDEX = uncorrected reflectivity.
 373                       * 5 = DR_INDEX = differential refl.
 374                       * 6 = LR_INDEX = another differential refl.
 375                       * 7 = ZD_INDEX = another differential refl.
 376                       * 8 = DM_INDEX = received power.
 377                       * 9 = RH_INDEX = RhoHV: Horz-Vert power corr coeff
 378                       *10 = PH_INDEX = PhiDP: Differential phase angle
 379                       *11 = XZ_INDEX = X-band reflectivity.
 380                       *12 = CD_INDEX = Corrected DR.
 381                       *13 = MZ_INDEX = DZ mask for 1C-51 HDF.
 382                       *14 = MR_INDEX = DR mask for 1C-51 HDF.
 383                       *15 = ZE_INDEX = Edited reflectivity.
 384                       *16 = VE_INDEX = Edited velocity.
 385                       *17 = KD_INDEX = KDP: Specific differential phase, deg/km.
 386                       *18 = TI_INDEX = TIME (unknown)  for MCTEX data.
 387                       *19 = DX_INDEX
 388                       *20 = CH_INDEX
 389                       *21 = AH_INDEX
 390                       *22 = CV_INDEX
 391                       *23 = AV_INDEX
 392                       *24 = SQ_INDEX = Signal Quality Index (Sigmet)
 393                       *25 = VS_INDEX = Radial Velocity Combined  (DORADE)
 394                       *26 = VL_INDEX = Radial Velocity Combined  (DORADE)
 395                       *27 = VG_INDEX = Radial Velocity Combined  (DORADE)
 396                       *28 = VT_INDEX = Radial Velocity Combined  (DORADE)
 397                       *29 = NP_INDEX = Normalized Coherent Power (DORADE)
 398                       *30 = HC_INDEX = HydroClass (Sigmet)
 399                       *31 = VC_INDEX = Radial Velocity Corrected (Sigmet)
 400                       *32 = V2_INDEX = Radial Velocity for VCP 121 second Doppler cut.
 401                       *33 = S2_INDEX = Spectrum Width  for VCP 121 second Doppler cut.
 402                       *34 = V3_INDEX = Radial Velocity for VCP 121 third Doppler cut.
 403                       *35 = S3_INDEX = Spectrum Width  for VCP 121 third Doppler cut.
 404                 */
 405
 406 } Radar;
 407
 408 /*
 409  * DZ     Reflectivity (dBZ), may contain some     DZ_INDEX
 410  *        signal-processor level QC and/or
 411  *        filters. This field would contain
 412  *        Darwin's CZ, or WSR88D's standard
 413  *        reflectivity. In other words, unless
 414  *        the field is described otherwise, it
 415  *        should always go here. In essence, this
 416  *        is the "cleanest" reflectivity field
 417  *        for a radar.
 418  *
 419  * VR     Radial Velocity (m/s)                    VR_INDEX
 420  *
 421  * SW     Spectral Width (m2/s2)                   SW_INDEX
 422  *
 423  * CZ     QC Reflectivity (dBZ), contains
 424  *        post-processed QC'd data                 CZ_INDEX
 425  *
 426  * ZT     Total Reflectivity (dBZ)                 ZT_INDEX
 427  *        Reflectivity unfiltered for clutter...
 428  *        This is UZ in UF files.
 429  *
 430  * DR     Differential reflectivity                DR_INDEX
 431  *        DR and LR are for dual-polarization
 432  *        radars only. Unitless or in dB.
 433  *
 434  * LR     Another form of differential ref         LR_INDEX
 435  *        called LDR, not sure of units
 436  *
 437  * ZD     ZDR: Reflectivity Depolarization Ratio   ZD_INDEX
 438  *        ZDR = 10log(ZH/ZV)  (dB)
 439  *
 440  * DM     Received power measured by the radar.    DM_INDEX
 441  *        Units are dBm.
 442  *
 443  * RH     RhoHV: Horz-Vert power correlation       RH_INDEX
 444  *        coefficient. (0 to 1) See volume.c
 445  *
 446  * PH     PhiDP: Differential phase angle.         PH_INDEX
 447  *        (0 to 180 deg in steps of 0.71)
 448  *        See volume.c
 449  *
 450  * XZ     X-band reflectivity                      XZ_INDEX
 451  *
 452  * CD     Corrected ZD reflectivity (differential) CD_INDEX
 453  *        contains QC'ed data
 454  *
 455  * MZ     DZ mask volume for HDF 1C-51 product.    MZ_INDEX
 456  *
 457  * MD     ZD mask volume for HDF 1C-51 product.    MD_INDEX
 458  *
 459  * ZE     Edited Reflectivity.                     ZE_INDEX
 460  *
 461  * VE     Edited Velocity.                         VE_INDEX
 462  *
 463  * KD     KDP (deg/km) Differencial Phase          KD_INDEX
 464  *            (Sigmet, Lassen)
 465  *
 466  * TI     TIME (unknown)  for MCTEX data.          TI_INDEX
 467  *
 468  * SQ     SQI: Signal Quality Index. (Sigmet)      SQ_INDEX
 469  *        Decimal fraction from 0 to 1, where 0
 470  *        is noise, 1 is noiseless.
 471  *
 472  * VS     Radial Velocity, Short PRT (m/s) (DORADE)   VS_INDEX
 473  *
 474  * VL     Radial Velocity, Long PRT (m/s)  (DORADE)   VL_INDEX
 475  *
 476  * VG     Radial Velocity, combined (m/s)  (DORADE)   VG_INDEX
 477  *
 478  * VT     Radial Velocity, combined (m/s)  (DORADE)   VT_INDEX
 479  *
 480  * NP     Normalized Coherent Power.       (DORADE)   NP_INDEX
 481  *
 482  * HC     HydroClass: enumerated class.    (Sigmet)   HC_INDEX
 483  *
 484  * VC     Radial Velocity corrected for    (Sigmet)   VC_INDEX
 485  *        Nyquist unfolding.
 486  */
 487
 488 /*
 489  * The number of *_INDEX must never exceed MAX_RADAR_VOLUMES.
 490  * Increase MAX_RADAR_VOLUMES appropriately, for new ingest formats.
 491  *
 492  * Also, when adding new *_INDEXes, you must update the following three arrays
 493  * located near the end of this file: RSL_ftype, RSL_f_list, and  RSL_invf_list.
 494  * You also need to modify volume.c, updating the initialization of array
 495  * rsl_qfield by adding a '1' for each new volume index.
 496  */
 497
 498 #define MAX_RADAR_VOLUMES 42
 499
 500 #define DZ_INDEX 0
 501 #define VR_INDEX 1
 502 #define SW_INDEX 2
 503 #define CZ_INDEX 3
 504 #define ZT_INDEX 4
 505 #define DR_INDEX 5
 506 #define LR_INDEX 6
 507 #define ZD_INDEX 7
 508 #define DM_INDEX 8
 509 #define RH_INDEX 9
 510 #define PH_INDEX 10
 511 #define XZ_INDEX 11
 512 #define CD_INDEX 12
 513 #define MZ_INDEX 13
 514 #define MD_INDEX 14
 515 #define ZE_INDEX 15
 516 #define VE_INDEX 16
 517 #define KD_INDEX 17
 518 #define TI_INDEX 18
 519 #define DX_INDEX 19
 520 #define CH_INDEX 20
 521 #define AH_INDEX 21
 522 #define CV_INDEX 22
 523 #define AV_INDEX 23
 524 #define SQ_INDEX 24
 525 #define VS_INDEX 25
 526 #define VL_INDEX 26
 527 #define VG_INDEX 27
 528 #define VT_INDEX 28
 529 #define NP_INDEX 29
 530 #define HC_INDEX 30
 531 #define VC_INDEX 31
 532 #define V2_INDEX 32
 533 #define S2_INDEX 33
 534 #define V3_INDEX 34
 535 #define S3_INDEX 35
 536 #define CR_INDEX 36
 537 #define CC_INDEX 37
 538 #define PR_INDEX 38
 539 #define SD_INDEX 39
 540 #define ZZ_INDEX 40
 541 #define RD_INDEX 41
 542
 543
 544 /* Prototypes for functions. */
 545 /* Alphabetical and grouped by object returned. */
 546
 547
 548 Radar *RSL_africa_to_radar(char *infile);
 549 Radar *RSL_anyformat_to_radar(char *infile, ...);
 550 Radar *RSL_dorade_to_radar(char *infile);
 551 Radar *RSL_EDGE_to_radar(char *infile);
 552 Radar *RSL_fix_radar_header(Radar *radar);
 553 Radar *RSL_get_window_from_radar(Radar *r, float min_range, float max_range,float low_azim, float hi_azim);
 554 Radar *RSL_hdf_to_radar(char *infile);
 555 Radar *RSL_hdf_to_radar_unQC(char *infile);
 556 Radar *RSL_kwaj_to_radar(char *infile);
 557 Radar *RSL_lassen_to_radar(char *infile);
 558 Radar *RSL_mcgill_to_radar(char *infile);
 559 Radar *RSL_new_radar(int nvolumes);
 560 Radar *RSL_nsig_to_radar(char *infile);
 561 Radar *RSL_nsig2_to_radar(char *infile);
 562 Radar *RSL_prune_radar(Radar *radar);
 563 Radar *RSL_radtec_to_radar(char *infile);
 564 Radar *RSL_rainbow_to_radar(char *infile);
 565 Radar *RSL_rapic_to_radar(char *infile);
 566 Radar *RSL_read_radar(char *infile);
 567 Radar *RSL_sort_radar(Radar *r);
 568 Radar *RSL_toga_to_radar(char *infile);
 569 Radar *RSL_uf_to_radar(char *infile);
 570 Radar *RSL_uf_to_radar_fp(FILE *fp);
 571 Radar *RSL_wsr88d_to_radar(char *infile, char *call_or_first_tape_file);
 572
 573 Volume *RSL_clear_volume(Volume *v);
 574 Volume *RSL_copy_volume(Volume *v);
 575 Volume *RSL_fix_volume_header(Volume *v);
 576 Volume *RSL_get_volume(Radar *r, int type_wanted);
 577 Volume *RSL_get_window_from_volume(Volume *v, float min_range, float max_range, float low_azim, float hi_azim);
 578 Volume *RSL_new_volume(int max_sweeps);
 579 Volume *RSL_prune_volume(Volume *v);
 580 Volume *RSL_read_volume(FILE *fp);
 581 Volume *RSL_reverse_sweep_order(Volume *v);
 582 Volume *RSL_sort_rays_in_volume(Volume *v);
 583 Volume *RSL_sort_sweeps_in_volume(Volume *v);
 584 Volume *RSL_sort_volume(Volume *v);
 585 Volume *RSL_volume_z_to_r(Volume *z_volume, float k, float a);
 586
 587 Sweep *RSL_clear_sweep(Sweep *s);
 588 Sweep *RSL_copy_sweep(Sweep *s);
 589 Sweep *RSL_fix_sweep_header(Sweep *sweep);
 590 Sweep *RSL_get_closest_sweep(Volume *v,float sweep_angle,float limit);
 591 Sweep *RSL_get_eth_sweep(Volume *v,float et_point,float max_range);
 592 Sweep *RSL_get_first_sweep_of_volume(Volume *v);
 593 Sweep *RSL_get_sweep(Volume *v, float elev);
 594 Sweep *RSL_get_window_from_sweep(Sweep *s, float min_range, float max_range, float low_azim, float hi_azim);
 595
 596 Sweep *RSL_new_sweep(int max_rays);
 597 Sweep *RSL_prune_sweep(Sweep *s);
 598 Sweep *RSL_read_sweep (FILE *fp);
 599 Sweep *RSL_sort_rays_in_sweep(Sweep *s);
 600 Sweep *RSL_sort_rays_by_time(Sweep *s);
 601 Sweep *RSL_sweep_z_to_r(Sweep *z_sweep, float k, float a);
 602
 603 Ray *RSL_clear_ray(Ray *r);
 604 Ray *RSL_copy_ray(Ray *r);
 605 Ray *RSL_get_closest_ray_from_sweep(Sweep *s,float ray_angle,float limit);
 606 Ray *RSL_get_first_ray_of_sweep(Sweep *s);
 607 Ray *RSL_get_first_ray_of_volume(Volume *v);
 608 Ray *RSL_get_closest_ray_from_sweep(Sweep *s,float ray_angle,float limit);
 609 Ray *RSL_get_next_ccwise_ray(Sweep *s, Ray *ray);
 610 Ray *RSL_get_next_cwise_ray(Sweep *s, Ray *ray);
 611 Ray *RSL_get_ray(Volume *v, float elev, float azimuth);
 612 Ray *RSL_get_ray_above(Volume *v, Ray *current_ray);
 613 Ray *RSL_get_ray_below(Volume *v, Ray *current_ray);
 614 Ray *RSL_get_ray_from_sweep(Sweep *s, float azim);
 615 Ray *RSL_get_window_from_ray(Ray *r, float min_range, float max_range, float low_azim, float hi_azim);
 616 Ray *RSL_new_ray(int max_bins);
 617 Ray *RSL_prune_ray(Ray *ray);
 618 Ray *RSL_ray_z_to_r(Ray *z_ray, float k, float a);
 619 Ray *RSL_read_ray   (FILE *fp);
 620
 621
 622 float RSL_area_of_ray(Ray *r, float lo, float hi, float min_range, float max_range);
 623 float RSL_fraction_of_ray(Ray *r, float lo, float hi, float range);
 624 float RSL_fraction_of_sweep(Sweep *s, float lo, float hi, float range);
 625 float RSL_fraction_of_volume(Volume *v, float lo, float hi, float range);
 626 float RSL_fractional_area_of_sweep(Sweep *s, float lo, float hi, float min_rng, float max_rng);
 627 float RSL_get_echo_top_height(Volume *v,float azim,float grange, float et_point);
 628 float RSL_get_linear_value(Volume *v,float srange,float azim,float elev,float limit);
 629 float RSL_get_nyquist_from_radar(Radar *radar);
 630 float RSL_get_range_of_range_index(Ray *ray, int index);
 631 float RSL_get_value(Volume *v, float elev, float azimuth, float range);
 632 float RSL_get_value_at_h(Volume *v, float azim, float grnd_r, float h);
 633 float RSL_get_value_from_cappi(Cappi *cappi, float rng, float azm);
 634 float RSL_get_value_from_ray(Ray *ray, float r);
 635 float RSL_get_value_from_sweep(Sweep *s, float azim, float r);
 636 float RSL_z_to_r(float z, float k, float a);
 637
 638 int RSL_fill_cappi(Volume *v, Cappi *cap, int method);
 639 int RSL_get_ray_index_from_sweep(Sweep *s, float azim,int *next_closest);
 640 int RSL_get_sweep_index_from_volume(Volume *v, float elev,int *next_closest);
 641 int RSL_radar_to_hdf(Radar *radar, char *outfile);
 642 int RSL_write_histogram(Histogram *histogram, char *outfile);
 643 int RSL_write_ray(Ray *r, FILE *fp);
 644 int RSL_write_sweep(Sweep *s, FILE *fp);
 645 int RSL_write_radar(Radar *radar, char *outfile);
 646 int RSL_write_radar_gzip(Radar *radar, char *outfile);
 647 int RSL_write_volume(Volume *v, FILE *fp);
 648
 649 unsigned char *RSL_rhi_sweep_to_cart(Sweep *s, int xdim, int ydim, float range,
 650                                                                          int vert_scale);
 651 unsigned char *RSL_sweep_to_cart(Sweep *s, int xdim, int ydim, float range);
 652
 653 void RSL_add_dbz_offset_to_ray(Ray *r, float dbz_offset);
 654 void RSL_add_dbz_offset_to_sweep(Sweep *s, float dbz_offset);
 655 void RSL_add_dbz_offset_to_volume(Volume *v, float dbz_offset);
 656 void RSL_bscan_ray(Ray *r, FILE *fp);
 657 void RSL_bscan_sweep(Sweep *s, char *outfile);
 658 void RSL_bscan_volume(Volume *v, char *basename);
 659 void RSL_find_rng_azm(float *r, float *ang, float x, float y);
 660 void RSL_fix_time (Ray *ray);
 661 void RSL_float_to_char(float *x, Range *c, int n);
 662
 663 void RSL_free_cappi(Cappi *c);
 664 void RSL_free_carpi(Carpi *carpi);
 665 void RSL_free_cube(Cube *cube);
 666 void RSL_free_histogram(Histogram *histogram);
 667 void RSL_free_ray(Ray *r);
 668 void RSL_free_slice(Slice *slice);
 669 void RSL_free_sweep(Sweep *s);
 670 void RSL_free_radar(Radar *r);
 671 void RSL_free_volume(Volume *v);
 672 void RSL_get_color_table(int icolor, char buffer[256], int *ncolors);
 673 void RSL_get_groundr_and_h(float slant_r, float elev, float *gr, float *h);
 674 void RSL_get_slantr_and_elev(float gr, float h, float *slant_r, float *elev);
 675 void RSL_get_slantr_and_h(float gr, float elev, float *slant_r, float *h);
 676 void RSL_load_color_table(char *infile, char buffer[256], int *ncolors);
 677 void RSL_load_height_color_table();
 678 void RSL_load_rainfall_color_table();
 679 void RSL_load_refl_color_table();
 680 void RSL_load_vel_color_table();
 681 void RSL_load_sw_color_table();
 682 void RSL_load_zdr_color_table();
 683 void RSL_load_red_table(char *infile);
 684 void RSL_load_green_table(char *infile);
 685 void RSL_load_blue_table(char *infile);
 686 void RSL_print_histogram(Histogram *histogram, int min_range, int max_range,
 687                                                  char *filename);
 688 void RSL_print_version();
 689 void RSL_prune_radar_on();
 690 void RSL_prune_radar_off();
 691 void RSL_radar_to_uf(Radar *r, char *outfile);
 692 void RSL_radar_to_uf_gzip(Radar *r, char *outfile);
 693 void RSL_radar_verbose_off(void);
 694 void RSL_radar_verbose_on(void);
 695 void RSL_read_these_sweeps(char *csweep, ...);
 696 void RSL_rebin_velocity_ray(Ray *r);
 697 void RSL_rebin_velocity_sweep(Sweep *s);
 698 void RSL_rebin_velocity_volume(Volume *v);
 699 void RSL_rebin_zdr_ray(Ray *r);
 700 void RSL_rebin_zdr_sweep(Sweep *s);
 701 void RSL_rebin_zdr_volume(Volume *v);
 702 void RSL_rhi_sweep_to_gif(Sweep *s, char *outfile, int xdim, int ydim, float range,
 703                                                   int vert_scale);
 704 void RSL_select_fields(char *field_type, ...);
 705 void RSL_set_color_table(int icolor, char buffer[256], int ncolors);
 706 void RSL_sweep_to_gif(Sweep *s, char *outfile, int xdim, int ydim, float range);
 707 void RSL_sweep_to_pgm(Sweep *s, char *outfile, int xdim, int ydim, float range);
 708 void RSL_sweep_to_pict(Sweep *s, char *outfile, int xdim, int ydim, float range);
 709 void RSL_sweep_to_ppm(Sweep *s, char *outfile, int xdim, int ydim, float range);
 710 void RSL_volume_to_gif(Volume *v, char *basename, int xdim, int ydim, float range);
 711 void RSL_volume_to_pgm(Volume *v, char *basename, int xdim, int ydim, float range);
 712 void RSL_volume_to_pict(Volume *v, char *basename, int xdim, int ydim, float range);
 713 void RSL_volume_to_ppm(Volume *v, char *basename, int xdim, int ydim, float range);
 714 void RSL_write_gif(char *outfile, unsigned char *image,
 715                                    int xdim, int ydim, char c_table[256][3]);
 716 void RSL_write_pgm(char *outfile, unsigned char *image,
 717                    int xdim, int ydim);
 718 void RSL_write_pict(char *outfile, unsigned char *image,
 719                     int xdim, int ydim, char c_table[256][3]);
 720 void RSL_write_ppm(char *outfile, unsigned char *image,
 721                    int xdim, int ydim, char c_table[256][3]);
 722
 723
 724 Cappi *RSL_new_cappi(Sweep *sweep, float height);
 725 Cappi *RSL_cappi_at_h(Volume  *v, float height, float max_range);
 726
 727 Carpi *RSL_cappi_to_carpi(Cappi *cappi, float dx, float dy,
 728                                                   float lat, float lon,
 729                                                   int nx, int ny, int radar_x, int radar_y);
 730 Carpi *RSL_new_carpi(int nrows, int ncols);
 731 Carpi *RSL_volume_to_carpi(Volume *v, float h, float grnd_r,
 732                                                 float dx, float dy, int nx, int ny,
 733                                                 int radar_x, int radar_y, float lat, float lon);
 734
 735 Cube *RSL_new_cube(int ncarpi);
 736 Cube *RSL_volume_to_cube(Volume *v, float dx, float dy, float dz,
 737                                           int nx, int ny, int nz, float grnd_r,
 738                                           int radar_x, int radar_y, int radar_z);
 739
 740 Slice *RSL_new_slice(int nrows, int ncols);
 741 Slice *RSL_get_slice_from_cube(Cube *cube, int x, int y, int z);
 742
 743
 744 Histogram *RSL_allocate_histogram(int low, int hi);
 745 Histogram *RSL_get_histogram_from_ray(Ray *ray, Histogram *histogram,
 746                                                                           int low, int hi, int min_range,
 747                                                                           int max_range);
 748 Histogram *RSL_get_histogram_from_sweep(Sweep *sweep, Histogram *histogram,
 749                                                                                 int low, int hi, int min_range,
 750                                                                                 int max_range);
 751 Histogram *RSL_get_histogram_from_volume(Volume *volume, Histogram *histogram,
 752                                                                                  int low, int hi, int min_range,
 753                                                                                  int max_range);
 754 Histogram *RSL_read_histogram(char *infile);
 755
 756 int no_command (char *cmd);
 757 FILE *uncompress_pipe (FILE *fp);
 758 FILE *compress_pipe (FILE *fp);
 759 int rsl_pclose(FILE *fp);
 760
 761 /* Carpi image generation functions. These are modified clones of the
 762          corresponding sweep image generation functions.
 763 */
 764 unsigned char *RSL_carpi_to_cart(Carpi *carpi, int xdim, int ydim,
 765                                                                                                                                  float range);
 766 void RSL_carpi_to_gif(Carpi *carpi, char *outfile, int xdim, int ydim,
 767                                                                                         float range);
 768 void RSL_carpi_to_pict(Carpi *carpi, char *outfile, int xdim, int ydim,
 769                                                                                          float range);
 770 void RSL_carpi_to_ppm(Carpi *carpi, char *outfile, int xdim, int ydim,
 771                                                                                         float range);
 772 void RSL_carpi_to_pgm(Carpi *carpi, char *outfile, int xdim, int ydim,
 773                                                                                         float range);
 774
 775 /* Internal storage conversion functions. These may be any conversion and
 776  * may be dynamically defined; based on the input data conversion.
 777  */
 778 float DZ_F(Range x);
 779 float VR_F(Range x);
 780 float SW_F(Range x);
 781 float CZ_F(Range x);
 782 float ZT_F(Range x);
 783 float DR_F(Range x);
 784 float LR_F(Range x);
 785 float ZD_F(Range x);
 786 float DM_F(Range x);
 787 float RH_F(Range x);
 788 float PH_F(Range x);
 789 float XZ_F(Range x);
 790 float CD_F(Range x);
 791 float MZ_F(Range x);
 792 float MD_F(Range x);
 793 float ZE_F(Range x);
 794 float VE_F(Range x);
 795 float KD_F(Range x);
 796 float TI_F(Range x);
 797 float DX_F(Range x);
 798 float CH_F(Range x);
 799 float AH_F(Range x);
 800 float CV_F(Range x);
 801 float AV_F(Range x);
 802 float SQ_F(Range x);
 803 float VS_F(Range x);
 804 float VL_F(Range x);
 805 float VG_F(Range x);
 806 float VT_F(Range x);
 807 float NP_F(Range x);
 808 float HC_F(Range x);
 809 float VC_F(Range x);
 810 float SD_F(Range x);
 811
 812 Range DZ_INVF(float x);
 813 Range VR_INVF(float x);
 814 Range SW_INVF(float x);
 815 Range CZ_INVF(float x);
 816 Range ZT_INVF(float x);
 817 Range DR_INVF(float x);
 818 Range LR_INVF(float x);
 819 Range ZD_INVF(float x);
 820 Range DM_INVF(float x);
 821 Range RH_INVF(float x);
 822 Range PH_INVF(float x);
 823 Range XZ_INVF(float x);
 824 Range CD_INVF(float x);
 825 Range MZ_INVF(float x);
 826 Range MD_INVF(float x);
 827 Range ZE_INVF(float x);
 828 Range VE_INVF(float x);
 829 Range KD_INVF(float x);
 830 Range TI_INVF(float x);
 831 Range DX_INVF(float x);
 832 Range CH_INVF(float x);
 833 Range AH_INVF(float x);
 834 Range CV_INVF(float x);
 835 Range AV_INVF(float x);
 836 Range SQ_INVF(float x);
 837 Range VS_INVF(float x);
 838 Range VL_INVF(float x);
 839 Range VG_INVF(float x);
 840 Range VT_INVF(float x);
 841 Range NP_INVF(float x);
 842 Range HC_INVF(float x);
 843 Range VC_INVF(float x);
 844 Range SD_INVF(float x);
 845
 846
 847 /* If you like these variables, you can use them in your application
 848  * by defining USE_RSL_VARS before #include "rsl.h"
 849  */
 850 #ifdef USE_RSL_VARS
 851 static char *RSL_ftype[] = {"DZ", "VR", "SW", "CZ", "ZT", "DR",
 852                             "LR", "ZD", "DM", "RH", "PH", "XZ",
 853                             "CD", "MZ", "MD", "ZE", "VE", "KD",
 854                             "TI", "DX", "CH", "AH", "CV", "AV",
 855                             "SQ", "VS", "VL", "VG", "VT", "NP",
 856                             "HC", "VC", "V2", "S2", "V3", "S3",
 857                             "CR", "CC", "PR", "SD", "ZZ", "RD"};
 858
 859 static  float (*RSL_f_list[])(Range x) = {DZ_F, VR_F, SW_F, CZ_F, ZT_F, DR_F,
 860                                           LR_F, ZD_F, DM_F, RH_F, PH_F, XZ_F,
 861                                           CD_F, MZ_F, MD_F, ZE_F, VE_F, KD_F,
 862                                           TI_F, DX_F, CH_F, AH_F, CV_F, AV_F,
 863                                           SQ_F, VS_F, VL_F, VG_F, VT_F, NP_F,
 864                                           HC_F, VC_F, VR_F, SW_F, VR_F, SW_F,
 865                                           DZ_F, CZ_F, PH_F, SD_F, DZ_F, DZ_F};
 866
 867 static  Range (*RSL_invf_list[])(float x)
 868          = {DZ_INVF, VR_INVF, SW_INVF, CZ_INVF, ZT_INVF, DR_INVF,
 869             LR_INVF, ZD_INVF, DM_INVF, RH_INVF, PH_INVF, XZ_INVF,
 870             CD_INVF, MZ_INVF, MD_INVF, ZE_INVF, VE_INVF, KD_INVF,
 871             TI_INVF, DX_INVF, CH_INVF, AH_INVF, CV_INVF, AV_INVF,
 872             SQ_INVF, VS_INVF, VL_INVF, VG_INVF, VT_INVF, NP_INVF,
 873             HC_INVF, VC_INVF, VR_INVF, SW_INVF, VR_INVF, SW_INVF,
 874             DZ_INVF, CZ_INVF, PH_INVF, SD_INVF, DZ_INVF, DZ_INVF};
 875 #endif
 876 /* Secret routines that are quite useful and useful to developers. */
 877 void radar_load_date_time(Radar *radar);
 878 int big_endian(void);
 879 int little_endian(void);
 880 void swap_4_bytes(void *word);
 881 void swap_2_bytes(void *word);
 882 Hash_table *hash_table_for_sweep(Sweep *s);
 883 int hash_bin(Hash_table *table,float angle);
 884 Azimuth_hash *the_closest_hash(Azimuth_hash *hash, float ray_angle);
 885 Hash_table *construct_sweep_hash_table(Sweep *s);
 886 double       angle_diff(float x, float y);
 887 int rsl_query_field(char *c_field);
 888
 889
 890 /* Debugging prototypes. */
 891 void poke_around_volume(Volume *v);
 892
 893 /* SYSTEM: left out prototypes? */
 894 extern int pclose (FILE *f); /* From stdio.h */
 895
 896 #endif