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