def test_empty_record(self):
"""
Tests if an empty record is given. This will later be changed for
real-time implementation.
Expected behaviour
------------------
Raise DmapDataError if no data is provided to the constructor
"""
with self.assertRaises(pydarnio.dmap_exceptions.DmapDataError):
pydarnio.SDarnWrite([], 'dummy_file.acf')
def test_DmapRead_SDarnWrite_rawacf(self):
"""
Test DmapRead reading an rawacf and SDarnWrite writing
the rawacf file
"""
dmap = pydarnio.DmapRead(rawacf_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_rawacf("test_rawacf.rawacf")
self.assertTrue(os.path.isfile("test_rawacf.rawacf"))
os.remove("test_rawacf.rawacf")
def test_darn_write_constructor(self):
"""
Tests SDarnWrite constructor
Expected behaviour
------------------
Contains file name of the data if given to it.
"""
rawacf_data = copy.deepcopy(rawacf_data_sets.rawacf_data)
darn = pydarnio.SDarnWrite(rawacf_data, "rawacf_test.rawacf")
self.assertEqual(darn.filename, "rawacf_test.rawacf")
def test_SDarnWrite_SDarnRead_iqdat(self):
"""
Test SDarnWrite writing a iqdat file and SDarnRead reading the iqdat
file
"""
iqdat_data = copy.deepcopy(iqdat_data_sets.iqdat_data)
iqdat_write = pydarnio.SDarnWrite(iqdat_data, "test_iqdat.iqdat")
iqdat_write.write_iqdat()
iqdat_read = pydarnio.SDarnRead("test_iqdat.iqdat")
iqdat_read_data = iqdat_read.read_iqdat()
self.dmap_compare(iqdat_read_data, iqdat_data)
os.remove("test_iqdat.iqdat")
def test_SDarnWrite_SDarnRead_fitacf(self):
"""
Test SDarnWrite writing a fitacf file and SDarnRead reading the fitacf
file
"""
fitacf_data = copy.deepcopy(fitacf_data_sets.fitacf_data)
fitacf_write = pydarnio.SDarnWrite(fitacf_data, "test_fitacf.fitacf")
fitacf_write.write_fitacf()
fitacf_read = pydarnio.SDarnRead("test_fitacf.fitacf")
fitacf_read_data = fitacf_read.read_fitacf()
self.dmap_compare(fitacf_read_data, fitacf_data)
os.remove("test_fitacf.fitacf")
def test_SDarnWrite_SDarnRead_rawacf(self):
"""
Test SDarnWrite writing a rawacf file and SDarnRead reading the rawacf
file
"""
rawacf_data = copy.deepcopy(rawacf_data_sets.rawacf_data)
rawacf_write = pydarnio.SDarnWrite(rawacf_data, "test_rawacf.rawacf")
rawacf_write.write_rawacf()
rawacf_read = pydarnio.SDarnRead("test_rawacf.rawacf")
rawacf_read_data = rawacf_read.read_rawacf()
self.dmap_compare(rawacf_read_data, rawacf_data)
os.remove("test_rawacf.rawacf")
def test_SDarnWrite_file_SDarnRead_iqdat(self):
"""
Test SDarnWrite to write a iqdat file then using
SDarnRead to read the file
"""
iqdat_data = copy.deepcopy(iqdat_data_sets.iqdat_data)
iqdat_write = pydarnio.SDarnWrite(iqdat_data, "test_iqdat.iqdat")
iqdat_write.write_iqdat()
iqdat_read = pydarnio.SDarnRead("test_iqdat.iqdat")
iqdat_read_data = iqdat_read.read_iqdat()
self.dmap_compare(iqdat_read_data, iqdat_data)
os.remove("test_iqdat.iqdat")
def test_SDarnRead_SDarnWrite_grid(self):
"""
Test DmapRead reading an grid and SDarnWrite writing
the grid file
"""
dmap = pydarnio.SDarnRead(grid_file)
dmap_data = dmap.read_grid()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_grid("test_grid.grid")
grid_read = pydarnio.SDarnRead("test_grid.grid")
grid_read_data = grid_read.read_grid()
self.dmap_compare(dmap_data, grid_read_data)
os.remove("test_grid.grid")
def test_SDarnWrite_file_SDarnRead_grid(self):
"""
Test SDarnWrite to write a grid file then using
SDarnRead to read the file
"""
grid_data = copy.deepcopy(grid_data_sets.grid_data)
grid_write = pydarnio.SDarnWrite(grid_data, "test_grid.grid")
grid_write.write_grid()
grid_read = pydarnio.SDarnRead("test_grid.grid")
grid_read_data = grid_read.read_grid()
self.dmap_compare(grid_read_data, grid_data)
os.remove("test_grid.grid")
def test_SDarnRead_SDarnWrite_map(self):
"""
Test DmapRead reading an map and SDarnWrite writing
the map file
"""
dmap = pydarnio.SDarnRead(map_file)
dmap_data = dmap.read_map()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_map("test_map.map")
map_read = pydarnio.SDarnRead("test_map.map")
map_read_data = map_read.read_map()
self.dmap_compare(dmap_data, map_read_data)
os.remove("test_map.map")
def test_SDarnWrite_SDarnRead_grid(self):
"""
Test SDarnWrite writing a grid file and SDarnRead reading the grid
file
"""
grid_data = copy.deepcopy(grid_data_sets.grid_data)
grid_write = pydarnio.SDarnWrite(grid_data, "test_grid.grid")
grid_write.write_grid()
grid_read = pydarnio.SDarnRead("test_grid.grid")
grid_read_data = grid_read.read_grid()
self.dmap_compare(grid_read_data, grid_data)
os.remove("test_grid.grid")
def test_DmapRead_SDarnWrite_SDarnRead_grid(self):
"""
Test DmapRead reading a grid file then writing it with SDarnWrite
then reading it again with SDarnRead
"""
dmap = pydarnio.DmapRead(grid_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_grid("test_grid.grid")
darn_read = pydarnio.SDarnRead("test_grid.grid")
grid_data = darn_read.read_grid()
self.dmap_compare(dmap_data, grid_data)
os.remove("test_grid.grid")
def test_DmapRead_SDarnWrite_SDarnRead_map(self):
"""
Test DmapRead reading a map file then writing it with SDarnWrite
then reading it again with SDarnRead
"""
dmap = pydarnio.DmapRead(map_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_map("test_map.map")
darn_read = pydarnio.SDarnRead("test_map.map")
map_data = darn_read.read_map()
self.dmap_compare(dmap_data, map_data)
os.remove("test_map.map")
def test_SDarnRead_SDarnWrite_fitacf(self):
"""
Test DmapRead reading an fitacf and SDarnWrite writing
the fitacf file
"""
dmap = pydarnio.SDarnRead(fitacf_file)
dmap_data = dmap.read_fitacf()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_fitacf("test_fitacf.fitacf")
fitacf_read = pydarnio.SDarnRead("test_fitacf.fitacf")
fitacf_read_data = fitacf_read.read_fitacf()
self.dmap_compare(dmap_data, fitacf_read_data)
os.remove("test_fitacf.fitacf")
def test_SDarnRead_SDarnWrite_iqdat(self):
"""
Test DmapRead reading an fitacf and SDarnWrite writing
the fitacf file
"""
dmap = pydarnio.SDarnRead(iqdat_file)
dmap_data = dmap.read_iqdat()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_iqdat("test_iqdat.iqdat")
iqdat_read = pydarnio.SDarnRead("test_iqdat.iqdat")
iqdat_read_data = iqdat_read.read_iqdat()
self.dmap_compare(dmap_data, iqdat_read_data)
os.remove("test_iqdat.iqdat")
def test_DmapRead_SDarnWrite_SDarnRead_iqdat(self):
"""
Test SDarnRead reads from a stream and SDarnWrite writes
to a iqdat file
"""
dmap = pydarnio.DmapRead(iqdat_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_iqdat("test_iqdat.iqdat")
darn_read = pydarnio.SDarnRead("test_iqdat.iqdat")
iqdat_data = darn_read.read_iqdat()
self.dmap_compare(dmap_data, iqdat_data)
os.remove("test_iqdat.iqdat")
def test_SDarnWrite_file_SDarnRead_map(self):
"""
Test SDarnWrite to write a map file then using
SDarnRead to read the file
"""
map_data = copy.deepcopy(map_data_sets.map_data)
map_write = pydarnio.SDarnWrite(map_data, "test_map.map")
map_write.write_map()
map_read = pydarnio.SDarnRead("test_map.map")
map_read_data = map_read.read_map()
self.dmap_compare(map_read_data, map_data)
os.remove("test_map.map")
def test_DmapRead_SDarnWrite_SDarnRead_fitacf(self):
"""
Test DmapRead reading a fitacf file then writing it with SDarnWrite
then reading it again with SDarnRead
"""
dmap = pydarnio.DmapRead(fitacf_file)
dmap_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_data)
dmap_write.write_fitacf("test_fitacf.fitacf")
darn_read = pydarnio.SDarnRead("test_fitacf.fitacf")
fitacf_data = darn_read.read_fitacf()
self.dmap_compare(dmap_data, fitacf_data)
os.remove("test_fitacf.fitacf")
def test_SDarnWrite_SDarnRead_map(self):
"""
Test SDarnWrite writing a map file and SDarnRead reading the map
file
"""
map_data = copy.deepcopy(map_data_sets.map_data)
map_write = pydarnio.SDarnWrite(map_data, "test_map.map")
map_write.write_map()
map_read = pydarnio.SDarnRead("test_map.map")
map_read_data = map_read.read_map()
self.dmap_compare(map_read_data, map_data)
os.remove("test_map.map")
def test_writing_iqdat(self):
"""
Tests write_iqdat method - writes a iqdat file
Expected behaviour
------------------
iqdat file is produced
"""
iqdat_data = copy.deepcopy(iqdat_data_sets.iqdat_data)
dmap = pydarnio.SDarnWrite(iqdat_data)
dmap.write_iqdat("test_iqdat.iqdat")
self.assertTrue(os.path.isfile("test_iqdat.iqdat"))
os.remove("test_iqdat.iqdat")
def test_writing_map(self):
"""
Tests write_map method - writes a map file
Expected behaviour
------------------
map file is produced
"""
map_data = copy.deepcopy(map_data_sets.map_data)
dmap = pydarnio.SDarnWrite(map_data)
dmap.write_map("test_map.map")
self.assertTrue(os.path.isfile("test_map.map"))
os.remove("test_map.map")
def test_writing_grid(self):
"""
Tests write_grid method - writes a grid file
Expected behaviour
------------------
grid file is produced
"""
grid_data = copy.deepcopy(grid_data_sets.grid_data)
dmap = pydarnio.SDarnWrite(grid_data)
dmap.write_grid("test_grid.grid")
self.assertTrue(os.path.isfile("test_grid.grid"))
os.remove("test_grid.grid")
def test_dict2dmap_SDarnWrite_rawacf(self):
"""
Test dict2dmap to convert a dictionary to dmap then SDarnWrite write
rawacf file
"""
rawacf_dict_data = copy.deepcopy(rawacf_dict_sets.rawacf_dict_data)
dmap_rawacf = pydarnio.dict2dmap(rawacf_dict_data)
darn_read = pydarnio.SDarnWrite(dmap_rawacf)
darn_read.write_rawacf("test_rawacf.rawacf")
dmap_read = pydarnio.DmapRead("test_rawacf.rawacf")
dmap_data = dmap_read.read_records()
dmap_data = dmap_read.get_dmap_records
self.dmap_compare(dmap_data, dmap_rawacf)
os.remove("test_rawacf.rawacf")
def test_writing_fitacf(self):
"""
Tests write_fitacf method - writes a fitacf file
Expected behaviour
------------------
fitacf file is produced
"""
fitacf_data = copy.deepcopy(fitacf_data_sets.fitacf_data)
dmap = pydarnio.SDarnWrite(fitacf_data)
dmap.write_fitacf("test_fitacf.fitacf")
self.assertTrue(os.path.isfile("test_fitacf.fitacf"))
os.remove("test_fitacf.fitacf")
def test_SDarnWrite_incorrect_rawacf_from_dict(self):
"""
Test convert dictionary with incorrect type to dmap and SDarnWrite
write the rawacf file
Behaviour: Raise SuperDARNDataFormatTypeError
"""
rawacf_dict_data = copy.deepcopy(rawacf_dict_sets.rawacf_dict_data)
rawacf_dict_data[0]['stid'] = np.int8(rawacf_dict_data[0]['stid'])
dmap_rawacf = pydarnio.dict2dmap(rawacf_dict_data)
darn_write = pydarnio.SDarnWrite(dmap_rawacf)
with self.assertRaises(pydarnio.superdarn_exceptions.
SuperDARNDataFormatTypeError):
darn_write.write_rawacf("test_rawacf.rawacf")
def test_DmapRead_stream_SDarnWrite_file_map(self):
"""
Test DmapRead to read in a stream then have SDarnWrite the
stream to file
"""
with bz2.open(map_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
dmap_stream_data = dmap.read_records()
dmap_write = pydarnio.SDarnWrite(dmap_stream_data)
dmap_write.write_map("test_map.map")
dmap = pydarnio.SDarnRead("test_map.map")
dmap_data = dmap.read_map()
self.dmap_compare(dmap_stream_data, dmap_data)
os.remove("test_map.map")
def test_SDarnRead_stream_SDarnWrite_file_map(self):
"""
Test SDarnRead reads from a stream and SDarnWrite writes
to a map file
"""
with bz2.open(map_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.SDarnRead(dmap_stream, True)
dmap_stream_data = dmap.read_map()
dmap_write = pydarnio.SDarnWrite(dmap_stream_data)
dmap_write.write_map("test_map.map")
self.assertTrue(os.path.isfile("test_map.map"))
dmap = pydarnio.SDarnRead("test_map.map")
dmap_data = dmap.read_map()
self.dmap_compare(dmap_stream_data, dmap_data)
def test_DmapRead_stream_SDarnWrite_file_fitacf(self):
"""
Test DmapRead to read in a stream then have SDarnWrite the
stream to file
"""
with bz2.open(fitacf_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.DmapRead(dmap_stream, True)
stream_data = dmap.read_records()
dmap_stream_data = dmap.get_dmap_records
dmap_write = pydarnio.SDarnWrite(stream_data)
dmap_write.write_fitacf("test_fitacf.fitacf")
dmap = pydarnio.SDarnRead("test_fitacf.fitacf")
dmap_data = dmap.read_fitacf()
dmap_data = dmap.get_dmap_records
self.dmap_compare(dmap_stream_data, dmap_data)
os.remove("test_fitacf.fitacf")
def test_SDarnRead_stream_SDarnWrite_file_iqdat(self):
"""
Test SDarnRead reads from a stream and SDarnWrite writes
to a iqdat file
"""
with bz2.open(iqdat_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.SDarnRead(dmap_stream, True)
stream_data = dmap.read_iqdat()
dmap_stream_data = dmap.get_dmap_records
dmap_write = pydarnio.SDarnWrite(stream_data)
dmap_write.write_iqdat("test_iqdat.iqdat")
self.assertTrue(os.path.isfile("test_iqdat.iqdat"))
dmap = pydarnio.SDarnRead("test_iqdat.iqdat")
_ = dmap.read_iqdat()
dmap_read_data = dmap.get_dmap_records
self.dmap_compare(dmap_stream_data, dmap_read_data)
def test_SDarnRead_stream_SDarnWrite_file_rawacf(self):
"""
Test SDarnRead reads from a stream and SDarnWrite writes
to a rawacf file
"""
with bz2.open(rawacf_stream) as fp:
dmap_stream = fp.read()
dmap = pydarnio.SDarnRead(dmap_stream, True)
stream_data = dmap.read_rawacf()
dmap_stream_data = dmap.get_dmap_records
dmap_write = pydarnio.SDarnWrite(stream_data)
dmap_write.write_rawacf("test_rawacf.rawacf")
dmap_read = pydarnio.SDarnRead("test_rawacf.rawacf")
_ = dmap_read.read_records()
dmap_data = dmap_read.get_dmap_records
self.dmap_compare(dmap_stream_data, dmap_data)
os.remove("test_rawacf.rawacf")
