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 makePvolFromFiles(filenames):
pvol = _polarvolume.new()
for fstr in filenames:
rb, param = readRBScanParameter(fstr)
scan = makeScanFromRB(rb)
scan.addParameter(param)
pvol.addScan(scan)
pvol.sortByElevations(1)
scan = pvol.getScan(0)
pvol.date, pvol.time = scan.date, scan.time
pvol.longitude = float(rb['sensorinfo']['lon']) * dr
pvol.latitude = float(rb['sensorinfo']['lat']) * dr
pvol.height = float(rb['sensorinfo']['alt'])
try:
nod = NAME2SOURCE[rb['sensorinfo']['@name']]
except KeyError:
nod = None
if nod:
source = odim_source.SOURCE[nod]
pvol.source = source.encode(UTF8)
return pvol
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 generateVolume(files, args):
if len(files) <= 0:
raise AttributeError("Volume must consist of at least 1 scan")
firstscan = False
volume = _polarvolume.new()
volume.date = args['date']
volume.time = args['time']
#'longitude', 'latitude', 'height', 'time', 'date', 'source'
for fname in files:
scan = None
if ravebdb != None:
scan = ravebdb.get_rave_object(fname)
else:
scan = _raveio.open(fname).object
if firstscan == False:
firstscan = True
volume.longitude = scan.longitude
volume.latitude = scan.latitude
volume.height = scan.height
volume.beamwidth = scan.beamwidth
volume.addScan(scan)
volume.source = scan.source # Recycle the last input, it won't necessarily be correct ...
odim_source.CheckSource(volume) # ... so check it!
return volume
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_source(self):
obj = _polarvolume.new()
self.assertEqual(None, obj.source)
obj.source = "ABC:10, ABD:1"
self.assertEqual("ABC:10, ABD:1", obj.source)
obj.source = None
self.assertEqual(None, obj.source)
def test_date(self):
obj = _polarvolume.new()
self.assertEqual(None, obj.date)
obj.date = "20050101"
self.assertEqual("20050101", obj.date)
obj.date = None
self.assertEqual(None, obj.date)
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_time(self):
obj = _polarvolume.new()
self.assertEqual(None, obj.time)
obj.time = "200500"
self.assertEqual("200500", obj.time)
obj.time = None
self.assertEqual(None, obj.time)
def compileVolumeFromScans(scans, adjustTime=True):
if len(scans) <= 0:
raise AttributeError("Volume must consist of at least 1 scan")
firstscan=False
volume = _polarvolume.new()
#'longitude', 'latitude', 'height', 'time', 'date', 'source', 'beamwidth', 'beamwH', beamwV'
#rave-py3/modules/pypolarscan.c:1712 beamwidth - DEPRECATED, Use beamwH!
for scan in scans:
if firstscan == False:
firstscan = True
volume.longitude = scan.longitude
volume.latitude = scan.latitude
volume.height = scan.height
volume.beamwidth = scan.beamwidth
if(hasattr(scan,'beamH')): volume.beamwH = scan.beamwH
if(hasattr(scan,'beamV')): volume.beamwV = scan.beamwV
volume.addScan(scan)
volume.source = scan.source # Recycle the last input, it won't necessarily be correct ...
odim_source.CheckSource(volume) # ... so check it!
# Adjust to closest nomimal time
if adjustTime:
if volume.isAscendingScans():
volume.date, volume.time = roundDT(volume.date, volume.time)
else:
lowest = volume.getScanClosestToElevation(-90.0, 0)
volume.date, volume.time = roundDT(lowest.enddate, lowest.endtime)
return volume
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_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 to_pvol(self, el):
import _ctop
dest = _polarvolume.new()
scan1 = _polarscan.new()
scan1.elangle = el
_ctop.transform(self, dest)
return dest
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 test_getDistance(self):
obj = _polarvolume.new()
obj.longitude = 14.0 * math.pi / 180.0
obj.latitude = 60.0 * math.pi / 180.0
result = obj.getDistance(
(14.0 * math.pi / 180.0, 61.0 * math.pi / 180.0))
self.assertAlmostEqual(111040.1, result, 1)
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_time_badValues(self):
obj = _polarvolume.new()
values = ["10101", "1010101", "1010ab", "1010x0", "abcdef", 123456]
for val in values:
try:
obj.time = val
self.fail("Expected ValueError")
except ValueError:
pass
def test_attribute_visibility(self):
attrs = [
'longitude', 'latitude', 'height', 'time', 'date', 'source',
'paramname'
]
obj = _polarvolume.new()
alist = dir(obj)
for a in attrs:
self.assertEqual(True, a in alist)
def test_height_typeError(self):
obj = _polarvolume.new()
self.assertAlmostEqual(0.0, obj.height, 4)
try:
obj.height = 10
self.fail("Excepted TypeError")
except TypeError:
pass
self.assertAlmostEqual(0.0, obj.height, 4)
def test_latitude_typeError(self):
obj = _polarvolume.new()
self.assertAlmostEqual(0.0, obj.latitude, 4)
try:
obj.latitude = 10
self.fail("Excepted TypeError")
except TypeError:
pass
self.assertAlmostEqual(0.0, obj.latitude, 4)
def test_date_badValues(self):
obj = _polarvolume.new()
values = ["200910101", "2001010", "200a1010", 20091010]
for val in values:
try:
obj.time = val
self.fail("Expected ValueError")
except ValueError:
pass
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_paramname(self):
obj = _polarvolume.new()
self.assertEqual("DBZH", obj.paramname)
obj.paramname = "MMM"
self.assertEqual("MMM", obj.paramname)
try:
obj.paramname = None
self.fail("Expected ValueError")
except ValueError:
self.assertEqual("MMM", obj.paramname)
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 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_erroneous_member(self):
obj = _polarvolume.new()
try:
obj.thisshouldnotexist = 10
self.fail("Expected AttributeError")
except AttributeError:
pass
try:
v = obj.thisshouldnotexist
self.fail("Expected AttributeError")
except AttributeError:
pass
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)
