qrf = (zg / 20.0) + np.sqrt(yg ** 2 + xg ** 2) * \
np.tan(1.0 * 1.5 * np.pi / 180.0) + 500.0 + \
zg * 1000.0 * theta ** 2 / (45.0 ** 2) / 17000.
return qrf
if __name__ == "__main__":
process_version = "1.0E"
vapname = "mmcg"
site = "sgp"
facility = "I7"
level = "c0"
ncfile = sys.argv[1]
odir = sys.argv[2]
cf_alt = 320.0 / 1000.0
cf_lat = dms_to_d([36.0, 36.0, 18.35])
cf_lon = -1.0*dms_to_d([97.0, 29.0, 10.69])
#mync=netCDF4.Dataset(ncfile)
#myradar=radar.Radar(mync)
myradar = pyart.io.read_netcdf(ncfile)
print myradar.time['data'][0]
cp = corner_to_point([myradar.location['latitude']['data'],
myradar.location['longitude']['data']],
[cf_lat, cf_lon])
#mync.close()
mygrids = grid.pyGrid(
(myradar,), nxyz=(241, 241, 35),
xyzr=((-120000 - cp[0], 120000 - cp[0]),
(-120000 - cp[1], 120000 - cp[1]),
(0, 17000)),
params=['reflectivity_horizontal'],
qrf = (zg / 20.0) + np.sqrt(yg ** 2 + xg ** 2) * \
np.tan(1.0 * 1.5 * np.pi / 180.0) + 500.0 + \
zg * 1000.0 * theta ** 2 / (45.0 ** 2) / 17000.
return qrf
if __name__ == "__main__":
process_version = "1.0E"
vapname = "mmcg"
site = "sgp"
facility = "I7"
level = "c0"
ncfile = sys.argv[1]
odir = sys.argv[2]
cf_alt = 320.0 / 1000.0
cf_lat = dms_to_d([36.0, 36.0, 18.35])
cf_lon = -1.0 * dms_to_d([97.0, 29.0, 10.69])
#mync=netCDF4.Dataset(ncfile)
#myradar=radar.Radar(mync)
myradar = pyart.io.read_netcdf(ncfile)
print myradar.time['data'][0]
cp = corner_to_point([
myradar.location['latitude']['data'],
myradar.location['longitude']['data']
], [cf_lat, cf_lon])
#mync.close()
mygrids = grid.pyGrid((myradar, ),
nxyz=(241, 241, 35),
xyzr=((-120000 - cp[0], 120000 - cp[0]),
(-120000 - cp[1], 120000 - cp[1]), (0, 17000)),
params=['reflectivity_horizontal'],
def read_rsl(filename, add_meta=None):
"""
Read a file supported by RSL
Parameters
----------
filename : str or RSL_radar
Name of file whose format is supported by RSL.
add_meta : dict or None
Dictionary containing additional metadata to add to the created
Radar object. This will overwrite metadata extracted from the file.
None is add no additional metadata.
Returns
-------
radar : Radar
Radar object.
"""
rslfile = _rsl_interface.RslFile(filename)
available_vols = rslfile.available_moments()
first_volume = rslfile.get_volume(available_vols[0])
first_sweep = first_volume.get_sweep(0)
first_ray = first_sweep.get_ray(0)
# TODO
# An issue that needs to be resolved is that this code likes all
# sweeps to have the same number of rays.. so for now we take
# min(nrays) across sweeps and drop rays out side of this...
# this is an "easy" issue to resolve caused by the fact I have been
# treating things as cubes and then flattening them
# what needs to be done is to make the field['data'] be masked arrays
# and mask out location where the ray is Null
# determine the shape parameters of the fields
nsweeps = first_volume.nsweeps
nrays = min(first_volume.get_nray_list())
ngates = first_ray.nbins
# scan_type, naz, and nele
if first_sweep.azimuth == -999.0:
scan_type = 'ppi'
naz = nrays
nele = nsweeps
else:
scan_type = 'rhi'
naz = nsweeps
nele = nrays
# range
_range = get_metadata('range')
range_bin1 = first_ray.range_bin1
gate_size = first_ray.gate_size
_range['data'] = range_bin1 + gate_size * np.arange(ngates)
_range['spacing_is_constant'] = 'true'
_range['meters_to_center_of_first_gate'] = range_bin1
_range['meters_between_gates'] = gate_size
# azimuth and elevation
_azimuth, _elevation = first_volume.get_azimuth_and_elev_array()
azimuth = get_metadata('azimuth')
azimuth['data'] = _azimuth.flatten()
elevation = get_metadata('elevation')
elevation['data'] = _elevation.flatten()
# time
last_sweep = first_volume.get_sweep(nsweeps - 1)
last_ray = last_sweep.get_ray(nrays - 1)
t_start = first_ray.get_datetime()
t_end = last_ray.get_datetime()
t_span = (t_end - t_start).seconds
tu = make_tu_str(t_start)
cal = "gregorian"
time = get_metadata('time')
time['data'] = np.linspace(0, t_span, nrays * nsweeps)
time['units'] = tu
time['calendar'] = cal
# sweep parameters
sweep_number = get_metadata('sweep_number')
sweep_mode = get_metadata('sweep_mode')
fixed_angle = get_metadata('fixed_angle')
sweep_start_ray_index = get_metadata('sweep_start_ray_index')
sweep_end_ray_index = get_metadata('sweep_end_ray_index')
len_time = len(time['data'])
if scan_type == 'ppi':
nsweeps = nele
sweep_number['data'] = range(nsweeps)
sweep_mode['data'] = nsweeps * ['azimuth_surveillance ']
fixed_angle['data'] = first_volume.get_sweep_elevs()
sweep_start_ray_index['data'] = np.arange(0, len_time, naz)
sweep_end_ray_index['data'] = np.arange(naz - 1, len_time, naz)
elif scan_type == 'rhi':
nsweeps = naz
sweep_number['data'] = range(nsweeps)
sweep_mode['data'] = nsweeps * ['rhi ']
fixed_angle['data'] = first_volume.get_sweep_azimuths()
sweep_start_ray_index['data'] = np.arange(0, len_time, nele)
sweep_end_ray_index['data'] = np.arange(nele - 1, len_time, nele)
sweep_info = {
'sweep_number': sweep_number,
'sweep_mode': sweep_mode,
'fixed_angle': fixed_angle,
'sweep_start_ray_index': sweep_start_ray_index,
'sweep_end_ray_index': sweep_end_ray_index}
sweep_mode = np.array([scan_type] * nsweeps)
sweep_number = np.linspace(0, nsweeps - 1, nsweeps)
# metadata
metadata = {'original_container': 'rsl'}
rsl_dict = rslfile.get_radar_header()
need_from_rsl_header = {
'name': 'instrument_name', 'project': 'project', 'state': 'state',
'country': 'country'} # rsl_name : radar_metadata_name
for rsl_key, metadata_key in need_from_rsl_header.iteritems():
metadata[metadata_key] = rsl_dict[rsl_key]
if add_meta is not None:
metadata.update(add_meta)
# location
lat = get_metadata('latitude')
lon = get_metadata('longitude')
elv = get_metadata('altitude')
latd = rsl_dict['latd']
latm = rsl_dict['latm']
lats = rsl_dict['lats']
lat['data'] = dms_to_d((latd, latm, lats))
lond = rsl_dict['lond']
lonm = rsl_dict['lonm']
lons = rsl_dict['lons']
lon['data'] = dms_to_d((lond, lonm, lons))
elv['data'] = rsl_dict['height']
location = {'latitude': lat, 'longitude': lon, 'altitude': elv}
# set instrument parameters attribute
inst_params = {}
inst_params['prt_mode'] = get_metadata('prt_mode')
inst_params['nyquist_velocity'] = get_metadata('nyquist_velocity')
inst_params['prt'] = get_metadata('prt')
inst_params['unambiguous_range'] = get_metadata('unambiguous_range')
pm_data, nv_data, pr_data, ur_data = first_volume.get_instr_params()
inst_params['prt_mode']['data'] = pm_data
inst_params['nyquist_velocity']['data'] = nv_data.flatten()
inst_params['prt']['data'] = pr_data.flatten()
inst_params['unambiguous_range']['data'] = ur_data.flatten()
# fields
# transfer only those which are available and have a standard name
fields = {}
available_vols = rslfile.available_moments()
good_vols = VOLUMENUM2STANDARDNAME.keys()
volumes_to_extract = [i for i in available_vols if i in good_vols]
for volume_num in volumes_to_extract:
# extract the field, mask and reshape
data = rslfile.get_volume_array(volume_num)
data[np.where(np.isnan(data))] = -9999.0
data[np.where(data == 131072)] = -9999.0
data = np.ma.masked_equal(data, -9999.0)
data.shape = (data.shape[0] * data.shape[1], data.shape[2])
# create the field dictionary
standard_field_name = VOLUMENUM2STANDARDNAME[volume_num]
fielddict = get_metadata(standard_field_name)
fielddict['data'] = data
fielddict['_FillValue'] = -9999.0
fields[standard_field_name] = fielddict
return Radar(nsweeps, nrays, ngates, scan_type, naz, nele, _range,
azimuth, elevation, tu, cal, time, fields, sweep_info,
sweep_mode, sweep_number, location, inst_params, metadata)