def test_getMaxDistance(self):
s1 = _polarscan.new()
s1.longitude = 60.0 * math.pi / 180.0
s1.latitude = 12.0 * math.pi / 180.0
s1.height = 0.0
s1.rscale = 1000.0
s1.elangle = (math.pi / 180.0) * 0.5
param = _polarscanparam.new()
param.quantity = "DBZH"
data = numpy.zeros((10, 10), numpy.int8)
param.setData(data)
s1.addParameter(param)
s2 = _polarscan.new()
s2.longitude = 60.0 * math.pi / 180.0
s2.latitude = 12.0 * math.pi / 180.0
s2.height = 0.0
s2.rscale = 1000.0
s2.elangle = (math.pi / 180.0) * 1.5
param = _polarscanparam.new()
param.quantity = "DBZH"
data = numpy.zeros((10, 10), numpy.int8)
param.setData(data)
s2.addParameter(param)
vol = _polarvolume.new()
vol.addScan(s1)
vol.addScan(s2)
self.assertAlmostEqual(10999.45, vol.getMaxDistance(), 2)
def test_getNumberOfScans(self):
obj = _polarvolume.new()
self.assertEqual(0, obj.getNumberOfScans())
obj.addScan(_polarscan.new())
self.assertEqual(1, obj.getNumberOfScans())
obj.addScan(_polarscan.new())
self.assertEqual(2, obj.getNumberOfScans())
def test_getScanWithMaxDistance(self):
obj = _polarvolume.new()
s1 = _polarscan.new()
s1.rscale = 500.0
s1.elangle = 0.5 * math.pi / 180.0
s1.longitude = 60.0 * math.pi / 180.0
s1.latitude = 14.0 * math.pi / 180.0
s1.height = 100.0
s1.addAttribute("how/value", "s1")
p1 = _polarscanparam.new()
p1.quantity = "DBZH"
p1.setData(numpy.zeros((100, 120), numpy.uint8))
s1.addParameter(p1)
s2 = _polarscan.new()
s2.rscale = 1000.0
s2.elangle = 0.5 * math.pi / 180.0
s2.longitude = 60.0 * math.pi / 180.0
s2.latitude = 14.0 * math.pi / 180.0
s2.height = 100.0
s2.addAttribute("how/value", "s2")
p2 = _polarscanparam.new()
p2.quantity = "DBZH"
p2.setData(numpy.zeros((100, 120), numpy.uint8))
s2.addParameter(p2)
obj.addScan(s1)
obj.addScan(s2)
result = obj.getScanWithMaxDistance()
self.assertEqual("s2", result.getAttribute("how/value"))
def test_getHeightField(self):
polnav = _polarnav.new()
polnav.lat0 = 60.0 * math.pi / 180.0
polnav.lon0 = 12.0 * math.pi / 180.0
polnav.alt0 = 0.0
expected = []
rarr = []
for i in range(10):
rarr.append(polnav.reToDh(100.0 * i, (math.pi / 180.0) * 0.5)[1])
rarr.append(-99999.0)
rarr.append(-99999.0)
expected.append(rarr)
rarr = []
for i in range(12):
rarr.append(polnav.reToDh(100.0 * i, (math.pi / 180.0) * 1.0)[1])
expected.append(rarr)
s1 = _polarscan.new()
s1.longitude = polnav.lon0 # We want same settings as the polar navigator so that we can test result
s1.latitude = polnav.lat0
s1.height = polnav.alt0
s1.rscale = 100.0
s1.elangle = (math.pi / 180.0) * 0.5
p1 = _polarscanparam.new()
p1.quantity = "DBZH"
data = numpy.zeros((5, 10), numpy.int8)
p1.setData(data)
s1.addParameter(p1)
s2 = _polarscan.new()
s2.longitude = polnav.lon0 # We want same settings as the polar navigator so that we can test result
s2.latitude = polnav.lat0
s2.height = polnav.alt0
s2.rscale = 100.0
s2.elangle = (math.pi / 180.0) * 1.0
p2 = _polarscanparam.new()
p2.quantity = "DBZH"
data = numpy.zeros((5, 12), numpy.int8)
p2.setData(data)
s2.addParameter(p2)
obj = _polarvolume.new()
obj.addScan(s1)
obj.addScan(s2)
f = obj.getHeightField()
self.assertEqual(12, f.xsize)
self.assertEqual(2, f.ysize)
for j in range(2):
for i in range(12):
self.assertAlmostEqual(expected[j][i], f.getValue(i, j)[1], 2)
def test_isTransformable_descending(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = 0.1
scan2 = _polarscan.new()
scan2.elangle = 0.01
obj.addScan(scan1)
obj.addScan(scan2)
result = obj.isTransformable()
self.assertEqual(False, result)
def test_is_polar_malfunc_pv3(self):
pv = _polarvolume.new()
ps1 = _polarscan.new()
ps1.addAttribute("how/malfunc", 'False')
ps1.elangle = 1.0
ps2 = _polarscan.new()
ps1.addAttribute("how/malfunc", 'True')
ps2.elangle = 2.0
pv.addScan(ps1)
pv.addScan(ps2)
self.assertEqual(True, rave_util.is_polar_malfunc(pv))
def test_use_azimuthal_nav_information_2(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan2 = _polarscan.new()
obj.addScan(scan1)
obj.addScan(scan2)
scan1.use_azimuthal_nav_information = False
self.assertEqual(True, obj.use_azimuthal_nav_information)
self.assertEqual(False, scan1.use_azimuthal_nav_information)
self.assertEqual(True, scan2.use_azimuthal_nav_information)
def test_getNearest(self):
obj = _polarvolume.new()
obj.longitude = 12.0 * math.pi / 180.0
obj.latitude = 60.0 * math.pi / 180.0
obj.height = 0.0
scan1 = _polarscan.new()
scan1.elangle = 0.1 * math.pi / 180.0
scan1.rstart = 0.0
scan1.rscale = 5000.0
param = _polarscanparam.new()
param.nodata = 10.0
param.undetect = 11.0
param.quantity = "DBZH"
data = numpy.zeros((100, 120), numpy.uint8)
param.setData(data)
scan1.addParameter(param)
scan2 = _polarscan.new()
scan2.elangle = 1.0 * math.pi / 180.0
scan2.rstart = 0.0
scan2.rscale = 5000.0
param = _polarscanparam.new()
param.nodata = 10.0
param.undetect = 11.0
param.quantity = "DBZH"
data = numpy.ones((100, 120), numpy.uint8)
param.setData(data)
scan2.addParameter(param)
obj.addScan(scan1)
obj.addScan(scan2)
# Allow outside ranges
t, v = obj.getNearest(
(12.0 * math.pi / 180.0, 60.45 * math.pi / 180.0), 1000.0, 0)
self.assertEqual(_rave.RaveValueType_DATA, t)
self.assertAlmostEqual(1.0, v, 4)
t, v = obj.getNearest(
(12.0 * math.pi / 180.0, 62.00 * math.pi / 180.0), 1000.0, 0)
self.assertEqual(_rave.RaveValueType_DATA, t)
self.assertAlmostEqual(0.0, v, 4)
# Only allow inside ranges
t, v = obj.getNearest(
(12.0 * math.pi / 180.0, 60.45 * math.pi / 180.0), 1000.0, 1)
self.assertEqual(_rave.RaveValueType_DATA, t)
self.assertAlmostEqual(1.0, v, 4)
t, v = obj.getNearest(
(12.0 * math.pi / 180.0, 62.00 * math.pi / 180.0), 1000.0, 1)
self.assertEqual(_rave.RaveValueType_NODATA, t)
def test_getScan(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan2 = _polarscan.new()
obj.addScan(scan1)
obj.addScan(scan2)
scanresult1 = obj.getScan(0)
scanresult2 = obj.getScan(1)
self.assertTrue(scan1 == scanresult1)
self.assertTrue(scan2 == scanresult2)
def test_isTransformable(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = 0.1
scan2 = _polarscan.new()
scan2.elangle = 0.3
scan3 = _polarscan.new()
scan3.elangle = 0.5
obj.addScan(scan1)
obj.addScan(scan2)
obj.addScan(scan3)
result = obj.isTransformable()
self.assertEqual(True, result)
def test_remove_malfunc_from_volume2(self):
pv = _polarvolume.new()
pv.addAttribute("how/malfunc", 'True')
ps1 = _polarscan.new()
ps1.addAttribute("how/malfunc", 'False')
ps1.elangle = 1.0
ps2 = _polarscan.new()
ps2.elangle = 2.0
ps2.addAttribute("how/malfunc", 'False')
pv.addScan(ps1)
pv.addScan(ps2)
result = rave_util.remove_malfunc_from_volume(pv)
self.assertTrue(result == None)
def test_removeScan(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan2 = _polarscan.new()
scan3 = _polarscan.new()
obj.addScan(scan1)
obj.addScan(scan2)
obj.addScan(scan3)
obj.removeScan(1)
self.assertEqual(2, obj.getNumberOfScans())
self.assertTrue(scan1 == obj.getScan(0))
self.assertTrue(scan3 == obj.getScan(1))
def test_isAscending_false(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = 0.1
scan2 = _polarscan.new()
scan2.elangle = 0.3
scan3 = _polarscan.new()
scan3.elangle = 0.5
obj.addScan(scan1)
obj.addScan(scan3)
obj.addScan(scan2)
result = obj.isAscendingScans()
self.assertEqual(False, result)
def test_setBeamwidth(self):
vol = _polarvolume.new()
vol.beamwidth = 2.0 * math.pi / 180.0
scan1 = _polarscan.new()
scan1.beamwidth = 3.0 * math.pi / 180.0
vol.addScan(scan1)
scan2 = _polarscan.new()
vol.addScan(scan2)
self.assertAlmostEqual(3.0 * math.pi / 180.0, scan1.beamwidth, 4)
self.assertAlmostEqual(2.0 * math.pi / 180.0, scan2.beamwidth, 4)
vol.beamwidth = 4.0 * math.pi / 180.0
self.assertAlmostEqual(4.0 * math.pi / 180.0, scan1.beamwidth, 4)
self.assertAlmostEqual(4.0 * math.pi / 180.0, scan2.beamwidth, 4)
def testPadding(self):
import numpy
scan = _polarscan.new()
dbzh = _polarscanparam.new()
dbzh.quantity = "DBZH"
l = []
for i in range(360):
l.append([i, i, i])
data = numpy.array(l).astype(numpy.uint16)
dbzh.setData(data)
scan.addParameter(dbzh)
dbzh.quantity = "TH"
scan.addParameter(dbzh)
options = ropo_realtime.options()
options.emitter2 = (-10, 3, 3) # default
newscan, gates = ropo_realtime.PadNrays(scan, options)
newdata = newscan.getParameter("DBZH").getData()
# Test data wrapping
self.assertEqual(newdata[:4].tolist(), data[356:, ].tolist())
self.assertEqual(newdata[364:, ].tolist(), data[:4, ].tolist())
classification = _ravefield.new()
classification.setData(newdata) # bogus probability of anomaly array
unwrapped, classification = ropo_realtime.UnpadNrays(
newscan, classification, gates)
# Test data unwrapping
self.assertEqual(
unwrapped.getParameter("DBZH").getData().tolist(), data.tolist())
def test_notDealiased_notVRADh(self):
scan = _polarscan.new()
vrad = _polarscanparam.new()
vrad.quantity = "VRAD"
vrad.addAttribute("how/dealiased", "True")
scan.addParameter(vrad)
self.assertFalse(_dealias.dealiased(scan))
def to_pvol(self, el):
import _ctop
dest = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = el
_ctop.transform(self, dest)
return dest
def test_isTransformable_oneScan(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = 0.1
obj.addScan(scan1)
result = obj.isTransformable()
self.assertEqual(True, result)
def test_clone(self):
vol = _polarvolume.new()
vol.longitude = 1.0
vol.latitude = 2.0
vol.height = 3.0
vol.time = "200000"
vol.date = "20110101"
vol.source = "CMT:123"
vol.beamwidth = 4.0
scan1 = _polarscan.new()
scan1.elangle = 2.0
vol.addScan(scan1)
cpy = vol.clone()
# Modify the source volume before we test the clone to verify that they aren't bound to each other
vol.longitude = 4.0
vol.latitude = 3.0
vol.height = 2.0
vol.time = "210000"
vol.date = "20120101"
vol.source = "CMT:124"
vol.beamwidth = 1.0
vol.getScan(0).elangle = 3.0
self.assertAlmostEqual(1.0, cpy.longitude, 4)
self.assertAlmostEqual(2.0, cpy.latitude, 4)
self.assertAlmostEqual(3.0, cpy.height, 4)
self.assertEqual("200000", cpy.time)
self.assertEqual("20110101", cpy.date)
self.assertAlmostEqual(4.0, cpy.beamwidth, 4)
self.assertEqual(1, cpy.getNumberOfScans())
self.assertAlmostEqual(2.0, cpy.getScan(0).elangle, 4)
def test_addScan_with_elangleInScan(self):
vol = _polarvolume.new()
vol.beamwidth = 2.0 * math.pi / 180.0
scan = _polarscan.new()
scan.beamwidth = 3.0 * math.pi / 180.0
vol.addScan(scan)
self.assertAlmostEqual(3.0 * math.pi / 180.0, scan.beamwidth, 4)
def test_addScan_dateTime(self):
obj = _polarvolume.new()
obj.date = "20100101"
obj.time = "100000"
scan = _polarscan.new()
obj.addScan(scan)
self.assertEqual("20100101", scan.date)
self.assertEqual("100000", scan.time)
def create_simple_scan_with_param(self, elangle, dshape, quantities):
scan = _polarscan.new()
scan.elangle = elangle
for q in quantities:
param = _polarscanparam.new()
param.quantity = q
param.setData(numpy.zeros(dshape, numpy.int8))
scan.addParameter(param)
return scan
def test_remove_malfunc_from_volume__all_malfunc(self):
pv = _polarvolume.new()
pv.addAttribute("how/malfunc", 'False')
ps1 = _polarscan.new()
ps1.addAttribute("how/malfunc", 'True')
ps1.elangle = 1.0
ps2 = _polarscan.new()
ps2.addAttribute("how/malfunc", 'True')
ps2.elangle = 2.0
ps3 = _polarscan.new()
ps3.addAttribute("how/malfunc", 'True')
ps3.elangle = 3.0
pv.addScan(ps1)
pv.addScan(ps2)
pv.addScan(ps3)
result = rave_util.remove_malfunc_from_volume(pv)
self.assertEqual(0, result.getNumberOfScans())
def test_getScanClosestToElevation_outside(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = 0.1 * math.pi / 180.0
obj.addScan(scan1)
scan2 = _polarscan.new()
scan2.elangle = 0.5 * math.pi / 180.0
obj.addScan(scan2)
scan3 = _polarscan.new()
scan3.elangle = 2.0 * math.pi / 180.0
obj.addScan(scan3)
els = [(0.0, 0.1), (0.1, 0.1), (0.2, 0.1), (0.3, 0.1), (0.31, 0.5),
(1.0, 0.5), (2.0, 2.0)]
for el in els:
elevation = el[0] * math.pi / 180.0
result = obj.getScanClosestToElevation(elevation, 0)
self.assertAlmostEqual(el[1], result.elangle * 180.0 / math.pi, 5)
def test_addScan_refcountIncreaseOnScan(self):
obj = _polarvolume.new()
ids = []
for i in range(50):
scan = _polarscan.new()
ids.append(repr(scan))
obj.addScan(scan)
for i in range(obj.getNumberOfScans()):
scan = obj.getScan(i)
if repr(scan) != repr(obj.getScan(i)):
self.fail("Failed to verify scan consistency")
def testDealiased(self):
scan = _polarscan.new()
vrad = _polarscanparam.new()
vrad.quantity = "VRADH"
vrad.addAttribute("how/dealiased", "True")
scan.addParameter(vrad)
self.assertTrue(_dealias.dealiased(scan))
try:
scan.getParameter("VRADH").getAttribute("how/task")
self.fail("Expected AttributeError")
except AttributeError:
pass
def match_radars_to_stations(print_summary=False):
# RADIUS_THRESHOLD = 250000. # only map radars to stations within
RADIUS_THRESHOLD = 247000. # Warning_nIN : nearestIndex None, casra CYYN, dist = 247183.26
D_stn = load_station()
D_radar = load_radar()
obj = _polarscan.new()
for id_stn in D_stn:
D_stn[id_stn]['radars'] = []
for id_radar in D_radar:
D_radar[id_radar]['stations'] = []
for id_radar in D_radar:
d_radar = D_radar[id_radar]
obj.longitude, obj.latitude = d_radar['lon'], d_radar['lat']
for id_stn in D_stn:
d_stn = D_stn[id_stn]
distance = obj.getDistance(d_stn['lonlat'])
if distance <= RADIUS_THRESHOLD:
d_radar['stations'].append(id_stn)
d_stn['radars'].append(id_radar)
fname_out = verifroot + '/metadata/radar_station_metadata_%s.csv' % timestamp
with open(fname_out, 'wb') as f:
for id_radar in sorted(D_radar):
if D_radar[id_radar]['stations']: # skip Guam, no stations
f.write('%s' % id_radar)
for id_stn in D_radar[id_radar]['stations']:
f.write(',%s' % id_stn)
f.write('\n')
os.symlink(fname_out, verifroot + '/radar_station.csv')
if print_summary:
L_num_radar = sorted([[len(D_radar[id_radar]['stations']), id_radar]
for id_radar in D_radar],
reverse=True)
L_num_stn = sorted([[len(D_stn[id_stn]['radars']), id_stn]
for id_stn in D_stn],
reverse=True)
eff_radar_count = sum([x[0] for x in L_num_stn])
eff_stn_count = sum([x[0] for x in L_num_radar])
if eff_radar_count != eff_stn_count:
sys.stderr.write('Error : radar and station indexes disagree\n')
sys.exit(1)
fname_out = 'radar_station_summary_%s.txt' % timestamp
with open(fname_out, 'wb') as f:
f.write('%d radars and %d stations give %d radar-station pairs\n' %
(len(D_radar), len(D_stn), eff_radar_count))
for n, id_radar in L_num_radar:
f.write('%s %d\n' % (id_radar, n))
for n, id_stn in L_num_stn:
f.write('%s %d\n' % (id_stn, n))
print 'see radar-station pair summary :', fname_out
def makeScanFromRB(rb):
scan = _polarscan.new()
scan.date = str(rb['@datetime'][:4] + rb['@datetime'][5:7] +
rb['@datetime'][8:10])
scan.time = str(rb['@datetime'][11:13] + rb['@datetime'][14:16] +
rb['@datetime'][17:19])
scan.beamwidth = float(rb['sensorinfo']['beamwidth']) * dr
scan.elangle = float(rb['scan']['pargroup']['posele']) * dr
scan.rscale = float(rb['scan']['slice']['rangestep']) * 1000.0
return scan
def test_sortByElevations_descending(self):
obj = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = 2.0
scan2 = _polarscan.new()
scan2.elangle = 3.0
scan3 = _polarscan.new()
scan3.elangle = 1.0
obj.addScan(scan1)
obj.addScan(scan2)
obj.addScan(scan3)
obj.sortByElevations(0)
scanresult1 = obj.getScan(0)
scanresult2 = obj.getScan(1)
scanresult3 = obj.getScan(2)
self.assertTrue(scan2 == scanresult1)
self.assertTrue(scan1 == scanresult2)
self.assertTrue(scan3 == scanresult3)
def readLevelII(filename, return_l2=False):
l2 = nexrad_level2.NEXRADLevel2File(filename)
rio = _raveio.new()
# Always assume we're reading volumes, not individual scans.
if l2.nscans > 1:
rio.object = _polarvolume.new()
else:
rio.object = _polarscan.new()
obj = rio.object
source = odim_source.SOURCE['us' + l2.volume_header['icao'][1:].lower()]
obj.source = source.encode(UTF8)
# Site location
lat, lon, alt = l2.location()
obj.longitude = lon * dr
obj.latitude = lat * dr
obj.height = float(alt)
# Date and time conversions
# obj.date, obj.time = makeDateTime(l2.volume_header['date'], l2.volume_header['time'])
obj.date, obj.time = get_times(l2)
getTopLevelHowAttrs(l2, obj)
if rio.objectType == _rave.Rave_ObjectType_SCAN:
populateScan(l2, obj)
elif rio.objectType == _rave.Rave_ObjectType_PVOL:
for i in range(l2.nscans):
scan = _polarscan.new()
populateScan(l2, scan, index=i)
if len(scan.getParameterNames()
) > 0: # Don't add the scan if there are no moments in it
obj.addScan(scan)
if return_l2: return rio, l2
else: return rio
