Sweep *RSL_sweep_z_to_r(Sweep *z_sweep, float k, float a)
{
Sweep *r_sweep;
int i;
if(z_sweep == NULL) return NULL;
r_sweep = RSL_new_sweep(z_sweep->h.nrays);
r_sweep->h = z_sweep->h;
for(i=0; i<z_sweep->h.nrays; i++) {
r_sweep->ray[i] = RSL_ray_z_to_r(z_sweep->ray[i], k, a);
}
return r_sweep;
}
int wsr88d_load_sweep_into_volume(Wsr88d_sweep ws,
Volume *v, int nsweep, unsigned int vmask)
{
int i;
int iray;
float v_data[1000];
Range c_data[1000];
int n;
int mon, day, year;
int hh, mm, ss;
float fsec;
int vol_cpat;
Ray *ray_ptr;
Range (*invf)(float x);
float (*f)(Range x);
/* Allocate memory for MAX_RAYS_IN_SWEEP rays. */
v->sweep[nsweep] = RSL_new_sweep(MAX_RAYS_IN_SWEEP);
if (v->sweep[nsweep] == NULL) {
perror("wsr88d_load_sweep_into_volume: RSL_new_sweep");
return -1;
}
v->sweep[nsweep]->h.nrays = 0;
f = (float (*)(Range x))NULL;
invf = (Range (*)(float x))NULL;
if (vmask & WSR88D_DZ) { invf = DZ_INVF; f = DZ_F; }
if (vmask & WSR88D_VR) { invf = VR_INVF; f = VR_F; }
if (vmask & WSR88D_SW) { invf = SW_INVF; f = SW_F; }
v->h.invf = invf;
v->h.f = f;
v->sweep[nsweep]->h.invf = invf;
v->sweep[nsweep]->h.f = f;
for (i=0,iray=0; i<MAX_RAYS_IN_SWEEP; i++) {
if (ws.ray[i] != NULL) {
wsr88d_ray_to_float(ws.ray[i], vmask, v_data, &n);
float_to_range(v_data, c_data, n, invf);
if (n > 0) {
wsr88d_get_date(ws.ray[i], &mon, &day, &year);
wsr88d_get_time(ws.ray[i], &hh, &mm, &ss, &fsec);
/*
fprintf(stderr,"n %d, mon %d, day %d, year %d, hour %d, min %d, sec %d, fsec %f\n",
n, mon, day, year, hh, mm, ss, fsec);
*/
/*
* Load the sweep/ray headar information.
*/
v->sweep[nsweep]->ray[iray] = RSL_new_ray(n);
/*(Range *)calloc(n, sizeof(Range)); */
ray_ptr = v->sweep[nsweep]->ray[iray]; /* Make code below readable. */
ray_ptr->h.f = f;
ray_ptr->h.invf = invf;
ray_ptr->h.month = mon;
ray_ptr->h.day = day;
ray_ptr->h.year = year + 1900; /* Yes 1900 makes this year 2000 compliant, due to wsr88d using unix time(). */
ray_ptr->h.hour = hh;
ray_ptr->h.minute = mm;
ray_ptr->h.sec = ss + fsec;
ray_ptr->h.unam_rng = wsr88d_get_range (ws.ray[i]);
ray_ptr->h.azimuth = wsr88d_get_azimuth (ws.ray[i]);
/* -180 to +180 is converted to 0 to 360 */
if (ray_ptr->h.azimuth < 0) ray_ptr->h.azimuth += 360;
ray_ptr->h.ray_num = ws.ray[i]->ray_num;
ray_ptr->h.elev = wsr88d_get_elevation_angle(ws.ray[i]);
ray_ptr->h.elev_num = ws.ray[i]->elev_num;
if (vmask & WSR88D_DZ) {
ray_ptr->h.range_bin1 = ws.ray[i]->refl_rng;
ray_ptr->h.gate_size = ws.ray[i]->refl_size;
} else {
ray_ptr->h.range_bin1 = ws.ray[i]->dop_rng;
ray_ptr->h.gate_size = ws.ray[i]->dop_size;
}
ray_ptr->h.vel_res = wsr88d_get_velocity_resolution(ws.ray[i]);
vol_cpat = wsr88d_get_volume_coverage(ws.ray[i]);
switch (vol_cpat) {
case 11: ray_ptr->h.sweep_rate = 16.0/5.0; break;
case 12: ray_ptr->h.sweep_rate = 17.0/4.2; break;
case 21: ray_ptr->h.sweep_rate = 11.0/6.0; break;
case 31: ray_ptr->h.sweep_rate = 8.0/10.0; break;
case 32: ray_ptr->h.sweep_rate = 7.0/10.0; break;
case 121:ray_ptr->h.sweep_rate = 20.0/5.5; break;
default: ray_ptr->h.sweep_rate = 0.0; break;
}
ray_ptr->h.nyq_vel = wsr88d_get_nyquist(ws.ray[i]);
ray_ptr->h.azim_rate = wsr88d_get_azimuth_rate(ws.ray[i]);
ray_ptr->h.fix_angle = wsr88d_get_fix_angle(ws.ray[i]);
ray_ptr->h.pulse_count = wsr88d_get_pulse_count(ws.ray[i]);
ray_ptr->h.pulse_width = wsr88d_get_pulse_width(ws.ray[i]);
ray_ptr->h.beam_width = .95;
ray_ptr->h.prf = wsr88d_get_prf(ws.ray[i]);
ray_ptr->h.frequency = wsr88d_get_frequency(ws.ray[i]);
ray_ptr->h.wavelength = 0.1071; /* Previously called
* wsr88d_get_wavelength(ws.ray[i]).
* See wsr88d.c for explanation.
*/
/* It is no coincidence that the 'vmask' and wsr88d datatype
* values are the same. We expect 'vmask' to be one of
* REFL_MASK, VEL_MASK, or SW_MASK. These match WSR88D_DZ,
* WSR88D_VR, and WSR88D_SW in the wsr88d library.
*/
ray_ptr->h.nbins = n;
memcpy(ray_ptr->range, c_data, n*sizeof(Range));
v->sweep[nsweep]->h.nrays = iray+1;
v->sweep[nsweep]->h.elev += ray_ptr->h.elev;
v->sweep[nsweep]->h.sweep_num = ray_ptr->h.elev_num;
iray++;
}
}
}
v->sweep[nsweep]->h.beam_width = .95;
v->sweep[nsweep]->h.vert_half_bw = .475;
v->sweep[nsweep]->h.horz_half_bw = .475;
/* Now calculate the mean elevation angle for this sweep. */
if (v->sweep[nsweep]->h.nrays > 0)
v->sweep[nsweep]->h.elev /= v->sweep[nsweep]->h.nrays;
else {
free(v->sweep[nsweep]); /* No rays loaded, free this sweep. */
v->sweep[nsweep] = NULL;
}
return 0;
}
int uf_into_radar(UF_buffer uf, Radar **the_radar)
{
/* Missing data flag : -32768 when a signed short. */
#define UF_NO_DATA 0X8000
/* Any convensions may be observed, however, Radial Velocity must be VE. */
/* Typically:
* DM = Reflectivity (dB(mW)).
* DZ = Reflectivity (dBZ).
* VR = Radial Velocity.
* CZ = Corrected Reflectivity. (Quality controlled: AP removed, etc.)
* SW = Spectrum Width.
* DR = Differential Reflectivity.
* XZ = X-band Reflectivity.
*
* These fields may appear in any order in the UF file.
*
* RETURN:
* UF_DONE if we're done with the UF ingest.
* UF_MORE if we need more UF data.
*/
/* These are pointers to various locations within the UF buffer 'uf'.
* They are used to index the different components of the UF structure in
* a manor consistant with the UF documentation. For instance, uf_ma[1]
* will be equivalenced to the second word (2 bytes/each) of the UF
* buffer.
*/
short *uf_ma; /* Mandatory header block. */
short *uf_lu; /* Local Use header block. */
short *uf_dh; /* Data header. */
short *uf_fh; /* Field header. */
short *uf_data; /* Data. */
/* The length of each header. */
int len_data, len_lu;
int current_fh_index;
float scale_factor;
int nfields, isweep, ifield, iray, i, m;
static int pulled_time_from_first_ray = 0;
char *field_type; /* For printing the field type upon error. */
short proj_name[4];
Ray *ray;
Sweep *sweep;
Radar *radar;
float x;
short missing_data;
Volume *new_volume;
int nbins;
extern int rsl_qfield[];
extern int *rsl_qsweep; /* See RSL_read_these_sweeps in volume.c */
extern int rsl_qsweep_max;
radar = *the_radar;
/*
* The organization of the Radar structure is by volumes, then sweeps, then
* rays, then gates. This is different from the UF file organization.
* The UF format is sweeps, rays, then gates for all field types (volumes).
*/
/* Set up all the UF pointers. */
uf_ma = uf;
uf_lu = uf + uf_ma[3] - 1;
uf_dh = uf + uf_ma[4] - 1;
nfields = uf_dh[0];
isweep = uf_ma[9] - 1;
if (rsl_qsweep != NULL) {
if (isweep > rsl_qsweep_max) return UF_DONE;
if (rsl_qsweep[isweep] == 0) return UF_MORE;
}
/* Here is a sticky part. We must make sure that if we encounter any
* additional fields that were not previously present, that we are able
* to load them. This will require us to copy the entire radar structure
* and whack off the old one. But, we must be sure that it really is a
* new field. This is not so trivial as a couple of lines of code; I will
* have to think about this a little bit more. See STICKYSOLVED below.
*/
#ifdef STICKYSOLVED
if (radar == NULL) radar = RSL_new_radar(nfields);
/* Sticky solution here. */
#else
if (radar == NULL) {
radar = RSL_new_radar(MAX_RADAR_VOLUMES);
*the_radar = radar;
pulled_time_from_first_ray = 0;
for (i=0; i<MAX_RADAR_VOLUMES; i++)
if (rsl_qfield[i]) /* See RSL_select_fields in volume.c */
radar->v[i] = RSL_new_volume(20);
}
#endif
/* For LITTLE ENDIAN:
* WE "UNSWAP" character strings. Because there are so few of them,
* it is easier to catch them here. The entire UF buffer is swapped prior
* to entry to here, therefore, undo-ing these swaps; sets the
* character strings right.
*/
for (i=0; i<nfields; i++) {
if (little_endian()) swap_2_bytes(&uf_dh[3+2*i]); /* Unswap. */
if (strncmp((char *)&uf_dh[3+2*i], "DZ", 2) == 0) ifield = DZ_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "VR", 2) == 0) ifield = VR_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "SW", 2) == 0) ifield = SW_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "CZ", 2) == 0) ifield = CZ_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "UZ", 2) == 0) ifield = ZT_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "ZT", 2) == 0) ifield = ZT_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "DR", 2) == 0) ifield = DR_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "ZD", 2) == 0) ifield = ZD_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "DM", 2) == 0) ifield = DM_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "RH", 2) == 0) ifield = RH_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "PH", 2) == 0) ifield = PH_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "XZ", 2) == 0) ifield = XZ_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "CD", 2) == 0) ifield = CD_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "MZ", 2) == 0) ifield = MZ_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "MD", 2) == 0) ifield = MD_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "ZE", 2) == 0) ifield = ZE_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "VE", 2) == 0) ifield = VE_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "KD", 2) == 0) ifield = KD_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "TI", 2) == 0) ifield = TI_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "DX", 2) == 0) ifield = DX_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "CH", 2) == 0) ifield = CH_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "AH", 2) == 0) ifield = AH_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "CV", 2) == 0) ifield = CV_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "AV", 2) == 0) ifield = AV_INDEX;
else if (strncmp((char *)&uf_dh[3+2*i], "SQ", 2) == 0) ifield = SQ_INDEX;
else { /* etc. DON'T know how to handle this yet. */
field_type = (char *)&uf_dh[3+2*i];
fprintf(stderr, "Unknown field type %c%c\n", (char)field_type[0], (char)field_type[1]);
continue;
}
switch (ifield) {
case DZ_INDEX: f = DZ_F; invf = DZ_INVF; break;
case VR_INDEX: f = VR_F; invf = VR_INVF; break;
case SW_INDEX: f = SW_F; invf = SW_INVF; break;
case CZ_INDEX: f = CZ_F; invf = CZ_INVF; break;
case ZT_INDEX: f = ZT_F; invf = ZT_INVF; break;
case DR_INDEX: f = DR_F; invf = DR_INVF; break;
case ZD_INDEX: f = ZD_F; invf = ZD_INVF; break;
case DM_INDEX: f = DM_F; invf = DM_INVF; break;
case RH_INDEX: f = RH_F; invf = RH_INVF; break;
case PH_INDEX: f = PH_F; invf = PH_INVF; break;
case XZ_INDEX: f = XZ_F; invf = XZ_INVF; break;
case CD_INDEX: f = CD_F; invf = CD_INVF; break;
case MZ_INDEX: f = MZ_F; invf = MZ_INVF; break;
case MD_INDEX: f = MD_F; invf = MD_INVF; break;
case ZE_INDEX: f = ZE_F; invf = ZE_INVF; break;
case VE_INDEX: f = VE_F; invf = VE_INVF; break;
case KD_INDEX: f = KD_F; invf = KD_INVF; break;
case TI_INDEX: f = TI_F; invf = TI_INVF; break;
case DX_INDEX: f = DX_F; invf = DX_INVF; break;
case CH_INDEX: f = CH_F; invf = CH_INVF; break;
case AH_INDEX: f = AH_F; invf = AH_INVF; break;
case CV_INDEX: f = CV_F; invf = CV_INVF; break;
case AV_INDEX: f = AV_F; invf = AV_INVF; break;
case SQ_INDEX: f = SQ_F; invf = SQ_INVF; break;
default: f = DZ_F; invf = DZ_INVF; break;
}
/* Do we place the data into this volume? */
if (radar->v[ifield] == NULL) continue; /* Nope. */
if (isweep >= radar->v[ifield]->h.nsweeps) { /* Exceeded sweep limit.
* Allocate more sweeps.
* Copy all previous sweeps.
*/
if (radar_verbose_flag)
fprintf(stderr,"Exceeded sweep allocation of %d. Adding 20 more.\n", isweep);
new_volume = RSL_new_volume(radar->v[ifield]->h.nsweeps+20);
new_volume = copy_sweeps_into_volume(new_volume, radar->v[ifield]);
radar->v[ifield] = new_volume;
}
if (radar->v[ifield]->sweep[isweep] == NULL) {
if (radar_verbose_flag)
fprintf(stderr,"Allocating new sweep for field %d, isweep %d\n", ifield, isweep);
radar->v[ifield]->sweep[isweep] = RSL_new_sweep(1000);
radar->v[ifield]->sweep[isweep]->h.nrays = 0; /* Increment this for each
* ray encountered.
*/
radar->v[ifield]->h.f = f;
radar->v[ifield]->h.invf = invf;
radar->v[ifield]->sweep[isweep]->h.f = f;
radar->v[ifield]->sweep[isweep]->h.invf = invf;
radar->v[ifield]->sweep[isweep]->h.sweep_num = uf_ma[9];
radar->v[ifield]->sweep[isweep]->h.elev = uf_ma[35] / 64.0;
}
current_fh_index = uf_dh[4+2*i];
uf_fh = uf + current_fh_index - 1;
sweep = radar->v[ifield]->sweep[isweep];
iray = sweep->h.nrays;
nbins = uf_fh[5];
radar->v[ifield]->sweep[isweep]->ray[iray] = RSL_new_ray(nbins);
ray = radar->v[ifield]->sweep[isweep]->ray[iray];
sweep->h.nrays += 1;
if (ray) {
/*
* ---- Beginning of MANDATORY HEADER BLOCK.
*/
ray->h.ray_num = uf_ma[7];
if (little_endian()) swap2(&uf_ma[10], 8);
memcpy(radar->h.radar_name, &uf_ma[10], 8);
if (little_endian()) swap2(&uf_ma[10], 8/2);
memcpy(radar->h.name, &uf_ma[14], 8);
if (little_endian()) swap2(&uf_ma[14], 8/2);
/* All components of lat/lon are the same sign. If not, then
* what ever wrote the UF was in error. A simple RSL program
* can repair the damage, however, not here.
*/
ray->h.lat = uf_ma[18] + uf_ma[19]/60.0 + uf_ma[20]/64.0/3600;
ray->h.lon = uf_ma[21] + uf_ma[22]/60.0 + uf_ma[23]/64.0/3600;
ray->h.alt = uf_ma[24];
ray->h.year = uf_ma[25];
if (ray->h.year < 1900) {
ray->h.year += 1900;
if (ray->h.year < 1980) ray->h.year += 100; /* Year >= 2000. */
}
ray->h.month = uf_ma[26];
ray->h.day = uf_ma[27];
ray->h.hour = uf_ma[28];
ray->h.minute = uf_ma[29];
ray->h.sec = uf_ma[30];
ray->h.azimuth = uf_ma[32] / 64.0;
/* If Local Use Header is present and contains azimuth, use that
* azimuth for VR and SW. This is for WSR-88D, which runs separate
* scans for DZ and VR/SW at the lower elevations, which means DZ
* VR/SW and have different azimuths in the "same" ray.
*/
len_lu = uf_ma[4] - uf_ma[3];
if (len_lu == 2 && (ifield == VR_INDEX || ifield == SW_INDEX)) {
if (strncmp(uf_lu,"ZA",2) == 0 || strncmp(uf_lu,"AZ",2) == 0)
ray->h.azimuth = uf_lu[1] / 64.0;
}
if (ray->h.azimuth < 0.) ray->h.azimuth += 360.; /* make it 0 to 360. */
ray->h.elev = uf_ma[33] / 64.0;
ray->h.elev_num = sweep->h.sweep_num;
ray->h.fix_angle = sweep->h.elev = uf_ma[35] / 64.0;
ray->h.azim_rate = uf_ma[36] / 64.0;
ray->h.sweep_rate = ray->h.azim_rate * (60.0/360.0);
missing_data = uf_ma[44];
if (pulled_time_from_first_ray == 0) {
radar->h.height = uf_ma[24];
radar->h.latd = uf_ma[18];
radar->h.latm = uf_ma[19];
radar->h.lats = uf_ma[20] / 64.0;
radar->h.lond = uf_ma[21];
radar->h.lonm = uf_ma[22];
radar->h.lons = uf_ma[23] / 64.0;
radar->h.year = ray->h.year;
radar->h.month = ray->h.month;
radar->h.day = ray->h.day;
radar->h.hour = ray->h.hour;
radar->h.minute = ray->h.minute;
radar->h.sec = ray->h.sec;
strcpy(radar->h.radar_type, "uf");
pulled_time_from_first_ray = 1;
}
/*
* ---- End of MANDATORY HEADER BLOCK.
*/
/* ---- Optional header used for MCTEX files. */
/* If this is a MCTEX file, the first 4 words following the
mandatory header contain the string 'MCTEX'. */
memcpy(proj_name, (short *)(uf + uf_ma[2] - 1), 8);
if (little_endian()) swap2(proj_name, 4);
/* ---- Local Use Header (if present) was checked during Mandatory
* Header processing above.
*/
/* ---- Begining of FIELD HEADER. */
uf_fh = uf+current_fh_index - 1;
scale_factor = uf_fh[1];
ray->h.range_bin1 = uf_fh[2] * 1000.0 + uf_fh[3];
ray->h.gate_size = uf_fh[4];
ray->h.nbins = uf_fh[5];
ray->h.pulse_width = uf_fh[6]/(RSL_SPEED_OF_LIGHT/1.0e6);
if (strncmp((char *)proj_name, "MCTEX", 5) == 0) /* MCTEX? */
{
/* The beamwidth values are not correct in Mctex UF files. */
ray->h.beam_width = 1.0;
sweep->h.beam_width = ray->h.beam_width;
sweep->h.horz_half_bw = ray->h.beam_width/2.0;
sweep->h.vert_half_bw = ray->h.beam_width/2.0;
}
else /* Not MCTEX */
{
ray->h.beam_width = uf_fh[7] / 64.0;
sweep->h.beam_width = uf_fh[7] / 64.0;
sweep->h.horz_half_bw = uf_fh[7] / 128.0; /* DFF 4/4/95 */
sweep->h.vert_half_bw = uf_fh[8] / 128.0; /* DFF 4/4/95 */
}
/* fprintf (stderr, "uf_fh[7] = %d, [8] = %d\n", (int)uf_fh[7], (int)uf_fh[8]); */
if((int)uf_fh[7] == -32768) {
ray->h.beam_width = 1;
sweep->h.beam_width = 1;
sweep->h.horz_half_bw = .5;
sweep->h.vert_half_bw = .5;
}
ray->h.frequency = uf_fh[9] / 64.0;
ray->h.wavelength = uf_fh[11] / 64.0 / 100.0; /* cm to m. */
ray->h.pulse_count = uf_fh[12];
if (ifield == DZ_INDEX || ifield == ZT_INDEX) {
radar->v[ifield]->h.calibr_const = uf_fh[16] / 100.0;
/* uf value scaled by 100 */
}
else {
radar->v[ifield]->h.calibr_const = 0.0;
}
if (uf_fh[17] == (short)UF_NO_DATA) x = 0;
else x = uf_fh[17] / 1000000.0; /* PRT in seconds. */
if (x != 0) {
ray->h.prf = 1/x;
ray->h.unam_rng = RSL_SPEED_OF_LIGHT / (2.0 * ray->h.prf * 1000.0);
}
else {
ray->h.prf = 0.0;
ray->h.unam_rng = 0.0;
}
if (VR_INDEX == ifield || VE_INDEX == ifield) {
ray->h.nyq_vel = uf_fh[19] / scale_factor;
}
/* ---- End of FIELD HEADER. */
ray->h.f = f;
ray->h.invf = invf;
/* ---- Begining of FIELD DATA. */
uf_data = uf+uf_fh[0] - 1;
len_data = ray->h.nbins; /* Known because of RSL_new_ray. */
for (m=0; m<len_data; m++) {
if (uf_data[m] == (short)UF_NO_DATA)
ray->range[m] = invf(BADVAL); /* BADVAL */
else {
if(uf_data[m] == missing_data)
ray->range[m] = invf(NOECHO); /* NOECHO */
else
ray->range[m] = invf((float)uf_data[m]/scale_factor);
}
}
}
}
return UF_MORE;
}