def test_ctoscan(self):
obj = _transform.new()
cartesian = _raveio.open(self.FIXTURE_CARTESIAN_PPI).object
volume = _raveio.open(self.FIXTURE_VOLUME).object
radardef = _radardef.new()
radardef.id = volume.source
radardef.description = "ctop test"
radardef.longitude = volume.longitude
radardef.latitude = volume.latitude
radardef.height = volume.height
elangles = []
nangles = volume.getNumberOfScans()
for i in range(nangles):
scan = volume.getScan(i)
elangles.append(scan.elangle)
radardef.elangles = elangles
scan = volume.getScan(0)
radardef.nrays = scan.nrays
radardef.nbins = scan.nbins
radardef.scale = scan.rscale
radardef.beamwidth = scan.beamwidth
elangle = scan.elangle
result = obj.ctoscan(cartesian, radardef, elangle, "DBZH")
rio = _raveio.new()
rio.object = result
rio.save("ctop_polarscan.h5")
def testDealiasScan(self):
scan = _raveio.open(self.FIXTURE).object.getScan(0)
dscan = _raveio.open(self.DEALIASED).object
self.assertTrue(different(scan, dscan))
status = _dealias.dealias(scan)
self.assertFalse(different(scan, dscan))
self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADH").getAttribute("how/task"))
def testMergeOdimScans2Pvol(self):
rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1A,
self.NEW_H5_TARBALL_DOPVOL1A)
rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1B,
self.NEW_H5_TARBALL_DOPVOL1B)
rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1C,
self.NEW_H5_TARBALL_DOPVOL1C)
FILELIST_H5_TARBALL=[\
self.NEW_H5_TARBALL_DOPVOL1A,\
self.NEW_H5_TARBALL_DOPVOL1B,\
self.NEW_H5_TARBALL_DOPVOL1C,\
]
rio_arr = [_raveio.open(x) for x in FILELIST_H5_TARBALL]
rb52odim.mergeOdimScans2Pvol(rio_arr,
self.NEW_H5_MERGED_PVOL,
interval=5,
taskname='DOPVOL')
new_rio = _raveio.open(self.NEW_H5_MERGED_PVOL)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_PVOL)
new_pvol = new_rio.object
self.assertEqual(new_pvol.getNumberOfScans(), 3)
validateMergedPvol(self, new_pvol, 0, self.RB5_TARBALL_DOPVOL1A)
validateMergedPvol(self, new_pvol, 1, self.RB5_TARBALL_DOPVOL1B)
validateMergedPvol(self, new_pvol, 2, self.RB5_TARBALL_DOPVOL1C)
os.remove(self.NEW_H5_TARBALL_DOPVOL1A)
os.remove(self.NEW_H5_TARBALL_DOPVOL1B)
os.remove(self.NEW_H5_TARBALL_DOPVOL1C)
os.remove(self.NEW_H5_MERGED_PVOL)
def testCombineRB5Tarballs2Pvol(self):
ifiles = [self.RB5_TARBALL_DOPVOL1A,
self.RB5_TARBALL_DOPVOL1B,
self.RB5_TARBALL_DOPVOL1C]
# Should not be necessary to write self.NEW_H5_MERGED_PVOL and then
# read it for validation, but per-scan what/time validation fails if
# rio_new is returned in memory and used instead.
# This could be a bug in RAVE.
rb52odim.combineRB5Tarballs2Pvol(ifiles, self.NEW_H5_MERGED_PVOL,
False, 5, "DOPVOL")
new_rio = _raveio.open(self.NEW_H5_MERGED_PVOL)
ref_rio = _raveio.open(self.REF_H5_MERGED_PVOL)
new_pvol, ref_pvol = new_rio.object, ref_rio.object
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_PVOL)
self.assertEquals(new_pvol.getNumberOfScans(),
ref_pvol.getNumberOfScans())
validateTopLevel(self, new_pvol, ref_pvol)
for i in range(new_pvol.getNumberOfScans()):
new_scan = new_pvol.getScan(i)
ref_scan = ref_pvol.getScan(i)
validateScan(self, new_scan, ref_scan)
os.remove(self.NEW_H5_MERGED_PVOL)
def testCombineRB5Files(self):
rb52odim.combineRB5(self.FILELIST_RB5, out_fullfile=self.NEW_H5_FILELIST)
new_rio = _raveio.open(self.NEW_H5_FILELIST)
ref_rio = _raveio.open(self.REF_H5_FILELIST)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN)
new_scan, ref_scan = new_rio.object, ref_rio.object
validateTopLevel(self, new_scan, ref_scan)
validateScan(self, new_scan, ref_scan)
os.remove(self.NEW_H5_FILELIST)
def testCombineRB5FromTarball(self):
rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1B, self.NEW_H5_TARBALL_DOPVOL1B)
new_rio = _raveio.open(self.NEW_H5_TARBALL_DOPVOL1B)
ref_rio = _raveio.open(self.REF_H5_TARBALL_DOPVOL1B)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN)
new_scan, ref_scan = new_rio.object, ref_rio.object
validateTopLevel(self, new_scan, ref_scan)
validateScan(self, new_scan, ref_scan)
os.remove(self.NEW_H5_TARBALL_DOPVOL1B)
def testSingleRB5Azi(self):
rb52odim.singleRB5(self.GOOD_RB5_AZI,out_fullfile=self.NEW_H5_AZI)
new_rio = _raveio.open(self.NEW_H5_AZI)
ref_rio = _raveio.open(self.REF_H5_AZI)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN)
new_scan, ref_scan = new_rio.object, ref_rio.object
validateTopLevel(self, new_scan, ref_scan)
validateScan(self, new_scan, ref_scan)
os.remove(self.NEW_H5_AZI)
def test_drDeriveParameter(self):
zdr_offset = 0.0
rio = _raveio.open(self.FIXTURE)
scan = rio.object
_dr_qc.drDeriveParameter(scan, zdr_offset)
#rio.save(self.DR_DERIVE_PARAMETER_FIXTURE)
refio = _raveio.open(self.DR_DERIVE_PARAMETER_FIXTURE)
ref_scan = refio.object
status = different(scan, ref_scan, "DR")
self.assertFalse(status)
def test_merge(self):
scan_dbzh = _raveio.open(self.FIXTURE_1).object
scan_vrad = _raveio.open(self.FIXTURE_1).object
p = scan_vrad.removeParameter("DBZH")
p.quantity="VRAD"
scan_vrad.addParameter(p)
classUnderTest = polar_merger.polar_merger()
result = classUnderTest.merge([scan_dbzh,scan_vrad])
self.assertTrue("VRAD" in result.getParameterNames())
self.assertTrue("DBZH" in result.getParameterNames())
def test_create_dealiased_parameter(self):
pvol = _raveio.open(self.FIXTURE).object
dscan = _raveio.open(self.DEALIASED).object
self.assertTrue(different(pvol.getScan(0), dscan))
param = _dealias.create_dealiased_parameter(pvol.getScan(0), "VRADH", "VRADDH")
self.assertFalse(different_param(dscan.getParameter("VRADH"), param))
dscan.getParameter("VRADH").addAttribute("how/something", "jupp")
# verify that created param is copy and not reference
self.assertFalse(param.hasAttribute("how/something"))
self.assertTrue(param.hasAttribute("how/dealiased"))
self.assertTrue(param.quantity == "VRADDH")
def testDealiasPvol(self):
pvol = _raveio.open(self.FIXTURE).object
dscan = _raveio.open(self.DEALIASED).object
self.assertTrue(different(pvol.getScan(0), dscan))
status = _dealias.dealias(pvol)
for i in range(pvol.getNumberOfScans()):
scan = pvol.getScan(i)
if scan.hasParameter("VRADH") and scan.elangle < 2.0*math.pi/180.0: # Currently, max elev angle is 2.0
self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADH").getAttribute("how/task"))
self.assertFalse(different(pvol.getScan(0), dscan))
def testNoTH(self):
convol = _raveio.open(self.FIXCONVOL).object
dopvol = _raveio.open(self.REF_DOPVOL).object
for i in range(convol.getNumberOfScans()):
scan = convol.getScan(i)
scan.removeParameter('TH')
try:
ec_dopvolqc.dopvolFilter(convol, dopvol)
self.fail()
except:
self.assertTrue(True)
def test_generateNcar_pid(self):
rio = _raveio.open(self.FIXTURE)
scan = rio.object
profile = ncarb.readProfile(self.PROFILE, scale_height=1000)
ncarb.THRESHOLDS_FILE['nexrad'] = self.THRESHOLDS
ncarb.pidScan(scan, profile, median_filter_len=7,
pid_thresholds='nexrad', keepExtras=True)
rio.object = scan
ref = _raveio.open(self.REF_FIXTURE).object
self.assertFalse(different(scan, ref))
self.assertFalse(different(scan, ref, "CLASS2"))
def testMergeDopvol(self):
dopvol1a = _raveio.open(self.FIXDOPVOL1A).object
dopvol1b = _raveio.open(self.FIXDOPVOL1B).object
dopvol1c = _raveio.open(self.FIXDOPVOL1C).object
dopvol2 = _raveio.open(self.FIXDOPVOL2).object
dvol = ec_dopvolqc.mergeDopvol(dopvol1a, dopvol1b, dopvol1c, dopvol2)
dopvol = _raveio.open(self.REF_DOPVOL).object
this = dvol.getScan(0)
ref = dopvol.getScan(0)
status = different(this, ref, "VRADH")
self.assertFalse(status)
def testDopvolFilter(self):
convol = _raveio.open(self.FIXCONVOL).object
dopvol = _raveio.open(self.REF_DOPVOL).object
refvol = _raveio.open(self.REF_OUT).object
ec_dopvolqc.dopvolFilter(convol, dopvol)
cdat = convol.getScan(23)
cref = refvol.getScan(23)
status = different(cdat, cref)
self.assertFalse(status)
def test_drQC(self):
rio = _raveio.open(self.FIXTURE)
scan = rio.object
ec_drqc.drQC(scan, kernely=3, kernelx=3)
refio = _raveio.open(self.DR_SPECKLE_FILTER_FIXTURE)
ref_scan = refio.object
status = different(scan, ref_scan, "DBZH")
self.assertFalse(status)
param = scan.getParameter("DR")
self.assertEquals(ec_drqc.TASK, param.getAttribute("how/task"))
self.assertEquals(
"param_name=DBZH zdr_offset=0.00 kernely=3 kernelx=3 param_thresh=35.0 dr_thresh=-12.0",
param.getAttribute("how/task_args"))
def test_drSpeckleFilter(self):
zdr_offset = 0.0
param_name, param_thresh, dr_thresh = "DBZH", 35.0, -12.0
kernely = kernelx = 3
rio = _raveio.open(self.DR_DERIVE_PARAMETER_FIXTURE)
scan = rio.object
_dr_qc.drSpeckleFilter(scan, param_name, kernely, kernelx,
param_thresh, dr_thresh)
#rio.save(self.DR_SPECKLE_FILTER_FIXTURE)
refio = _raveio.open(self.DR_SPECKLE_FILTER_FIXTURE)
ref_scan = refio.object
status = different(scan, ref_scan, param_name)
self.assertFalse(status)
def testSingleRB5Vol(self):
rb52odim.singleRB5(self.GOOD_RB5_VOL,out_fullfile=self.NEW_H5_VOL)
new_rio = _raveio.open(self.NEW_H5_VOL)
ref_rio = _raveio.open(self.REF_H5_VOL)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_PVOL)
new_pvol, ref_pvol = new_rio.object, ref_rio.object
self.assertEquals(new_pvol.getNumberOfScans(), ref_pvol.getNumberOfScans())
validateTopLevel(self, new_pvol, ref_pvol)
for i in range(new_pvol.getNumberOfScans()):
new_scan = new_pvol.getScan(i)
ref_scan = ref_pvol.getScan(i)
validateScan(self, new_scan, ref_scan)
os.remove(self.NEW_H5_VOL)
def testDealiasPvol_byEMAX_higher(self):
pvol = _raveio.open(self.FIXTURE).object
dscan = _raveio.open(self.DEALIASED).object
self.assertTrue(different(pvol.getScan(0), dscan))
status = _dealias.dealias(pvol, "VRADH", 30.0)
for i in range(pvol.getNumberOfScans()):
scan = pvol.getScan(i)
if scan.hasParameter("VRADH"):
if scan.elangle <= 30.0*math.pi/180.0:
self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADH").getAttribute("how/task"))
else:
self.assertFalse(scan.getParameter("VRADH").hasAttribute("how/task"))
self.assertFalse(different(pvol.getScan(0), dscan))
def testDealiasScan_VRADV(self):
# Really not relevant but we don't force what parameter to use
scan = _raveio.open(self.FIXTURE).object.getScan(0)
dscan = _raveio.open(self.DEALIASED).object
scan.addParameter(copyParam(scan.getParameter("VRADH"), "VRADV"))
dscan.addParameter(copyParam(dscan.getParameter("VRADH"), "VRADV"))
self.assertTrue(different(scan, dscan))
self.assertTrue(different(scan, dscan, "VRADV"))
status = _dealias.dealias(scan, "VRADV")
self.assertTrue(different(scan, dscan, "VRADH"))
self.assertFalse(different(scan, dscan, "VRADV"))
self.assertFalse(scan.getParameter("VRADH").hasAttribute("how/task"))
self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADV").getAttribute("how/task"))
def test_merge_different_sizes(self):
scan_dbzh = _raveio.open(self.FIXTURE_1).object
scan_vrad = _raveio.open(self.FIXTURE_1).object
p = scan_vrad.removeParameter("DBZH")
p.quantity="VRAD"
p.setData(numpy.zeros((10,10), numpy.uint8))
scan_vrad.addParameter(p)
classUnderTest = polar_merger.polar_merger()
try:
result = classUnderTest.merge([scan_dbzh,scan_vrad])
self.fail("Expected an exception")
except AttributeError:
pass
def concatenate_topo():
ios1 = _raveio.open("./W020N90.h5")
src1 = ios1.object
data1 = src1.getParameter("TOPO").getData()
ios2 = _raveio.open("./E020N90.h5")
src2 = ios2.object
data2 = src2.getParameter("TOPO").getData()
#data2 = numpy.zeros((6000,4800), numpy.int16)
a1 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], numpy.int16)
data = concatenate((a1, a1), 1)
print(concatenate((a1, a1), 1))
print(data)
a = _area.new()
a.id = "BALTRAD"
a.projection = src1.projection
a.extent = (src1.areaextent[0], src1.areaextent[1], src2.areaextent[2],
src2.areaextent[3])
a.xsize = src1.xsize + src2.xsize
a.ysize = src1.ysize
a.xscale = (a.extent[2] - a.extent[0]) / (a.xsize - 1)
a.yscale = (a.extent[3] - a.extent[1]) / (a.ysize - 1)
print(a.id)
print(a.projection.definition)
print(a.extent)
print(a.xsize, a.ysize)
print(a.xscale, a.yscale)
src = _cartesian.new()
src.init(a, _rave.RaveDataType_SHORT)
src.time = src1.time
src.date = src1.date
src.objectType = src1.objectType
src.product = src1.product
src.source = src1.source
param1 = src1.getParameter("TOPO")
param = _cartesianparam.new()
param.quantity = param1.quantity
param.gain = param1.gain
param.offset = param1.offset
param.nodata = param1.nodata
param.setData(data)
ios = _raveio.new()
ios.object = src
ios.filename = "./BALTRAD_topo.h5"
ios.save()
def __init__(self, h5file, quantity="DBZH", **kw):
self._gmappalette = None
self._gain = None
self._offset = None
self._quant = None
self._qinds = {}
rio = _raveio.open(h5file)
if rio.objectType == _rave.Rave_ObjectType_COMP:
prod = rio.object.getImage(
0) # assume only one "composite" in this file
elif rio.objectType == _rave.Rave_ObjectType_IMAGE:
prod = rio.object
self._quant = prod.getParameter(quantity)
for i in range(self._quant.getNumberOfQualityFields()):
qi = self._quant.getQualityField(i)
task = qi.getAttribute("how/task")
self._qinds[task] = qi
if not "gain" in kw:
self._gain = self._quant.gain
if self._gain == 0.0:
raise ValueError('gain == 0.0')
else:
self._gain = kw["gain"]
if not "offset" in kw:
self._offset = self._quant.offset
else:
self._offset = kw["offset"]
self._gmappalette = GmapColorMap.PALETTES[SETTINGS[quantity].palette]
def testReadParameters(self):
scan = rb52odim.readParameterFiles([self.CASRA_AZI_dBZ])[0]
ref = _raveio.open(self.CASRA_H5_SCAN).object
for pname in ref.getParameterNames():
if pname != 'DBZH':
ref.removeParameter(pname)
validateScan(self, scan, ref)
def testCombineRB5FilesReturnRIO(self):
new_rio = rb52odim.combineRB5(self.FILELIST_RB5, return_rio=True)
ref_rio = _raveio.open(self.REF_H5_FILELIST)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN)
new_scan, ref_scan = new_rio.object, ref_rio.object
validateTopLevel(self, new_scan, ref_scan)
validateScan(self, new_scan, ref_scan)
def testChainCompare_8bit_and_32bit_Restore(self):
a = _raveio.open(self.PVOL_RIX_TESTFILE).object.getScan(0)
b = _ropogenerator.new(_fmiimage.fromRave(a, "DBZH"))
result8bit = b.speckNormOld(-20, 24, 8).emitter2(-30, 3, 3).softcut(
5, 170, 180).ship(20, 8).speck(
-30,
12).restore(108).toPolarScan().getParameter("DBZH").getData()
# Adjust the 8 bit data to be 16 bit instead
p = a.getParameter("DBZH")
d = p.getData().astype(numpy.int32)
p.setData(d)
p.undetect = 0.0
p.nodata = 255.0
a.addParameter(p)
b = _ropogenerator.new(_fmiimage.fromRave(a, "DBZH"))
result32bit = b.speckNormOld(-20, 24, 8).emitter2(-30, 3, 3).softcut(
5, 170, 180).ship(20, 8).speck(
-30,
12).restore(108).toPolarScan().getParameter("DBZH").getData()
self.assertEqual(
numpy.int32,
result32bit.dtype) # Result should be same type as when created
result32bit = result32bit.astype(numpy.uint8)
self.assertTrue(
numpy.array_equal(result8bit.astype(numpy.int32),
result32bit.astype(numpy.int32)))
def testClassify_reclassification(self):
a = _raveio.open(self.PVOL_RIX_TESTFILE).object.getScan(0)
b = _ropogenerator.new(_fmiimage.fromRave(a, "DBZH"))
b.speck(-20, 5).emitter(3, 6).classify()
self.assertEqual("fi.fmi.ropo.detector.classification",
b.classification.getAttribute("how/task"))
self.assertTrue(
b.classification.getAttribute("how/task_args").find("SPECK:") >= 0)
self.assertTrue(
b.classification.getAttribute("how/task_args").find("EMITTER:") >=
0)
self.assertEqual("fi.fmi.ropo.detector.classification_marker",
b.markers.getAttribute("how/task"))
self.assertTrue(
b.markers.getAttribute("how/task_args").find("SPECK:") >= 0)
self.assertTrue(
b.markers.getAttribute("how/task_args").find("EMITTER:") >= 0)
b.clutter(-5, 5).classify()
self.assertEqual("fi.fmi.ropo.detector.classification",
b.classification.getAttribute("how/task"))
self.assertTrue(
b.classification.getAttribute("how/task_args").find("SPECK:") >= 0)
self.assertTrue(
b.classification.getAttribute("how/task_args").find("EMITTER:") >=
0)
self.assertTrue(
b.classification.getAttribute("how/task_args").find("CLUTTER:") >=
0)
def process(self, obj, reprocess_quality_flag=True, arguments=None):
#_rave.setDebugLevel(_rave.Debug_RAVE_DEBUG)
if not _polarvolume.isPolarVolume(obj):
raise Exception, "Input object is not a polar volume. Bailing ..."
# Using a dictionary lets us match tasks with payloads
dpvol = {"dopvol1a" : None,
"dopvol1b" : None,
"dopvol1c" : None,
"dopvol2" : None}
for i in range(len(arguments)):
dobj = _raveio.open(arguments[i]).object
task = "".join(dobj.getAttribute('how/task').lower().split("_"))
dpvol[task] = dobj
dopvol = ec_dopvolqc.mergeDopvol(dopvol1a = dpvol["dopvol1a"],
dopvol1b = dpvol["dopvol1b"],
dopvol1c = dpvol["dopvol1c"],
dopvol2 = dpvol["dopvol2"])
# Assume we always want spatial=1 filtering
ec_dopvolqc.dopvolFilter(obj, dopvol)
return obj
def testReadRB5Azi(self):
rio = _rb52odim.readRB5(self.GOOD_RB5_AZI)
self.assertTrue(rio.objectType is _rave.Rave_ObjectType_SCAN)
scan = rio.object
ref_scan = _raveio.open(self.REF_H5_AZI).object
validateTopLevel(self, scan, ref_scan)
validateScan(self, scan, ref_scan)
def testCombineRB5FromTarballReturnRIO(self):
new_rio = rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1B, None, return_rio=True)
ref_rio = _raveio.open(self.REF_H5_TARBALL_DOPVOL1B)
self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN)
new_scan, ref_scan = new_rio.object, ref_rio.object
validateTopLevel(self, new_scan, ref_scan)
validateScan(self, new_scan, ref_scan)
def test_raveio2radar_pvol():
rio = _raveio.open(PVOL_FILENAME)
radar = bridge.raveio2radar(rio)
# latitude, longitude, altitude
assert round(radar.latitude['data'], 2) == 58.11
assert round(radar.longitude['data'], 2) == 15.94
assert round(radar.altitude['data'], 2) == 222.0
# metadata
assert radar.metadata['source'] == (
'WMO:02570,PLC:Norrk\xc3\xb6ping,RAD:SE53,NOD:senkp')
assert radar.metadata['original_container'] == 'odim_h5'
# sweep_start_ray_index, sweep_end_ray_index
# radar consists of 6 sweeps each containing 361 rays
assert_array_equal(radar.sweep_start_ray_index['data'],
np.arange(6) * 361)
assert_array_equal(radar.sweep_end_ray_index['data'],
np.arange(6) * 361 + 360)
# sweep_number, sweep_mode, scan_type
assert_array_equal(radar.sweep_number['data'], np.arange(6))
assert_array_equal(radar.sweep_mode['data'],
['azimuth_surveillance'] * 6)
assert radar.scan_type == 'ppi'
# fixed_angle
assert_allclose(radar.fixed_angle['data'],
[0.0, 1.1, 23.5, 28.2, 33.7, 40.0])
# elevation, check each sweep
assert np.allclose(radar.elevation['data'][:361], 0.0)
assert np.allclose(radar.elevation['data'][361:722], 1.1)
assert np.allclose(radar.elevation['data'][722:1083], 23.5)
assert np.allclose(radar.elevation['data'][1083:1444], 28.2)
assert np.allclose(radar.elevation['data'][1444:1805], 33.7)
assert np.allclose(radar.elevation['data'][1805:], 40.0)
# range
assert_allclose(radar.range['data'], np.arange(800) * 250)
# azimuth
assert round(radar.azimuth['data'][10], 2) == 10.04
assert round(radar.azimuth['data'][361 + 10], 2) == 10.03
assert round(radar.azimuth['data'][722 + 10], 2) == 10.01
assert round(radar.azimuth['data'][1083 + 10], 2) == 10.03
assert round(radar.azimuth['data'][1444 + 10], 2) == 10.04
assert round(radar.azimuth['data'][1805 + 10], 2) == 10.02
# time
assert radar.time['units'] == 'seconds since 2012-02-26T10:27:51Z'
assert radar.time['data'][0] == 0
assert radar.time['data'][-1] == 236
# additional radar attributes
assert radar.nsweeps == 6
assert radar.ngates == 800
assert radar.nrays == 2166
def test_raveio2radar_scan():
rio = _raveio.open(SCAN_FILENAME)
radar = bridge.raveio2radar(rio)
