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 = pydarn.SDarnWrite(rawacf_data, "rawacf_test.rawacf") self.assertEqual(darn.filename, "rawacf_test.rawacf")
def test_DmapRead_SDarnWrite_rawacf(self): """ Test DmapRead reading an rawacf and SDarnWrite writing the rawacf file """ dmap = pydarn.DmapRead(rawacf_file) dmap_data = dmap.read_records() dmap_write = pydarn.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_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(pydarn.dmap_exceptions.DmapDataError): pydarn.SDarnWrite([], 'dummy_file.acf')
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 = pydarn.SDarnWrite(iqdat_data, "test_iqdat.iqdat") iqdat_write.write_iqdat() iqdat_read = pydarn.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 = pydarn.SDarnWrite(fitacf_data, "test_fitacf.fitacf") fitacf_write.write_fitacf() fitacf_read = pydarn.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_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 = pydarn.SDarnWrite(grid_data, "test_grid.grid") grid_write.write_grid() grid_read = pydarn.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_grid(self): """ Test DmapRead reading an grid and SDarnWrite writing the grid file """ dmap = pydarn.SDarnRead(grid_file) dmap_data = dmap.read_grid() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_grid("test_grid.grid") grid_read = pydarn.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_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 = pydarn.SDarnWrite(iqdat_data, "test_iqdat.iqdat") iqdat_write.write_iqdat() iqdat_read = pydarn.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_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 = pydarn.SDarnWrite(map_data, "test_map.map") map_write.write_map() map_read = pydarn.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_SDarnRead_SDarnWrite_iqdat(self): """ Test DmapRead reading an fitacf and SDarnWrite writing the fitacf file """ dmap = pydarn.SDarnRead(iqdat_file) dmap_data = dmap.read_iqdat() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_iqdat("test_iqdat.iqdat") iqdat_read = pydarn.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_fitacf(self): """ Test DmapRead reading a fitacf file then writing it with SDarnWrite then reading it again with SDarnRead """ dmap = pydarn.DmapRead(fitacf_file) dmap_data = dmap.read_records() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_fitacf("test_fitacf.fitacf") darn_read = pydarn.SDarnRead("test_fitacf.fitacf") fitacf_data = darn_read.read_fitacf() self.dmap_compare(dmap_data, fitacf_data) os.remove("test_fitacf.fitacf")
def test_SDarnRead_SDarnWrite_fitacf(self): """ Test DmapRead reading an fitacf and SDarnWrite writing the fitacf file """ dmap = pydarn.SDarnRead(fitacf_file) dmap_data = dmap.read_fitacf() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_fitacf("test_fitacf.fitacf") fitacf_read = pydarn.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_DmapRead_SDarnWrite_SDarnRead_grid(self): """ Test DmapRead reading a grid file then writing it with SDarnWrite then reading it again with SDarnRead """ dmap = pydarn.DmapRead(grid_file) dmap_data = dmap.read_records() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_grid("test_grid.grid") darn_read = pydarn.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_iqdat(self): """ Test SDarnRead reads from a stream and SDarnWrite writes to a iqdat file """ dmap = pydarn.DmapRead(iqdat_file) dmap_data = dmap.read_records() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_iqdat("test_iqdat.iqdat") darn_read = pydarn.SDarnRead("test_iqdat.iqdat") iqdat_data = darn_read.read_iqdat() self.dmap_compare(dmap_data, iqdat_data) os.remove("test_iqdat.iqdat")
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 = pydarn.DmapRead(map_file) dmap_data = dmap.read_records() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_map("test_map.map") darn_read = pydarn.SDarnRead("test_map.map") map_data = darn_read.read_map() self.dmap_compare(dmap_data, map_data) os.remove("test_map.map")
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 = pydarn.SDarnWrite(grid_data, "test_grid.grid") grid_write.write_grid() grid_read = pydarn.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_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 = pydarn.SDarnWrite(rawacf_data, "test_rawacf.rawacf") rawacf_write.write_rawacf() rawacf_read = pydarn.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_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 = pydarn.SDarnWrite(map_data, "test_map.map") map_write.write_map() map_read = pydarn.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_SDarnRead_SDarnWrite_map(self): """ Test DmapRead reading an map and SDarnWrite writing the map file """ dmap = pydarn.SDarnRead(map_file) dmap_data = dmap.read_map() dmap_write = pydarn.SDarnWrite(dmap_data) dmap_write.write_map("test_map.map") map_read = pydarn.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_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 = pydarn.dict2dmap(rawacf_dict_data) darn_write = pydarn.SDarnWrite(dmap_rawacf) with self.assertRaises(pydarn.superdarn_exceptions. SuperDARNDataFormatTypeError): darn_write.write_rawacf("test_rawacf.rawacf")
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 = pydarn.dict2dmap(rawacf_dict_data) darn_read = pydarn.SDarnWrite(dmap_rawacf) darn_read.write_rawacf("test_rawacf.rawacf") dmap_read = pydarn.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_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 = pydarn.SDarnWrite(grid_data) dmap.write_grid("test_grid.grid") self.assertTrue(os.path.isfile("test_grid.grid")) os.remove("test_grid.grid")
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 = pydarn.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 = pydarn.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_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 = pydarn.SDarnWrite(fitacf_data) dmap.write_fitacf("test_fitacf.fitacf") self.assertTrue(os.path.isfile("test_fitacf.fitacf")) os.remove("test_fitacf.fitacf")
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 = pydarn.SDarnRead(dmap_stream, True) dmap_stream_data = dmap.read_map() dmap_write = pydarn.SDarnWrite(dmap_stream_data) dmap_write.write_map("test_map.map") self.assertTrue(os.path.isfile("test_map.map")) dmap = pydarn.SDarnRead("test_map.map") dmap_data = dmap.read_map() self.dmap_compare(dmap_stream_data, dmap_data)
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 = pydarn.DmapRead(dmap_stream, True) dmap_stream_data = dmap.read_records() dmap_write = pydarn.SDarnWrite(dmap_stream_data) dmap_write.write_map("test_map.map") dmap = pydarn.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_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 = pydarn.SDarnRead(dmap_stream, True) stream_data = dmap.read_rawacf() dmap_stream_data = dmap.get_dmap_records dmap_write = pydarn.SDarnWrite(stream_data) dmap_write.write_rawacf("test_rawacf.rawacf") dmap_read = pydarn.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")
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 = pydarn.DmapRead(dmap_stream, True) stream_data = dmap.read_records() dmap_stream_data = dmap.get_dmap_records dmap_write = pydarn.SDarnWrite(stream_data) dmap_write.write_fitacf("test_fitacf.fitacf") dmap = pydarn.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 = pydarn.SDarnRead(dmap_stream, True) stream_data = dmap.read_iqdat() dmap_stream_data = dmap.get_dmap_records dmap_write = pydarn.SDarnWrite(stream_data) dmap_write.write_iqdat("test_iqdat.iqdat") self.assertTrue(os.path.isfile("test_iqdat.iqdat")) dmap = pydarn.SDarnRead("test_iqdat.iqdat") _ = dmap.read_iqdat() dmap_read_data = dmap.get_dmap_records self.dmap_compare(dmap_stream_data, dmap_read_data)