def test_firms_cluster_pass(self):
""" Test _firms_clustering """
bf = BushFire()
firms_ori = bf._clean_firms_csv(TEST_FIRMS)
firms_ori['datenum'].values[100] = 7000
firms_ori = bf._firms_cons_days(firms_ori)
firms = bf._firms_clustering(firms_ori.copy(), 0.375 / 2 / 15, 15)
self.assertEqual(len(firms), 9325)
self.assertTrue(
np.allclose(firms.clus_id.values[-4:], np.zeros(4, int)))
self.assertEqual(firms.clus_id.values[100], 0)
self.assertEqual(firms.clus_id.values[2879], 3)
self.assertEqual(firms.clus_id.values[0], 2)
self.assertEqual(firms.clus_id.values[2], 2)
self.assertEqual(firms.clus_id.values[9320], 0)
self.assertEqual(firms.clus_id.values[4254], 2)
self.assertEqual(firms.clus_id.values[4255], 0)
self.assertEqual(firms.clus_id.values[8105], 1)
self.assertTrue(
np.allclose(np.unique(firms.clus_id.values), np.arange(4)))
for col_name in firms.columns:
if col_name not in ('clus_id', 'acq_date', 'confidence',
'instrument', 'satellite'):
self.assertTrue(
np.allclose(firms[col_name].values,
firms_ori[col_name].values))
elif col_name != 'clus_id':
for elem_l, elem_r in zip(firms[col_name].values,
firms_ori[col_name].values):
self.assertEqual(elem_l, elem_r)
def test_firms_resolution_pass(self):
""" Test _firms_resolution """
bf = BushFire()
firms = bf._clean_firms_csv(TEST_FIRMS)
self.assertAlmostEqual(bf._firms_resolution(firms), 0.375 / ONE_LAT_KM)
firms['instrument'][0] = 'MODIS'
self.assertAlmostEqual(bf._firms_resolution(firms), 1.0 / ONE_LAT_KM)
def test_centroids_resolution_pass(self):
""" Test _centroids_resolution """
bf = BushFire()
res_centr = bf._centroids_resolution(DEF_CENTROIDS[0])
res = get_resolution(DEF_CENTROIDS[0].lat, DEF_CENTROIDS[0].lon)
self.assertAlmostEqual((res[0] + res[1]) / 2, res_centr)
centroids = Centroids()
centroids.meta = {'transform': Affine(0.5, 0, -180, 0, -0.5, 90)}
res_centr = bf._centroids_resolution(centroids)
self.assertAlmostEqual(0.5, res_centr)
def test_bush_fire_all_rnd_pass(self):
bf = BushFire()
centr_res_factor = 1
bf.set_bush_fire(TEST_FIRMS, centr_res_factor, seed = 8)
bf.set_proba_all_event(ens_size = 3)
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.tag.description, '')
self.assertEqual(bf.units, 'K')
self.assertEqual(bf.centroids.size, 78090)
self.assertEqual(bf.event_id.size, 20)
self.assertEqual(bf.event_id[0], 1)
self.assertEqual(bf.event_name, ['1.0', '2.0', '3.0', '4.0', '5.0',
'1.0_gen0', '1.0_gen1', '1.0_gen2',
'2.0_gen0', '2.0_gen1', '2.0_gen2',
'3.0_gen0', '3.0_gen1', '3.0_gen2',
'4.0_gen0', '4.0_gen1', '4.0_gen2',
'5.0_gen0', '5.0_gen1', '5.0_gen2'])
self.assertTrue(np.array_equal(bf.frequency, np.array([0.25, 0.25, 0.25, 0.25, 0.25,
0.25, 0.25, 0.25,
0.25, 0.25, 0.25,
0.25, 0.25, 0.25,
0.25, 0.25, 0.25,
0.25, 0.25, 0.25])))
self.assertTrue(isinstance(bf.intensity, sparse.csr_matrix))
self.assertTrue(isinstance(bf.fraction, sparse.csr_matrix))
self.assertEqual(bf.intensity.shape, (20, 78090))
self.assertEqual(bf.fraction.shape, (20, 78090))
def test_clean_firms_pass(self):
""" Test _clean_firms_csv """
bf = BushFire()
firms = bf._clean_firms_csv(TEST_FIRMS)
self.assertEqual(firms['latitude'][0], 36.46245)
self.assertEqual(firms['longitude'][0], -121.8989)
self.assertEqual(firms['latitude'].iloc[-1], 36.17266)
self.assertEqual(firms['longitude'].iloc[-1], -121.61211000000002)
self.assertEqual(firms['datenum'].iloc[-1], 736245)
self.assertTrue(
np.array_equal(firms['iter_ev'].values, np.ones(len(firms), bool)))
self.assertTrue(
np.array_equal(firms['cons_id'].values,
np.zeros(len(firms), int) - 1))
self.assertTrue(
np.array_equal(firms['clus_id'].values,
np.zeros(len(firms), int) - 1))
def test_firms_cons_days_1_pass(self):
""" Test _firms_cons_days """
bf = BushFire()
firms_ori = bf._clean_firms_csv(TEST_FIRMS)
firms = bf._firms_cons_days(firms_ori.copy())
self.assertEqual(len(firms), 9325)
cons_id = np.zeros(9325, int)
cons_id[8176:-4] = 1
cons_id[-4:] = 2
self.assertTrue(np.allclose(firms.cons_id.values, cons_id))
for col_name in firms.columns:
if col_name not in ('cons_id', 'acq_date', 'confidence',
'instrument', 'satellite'):
self.assertTrue(
np.allclose(firms[col_name].values,
firms_ori[col_name].values))
elif col_name != 'cons_id':
for elem_l, elem_r in zip(firms[col_name].values,
firms_ori[col_name].values):
self.assertEqual(elem_l, elem_r)
def test_centroids_pass(self):
""" Test _centroids_creation """
bf = BushFire()
firms = bf._clean_firms_csv(TEST_FIRMS)
centroids = bf._centroids_creation(firms, 0.375 / ONE_LAT_KM, 1 / 2)
self.assertEqual(centroids.meta['width'], 144)
self.assertEqual(centroids.meta['height'], 138)
self.assertEqual(centroids.meta['crs']['init'], 'epsg:4326')
self.assertAlmostEqual(centroids.meta['transform'][0],
0.006749460043196544)
self.assertAlmostEqual(centroids.meta['transform'][1], 0.0)
self.assertTrue(
centroids.meta['transform'][2] <= firms.longitude.min())
self.assertAlmostEqual(centroids.meta['transform'][3], 0.0)
self.assertAlmostEqual(centroids.meta['transform'][4],
-centroids.meta['transform'][0])
self.assertTrue(centroids.meta['transform'][5] >= firms.latitude.max())
self.assertTrue(firms.latitude.max() <= centroids.total_bounds[3])
self.assertTrue(firms.latitude.min() >= centroids.total_bounds[1])
self.assertTrue(firms.longitude.max() <= centroids.total_bounds[2])
self.assertTrue(firms.longitude.min() >= centroids.total_bounds[0])
self.assertTrue(centroids.lat.size)
self.assertTrue(centroids.area_pixel.size)
self.assertTrue(centroids.on_land.size)
def test_iter_events_pass(self):
""" Test identification of events """
ori_thres = BushFire.days_thres
bf = BushFire()
firms = bf._clean_firms_csv(TEST_FIRMS)
firms['datenum'].values[100] = 7000
i_iter = 0
BushFire.days_thres = 3
while firms.iter_ev.any():
# Compute cons_id: consecutive events in current iteration
bf._firms_cons_days(firms)
# Compute clus_id: cluster identifier inside cons_id
bf._firms_clustering(firms, 0.375, 15)
# compute event_id
BushFire.days_thres = 2
bf._firms_event(BushFire.days_thres, firms.cons_id.values,
firms.clus_id.values, firms.event_id.values,
firms.iter_ev.values, firms.datenum.values)
i_iter += 1
self.assertEqual(i_iter, 2)
BushFire.days_thres = ori_thres
def test_random_one_pass(self):
""" Test _random_bushfire_one_event """
np.random.seed(8)
bf = BushFire()
bf.centroids = DEF_CENTROIDS[0]
bf.date = np.ones(1)
rnd_num = np.random.randint(2, size=1000)
bf.intensity = sparse.lil_matrix(np.zeros((1, bf.centroids.size)))
bf.intensity[0, :1000] = rnd_num
bf.intensity[0, np.logical_not(bf.centroids.on_land)] = 0
bf.intensity = bf.intensity.tocsr()
np.random.seed(8)
syn_haz = bf._random_bushfire_one_event(0, 5)
self.assertTrue(syn_haz.intensity.data.size >= bf.intensity.data.size)
self.assertTrue(syn_haz.centroids.area_pixel.sum() >=
bf.centroids.area_pixel.sum())
self.assertAlmostEqual(syn_haz.intensity.max(), bf.intensity.max())
self.assertAlmostEqual(syn_haz.intensity.min(), bf.intensity.min())
def test_pool_pass(self):
""" Test reproducibility with pool """
from pathos.pools import ProcessPool as Pool
pool = Pool()
bf = BushFire(pool)
bf.set_hist_events(TEST_FIRMS, 1 / 2)
bf.set_proba_events(ens_size=2, seed=9)
bf.check()
self.assertEqual(bf.size, 9 * 3)
orig = np.zeros(27, bool)
orig[:9] = True
self.assertTrue(np.allclose(bf.orig, orig))
self.assertTrue(
np.allclose(
bf.date[:9],
np.array([
736190, 736218, 736167, 736180, 736221, 736245, 736221,
736225, 736228
])))
self.assertTrue(np.allclose(bf.date[9:11], np.array([736190, 736190])))
self.assertTrue(np.allclose(bf.date[11:13], np.array([736218,
736218])))
self.assertTrue(np.allclose(bf.date[-2:], np.array([736228, 736228])))
self.assertEqual(bf.event_name[:9],
['1', '2', '3', '4', '5', '6', '7', '8', '9'])
self.assertEqual(bf.event_name[9:11], ['1_gen1', '1_gen2'])
self.assertEqual(bf.event_name[-2:], ['9_gen1', '9_gen2'])
self.assertAlmostEqual(bf.fraction.max(), 1.0)
self.assertAlmostEqual(bf.fraction.min(), 0.0)
self.assertAlmostEqual(bf.intensity[26, 9994], 301.5)
self.assertAlmostEqual(bf.intensity[26, 9995], 326.7)
self.assertAlmostEqual(bf.intensity[26, 10138], 326.7)
self.assertAlmostEqual(bf.intensity[26, 10281], 326.7)
self.assertEqual(bf.intensity[26, :].nonzero()[0].size, 4)
self.assertEqual(bf.intensity.nonzero()[0].size, 5517)
self.assertEqual(bf.intensity.shape, (27, 19872))
self.assertEqual(bf.fraction.shape, (27, 19872))
def test_centr_synth_pass(self):
""" Test probabilistic set_proba_events """
centroids = def_ori_centroids(-121.92908999999999, 35.66364,
-120.96468, 36.59146, 1 / 2)
bf = BushFire()
bf.set_hist_events(TEST_FIRMS, centroids=centroids)
bf.set_proba_events(ens_size=2, seed=8)
bf.check()
self.assertEqual(bf.size, 9 * 3)
orig = np.zeros(27, bool)
orig[:9] = True
self.assertTrue(np.allclose(bf.orig, orig))
self.assertTrue(
np.allclose(
bf.date[:9],
np.array([
736190, 736218, 736167, 736180, 736221, 736245, 736221,
736225, 736228
])))
self.assertTrue(np.allclose(bf.date[9:11], np.array([736190, 736190])))
self.assertTrue(np.allclose(bf.date[11:13], np.array([736218,
736218])))
self.assertTrue(np.allclose(bf.date[-2:], np.array([736228, 736228])))
self.assertEqual(bf.event_name[:9],
['1', '2', '3', '4', '5', '6', '7', '8', '9'])
self.assertEqual(bf.event_name[9:11], ['1_gen1', '1_gen2'])
self.assertEqual(bf.event_name[-2:], ['9_gen1', '9_gen2'])
self.assertEqual(bf.intensity.shape, (27, 19454))
self.assertEqual(bf.fraction.shape, (27, 19454))
self.assertAlmostEqual(bf.intensity[26, 10128], 301.5)
self.assertAlmostEqual(bf.intensity[26, 10269], 301.5)
self.assertAlmostEqual(bf.intensity[26, 10271], 295.4)
self.assertEqual(bf.intensity[26, :].nonzero()[0].size, 3)
self.assertEqual(bf.intensity.nonzero()[0].size, 5445)
self.assertAlmostEqual(bf.fraction.max(), 1.0)
self.assertAlmostEqual(bf.fraction.min(), 0.0)
def test_firms_event_pass(self):
""" Test _firms_event """
bf = BushFire()
firms_ori = bf._clean_firms_csv(TEST_FIRMS)
firms_ori['datenum'].values[100] = 7000
firms_ori = bf._firms_cons_days(firms_ori)
firms_ori = bf._firms_clustering(firms_ori, 0.375 / 2 / 15, 15)
firms = firms_ori.copy()
bf._firms_event(2, firms.cons_id.values, firms.clus_id.values,
firms.event_id.values, firms.iter_ev.values,
firms.datenum.values)
self.assertEqual(len(firms), 9325)
self.assertTrue(np.allclose(np.unique(firms.event_id), np.arange(7)))
self.assertTrue(np.allclose(firms.event_id[-4:], np.ones(4) * 6))
self.assertEqual(firms.event_id.values[100], 0)
self.assertEqual(firms.event_id.values[4255], 1)
self.assertEqual(firms.event_id.values[8105], 2)
self.assertEqual(firms.event_id.values[0], 3)
self.assertEqual(firms.event_id.values[2], 3)
self.assertEqual(firms.event_id.values[4254], 3)
self.assertEqual(firms.event_id.values[2879], 4)
self.assertEqual(firms.event_id.values[9320], 5)
self.assertFalse(firms.iter_ev.any())
for ev_id in np.unique(firms.event_id):
if np.unique(firms[firms.event_id == ev_id].cons_id).size != 1:
self.assertEqual(1, 0)
if np.unique(firms[firms.event_id == ev_id].clus_id).size != 1:
self.assertEqual(1, 0)
for col_name in firms.columns:
if col_name not in ('event_id', 'acq_date', 'confidence',
'instrument', 'satellite', 'iter_ev'):
self.assertTrue(
np.allclose(firms[col_name].values,
firms_ori[col_name].values))
elif col_name not in ('event_id', 'iter_ev'):
for elem_l, elem_r in zip(firms[col_name].values,
firms_ori[col_name].values):
self.assertEqual(elem_l, elem_r)
def test_bush_fire_one_pass(self):
bf = BushFire()
centr_res_factor = 1
bf.set_bush_fire(TEST_FIRMS, centr_res_factor, seed = 8)
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.tag.description, '')
self.assertEqual(bf.units, 'K')
self.assertEqual(bf.centroids.size, 78090)
self.assertEqual(bf.event_id.size, 5)
self.assertEqual(bf.event_id[0], 1)
self.assertEqual(bf.event_name, ['1.0', '2.0', '3.0', '4.0', '5.0'])
self.assertTrue(np.array_equal(bf.frequency, np.array([1, 1, 1, 1, 1])))
self.assertTrue(isinstance(bf.intensity, sparse.csr_matrix))
self.assertTrue(isinstance(bf.fraction, sparse.csr_matrix))
self.assertEqual(bf.intensity.shape, (5, 78090))
self.assertEqual(bf.fraction.shape, (5, 78090))
def test_hist_pass(self):
""" Test set_hist_events """
bf = BushFire()
bf.set_hist_events(TEST_FIRMS, centr_res_factor=1 / 2)
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.units, 'K')
self.assertTrue(np.allclose(bf.event_id, np.arange(1, 10)))
self.assertTrue(
np.allclose(
bf.date,
np.array([
736190, 736218, 736167, 736180, 736221, 736245, 736221,
736225, 736228
])))
self.assertTrue(np.allclose(bf.orig, np.ones(9, bool)))
self.assertEqual(bf.event_name,
['1', '2', '3', '4', '5', '6', '7', '8', '9'])
self.assertTrue(np.allclose(bf.frequency, np.ones(9)))
self.assertEqual(bf.intensity.shape, (9, 19872))
self.assertEqual(bf.fraction.shape, (9, 19872))
self.assertEqual(bf.intensity[1, :].nonzero()[1][0], 13052)
self.assertEqual(bf.intensity[3, :].nonzero()[1][0], 56)
self.assertEqual(bf.intensity[5, :].nonzero()[1][0], 8975)
self.assertEqual(bf.intensity[5, :].nonzero()[1][1], 8976)
self.assertEqual(bf.intensity[5, :].nonzero()[1].size, 2)
self.assertEqual(bf.intensity[6, :].nonzero()[1][0], 9555)
self.assertEqual(bf.intensity[6, :].nonzero()[1].size, 1)
self.assertEqual(bf.intensity[7, :].nonzero()[1][0], 8682)
self.assertEqual(bf.intensity[7, :].nonzero()[1].size, 3)
self.assertAlmostEqual(bf.intensity[0, 19003], 317.6)
self.assertAlmostEqual(bf.intensity[2, 2008], 0.0)
self.assertAlmostEqual(bf.intensity[2, 9409], 350.9)
self.assertAlmostEqual(bf.intensity[7, 8683], 307.9)
self.assertAlmostEqual(bf.fraction.max(), 1.0)
self.assertAlmostEqual(bf.fraction.min(), 0.0)
def test_centr_hist_pass(self):
""" Test set_hist_events """
centroids = def_ori_centroids(-121.92908999999999, 35.66364,
-120.96468, 36.59146, 1 / 2)
bf = BushFire()
bf.set_hist_events(TEST_FIRMS, centroids=centroids)
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.units, 'K')
self.assertTrue(np.allclose(bf.event_id, np.arange(1, 10)))
self.assertTrue(
np.allclose(
bf.date,
np.array([
736190, 736218, 736167, 736180, 736221, 736245, 736221,
736225, 736228
])))
self.assertTrue(np.allclose(bf.orig, np.ones(9, bool)))
self.assertEqual(bf.event_name,
['1', '2', '3', '4', '5', '6', '7', '8', '9'])
self.assertTrue(np.allclose(bf.frequency, np.ones(9)))
self.assertEqual(bf.intensity.shape, (9, 19454))
self.assertEqual(bf.fraction.shape, (9, 19454))
self.assertEqual(bf.intensity[1, :].nonzero()[1][0], 6764)
self.assertEqual(bf.intensity[3, :].nonzero()[1][0], 19367)
self.assertEqual(bf.intensity[5, :].nonzero()[1][0], 10696)
self.assertEqual(bf.intensity[5, :].nonzero()[1][1], 10697)
self.assertEqual(bf.intensity[6, :].nonzero()[1][0], 10132)
self.assertEqual(bf.intensity[7, :].nonzero()[1][0], 10834)
self.assertAlmostEqual(bf.intensity[0, 3257], 299.1)
self.assertAlmostEqual(bf.intensity[2, 13650], 367.0)
self.assertAlmostEqual(bf.intensity[2, 17328], 357.9)
self.assertAlmostEqual(bf.intensity[7, 10834], 336.7)
self.assertAlmostEqual(bf.fraction.max(), 1.0)
self.assertAlmostEqual(bf.fraction.min(), 0.0)
def test_bush_fire_rnd_one_pass(self):
bf = BushFire()
centr_res_factor = 1
bf.set_bush_fire(TEST_FIRMS, centr_res_factor, seed = 8)
bf_haz = bf._set_proba_one_event(ev_id = 3, ens_size = 3)
prob_haz = BushFire()
prob_haz._append_all(bf_haz)
bf.append(prob_haz)
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.tag.description, '')
self.assertEqual(bf.units, 'K')
self.assertEqual(bf.centroids.size, 78090)
self.assertEqual(bf.event_id.size, 8)
self.assertEqual(bf.event_id[0], 1)
self.assertEqual(bf.event_name, ['1.0', '2.0', '3.0', '4.0', '5.0', '3_gen0', '3_gen1', '3_gen2'])
self.assertTrue(np.array_equal(bf.frequency, np.array([1, 1, 1, 1, 1, 1, 1, 1])))
self.assertTrue(isinstance(bf.intensity, sparse.csr_matrix))
self.assertTrue(isinstance(bf.fraction, sparse.csr_matrix))
self.assertEqual(bf.intensity.shape, (8, 78090))
self.assertEqual(bf.fraction.shape, (8, 78090))
def test_random_brightness_one_pass(self):
bf = BushFire()
firms, description = bf._read_firms_csv(TEST_FIRMS)
firms = bf._clean_firms_csv(firms)
self.assertEqual(firms['latitude'][0], 36.46245)
self.assertEqual(firms['longitude'][0], -121.8989)
self.assertEqual(firms['latitude'].iloc[-1], 36.17266)
self.assertEqual(firms['longitude'].iloc[-1], -121.61211000000002)
centroids, res_data = bf._centroids_creation(firms, 1)
firms = bf._firms_cons_days(firms)
self.assertEqual(firms['cons_id'][9320], 0)
self.assertEqual(firms['cons_id'][9321], 1)
firms = bf._firms_clustering(firms, res_data)
self.assertEqual(firms['clus_id'][1621], 0)
self.assertEqual(firms['clus_id'][1622], 1)
self.assertEqual(firms['clus_id'][1623], 2)
firms = bf._firms_event(firms)
self.assertEqual(firms['event_id'][1621], 1)
self.assertEqual(firms['event_id'][1622], 2)
self.assertEqual(firms['event_id'][1623], 3)
self.assertEqual(firms['event_id'][9319], 3)
self.assertEqual(firms['event_id'][9320], 4)
bf._calc_brightness(firms, centroids)
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.tag.description, '')
self.assertEqual(bf.units, 'K')
self.assertEqual(bf.centroids.size, 78090)
self.assertEqual(bf.event_id.size, 5)
self.assertEqual(bf.event_id[0], 1)
self.assertEqual(bf.event_name, ['1.0', '2.0', '3.0', '4.0', '5.0'])
self.assertTrue(np.array_equal(bf.frequency, np.array([1, 1, 1, 1, 1])))
self.assertTrue(isinstance(bf.intensity, sparse.csr_matrix))
self.assertTrue(isinstance(bf.fraction, sparse.csr_matrix))
self.assertEqual(bf.intensity.shape, (5, 78090))
self.assertEqual(bf.fraction.shape, (5, 78090))
bf._area_one_year(2016)
ev_id = 3
area_hull_one_event = bf._hull_burned_area(ev_id)
self.assertAlmostEqual(area_hull_one_event, 60421, delta = 500)
prob_event = bf._random_bushfire_one_event(ev_id, 1)
prob_event.check()
self.assertEqual(prob_event.tag.haz_type, 'BF')
self.assertEqual(prob_event.tag.description, '')
self.assertEqual(prob_event.units, 'K')
self.assertEqual(prob_event.centroids.size, 78090)
self.assertEqual(prob_event.event_id.size, 1)
self.assertEqual(prob_event.event_id[0], 1)
self.assertEqual(prob_event.event_name, ['3_gen1'])
self.assertTrue(np.array_equal(prob_event.frequency, np.array([1])))
self.assertTrue(isinstance(prob_event.intensity, sparse.csr_matrix))
self.assertTrue(isinstance(prob_event.fraction, sparse.csr_matrix))
self.assertEqual(prob_event.intensity.shape, (1, 78090))
self.assertEqual(prob_event.fraction.shape, (1, 78090))
self.assertAlmostEqual(prob_event.intensity.nonzero()[0].size, 3928, delta = 10)
self.assertAlmostEqual(bf.intensity[ev_id - 1].data.mean(),prob_event.intensity[0].data.mean(), delta = 2)
self.assertAlmostEqual(bf.intensity[ev_id - 1].data.std(), prob_event.intensity[0].data.std(), delta = 2)
dlon_km = abs(firms['longitude'].min() - firms['longitude'].max()) * ONE_LAT_KM* \
np.cos(np.radians((abs(firms['latitude'].min() - firms['latitude'].max()))/2))
nb_centr_lat = int(dlat_km / res_data * centr_res_factor)
nb_centr_lon = int(dlon_km / res_data * centr_res_factor)
coord = (np.mgrid[firms['latitude'].min() : firms['latitude'].max() : complex(0, nb_centr_lat), \
firms['longitude'].min() : firms['longitude'].max() : complex(0, nb_centr_lon)]). \
reshape(2, nb_centr_lat*nb_centr_lon).transpose()
centroids.set_lat_lon(coord[:, 0], coord[:, 1])
centroids.set_area_approx()
centroids.set_on_land()
centroids.empty_geometry_points()
return centroids, res_data
DEF_CENTROIDS = def_ori_centroids(BushFire._clean_firms_csv(TEST_FIRMS), 1 / 2)
class TestMethodsFirms(unittest.TestCase):
"""Test loading functions from the BushFire class"""
def test_clean_firms_pass(self):
""" Test _clean_firms_csv """
bf = BushFire()
firms = bf._clean_firms_csv(TEST_FIRMS)
self.assertEqual(firms['latitude'][0], 36.46245)
self.assertEqual(firms['longitude'][0], -121.8989)
self.assertEqual(firms['latitude'].iloc[-1], 36.17266)
self.assertEqual(firms['longitude'].iloc[-1], -121.61211000000002)
self.assertEqual(firms['datenum'].iloc[-1], 736245)
self.assertTrue(
def test_hist_event_one_pass(self):
bf = BushFire()
firms = {
'latitude': [
-38.104, -38.104, -38.104, -38.104, -38.104, -38.093, -38.095,
-37.433, -37.421, -37.423, -37.45, -38.104, -38.104, -38.104,
-38.095, -37.45, -38.045, -38.047, -38.036, -37.983, -37.978,
-37.979, -37.981, -37.45, -37.431, -37.421, -37.423, -38.104
],
'longitude': [
146.388, 146.388, 146.388, 146.388, 146.388, 146.397, 146.386,
142.43, 142.442, 142.428, 145.361, 146.388, 146.388, 146.388,
146.397, 145.361, 146.416, 146.404, 146.413, 146.33, 146.311,
146.299, 146.288, 145.361, 142.445, 142.442, 142.428, 146.388
],
'brightness': [
400, 10, 316.5, 150, 500, 312.6, 312.7, 324.4, 373.6, 359.6,
312.9, 100, 400, 500, 300, 250, 100, 150, 300, 400, 250, 300,
332, 450, 200, 150, 400, 100
],
'acq_date': [
'2008-03-08', '2008-03-08', '2006-01-24', '2006-01-24',
'2006-01-24', '2006-01-24', '2006-01-24', '2006-01-24',
'2006-01-24', '2006-01-24', '2006-01-24', '2006-01-25',
'2006-01-25', '2006-01-28', '2006-01-28', '2006-01-30',
'2006-03-06', '2006-03-06', '2006-03-06', '2006-03-06',
'2007-01-24', '2007-01-24', '2007-01-24', '2007-01-24',
'2007-01-24', '2008-03-08', '2008-03-08', '2008-03-08'
]
}
firms, description = TestReaderDF._read_firms_synth(firms)
self.assertEqual(firms['latitude'][0], -38.104)
self.assertEqual(firms['longitude'][0], 146.388)
self.assertEqual(firms['latitude'].iloc[-1], -38.104)
self.assertEqual(firms['longitude'].iloc[-1], 146.388)
self.assertFalse(firms['datenum'][0] == firms['datenum'][9])
firms = bf._firms_cons_days(firms)
self.assertEqual(firms['cons_id'][0], 0)
self.assertEqual(firms['cons_id'][7], 0)
self.assertEqual(firms['cons_id'][8], 0)
self.assertEqual(firms['cons_id'][9], 0)
self.assertEqual(firms['cons_id'][10], 0)
self.assertEqual(firms['cons_id'][11], 1)
self.assertEqual(firms['cons_id'][13], 1)
self.assertEqual(firms['cons_id'][15], 2)
self.assertEqual(firms['cons_id'][21], 3)
self.assertEqual(firms['cons_id'][26], 4)
centroids, res_data = bf._centroids_creation(firms, 1)
firms = bf._firms_clustering(firms, res_data)
self.assertEqual(max((firms['clus_id'][:10]).values), 2)
self.assertEqual(max((firms['clus_id'][11:13]).values), 0)
firms = bf._firms_event(firms)
self.assertEqual(max((firms['event_id'][:10]).values), 3)
self.assertEqual(firms['event_id'][11], 4)
self.assertEqual(firms['event_id'][12], 4)
self.assertEqual(firms['event_id'][13], 5)
# add brightness matrix
bf._calc_brightness(firms, centroids)
self.assertEqual(bf.intensity[0, 1172], 500)
self.assertEqual(bf.intensity[0, 4714], 312.7)
self.assertEqual(bf.intensity[0, 4717], 312.6)
self.assertEqual(bf.intensity[1, 227620], 312.9)
self.assertEqual(bf.intensity[2, 232658], 324.4)
self.assertEqual(bf.intensity[2, 236200], 359.6)
self.assertEqual(bf.intensity[2, 237385], 373.6)
self.assertEqual(bf.intensity[3, 1172], 500)
self.assertEqual(bf.intensity[3, 4717], 300)
self.assertEqual(bf.intensity[4, 227620], 250)
# add probabilistic event
ev_id = 1
bf._random_bushfire_one_event(ev_id, 1)
def test_calc_bright_pass(self):
""" Test _calc_brightness """
# from pathos.pools import ProcessPool as Pool
# pool = Pool()
bf = BushFire()
firms = bf._clean_firms_csv(TEST_FIRMS)
firms['datenum'].values[100] = 7000
firms = bf._firms_cons_days(firms)
firms = bf._firms_clustering(firms, DEF_CENTROIDS[1] / 2 / 15, 15)
bf._firms_event(2, firms.cons_id.values, firms.clus_id.values,
firms.event_id.values, firms.iter_ev.values,
firms.datenum.values)
firms.latitude[8169] = firms.loc[16]['latitude']
firms.longitude[8169] = firms.loc[16]['longitude']
bf._calc_brightness(firms, DEF_CENTROIDS[0], DEF_CENTROIDS[1])
bf.check()
self.assertEqual(bf.tag.haz_type, 'BF')
self.assertEqual(bf.tag.description, '')
self.assertEqual(bf.units, 'K')
self.assertEqual(bf.centroids.size, 19454)
self.assertTrue(np.allclose(bf.event_id, np.arange(1, 8)))
self.assertEqual(bf.event_name, ['1', '2', '3', '4', '5', '6', '7'])
self.assertTrue(bf.frequency.size, 0)
self.assertTrue(isinstance(bf.intensity, sparse.csr_matrix))
self.assertTrue(isinstance(bf.fraction, sparse.csr_matrix))
self.assertEqual(bf.intensity.shape, (7, 19454))
self.assertEqual(bf.fraction.shape, (7, 19454))
self.assertEqual(bf.fraction.max(), 1.0)
self.assertAlmostEqual(bf.intensity[0, 16618],
firms.loc[100].brightness)
self.assertAlmostEqual(
bf.intensity[1, 123],
max(firms.loc[6721].brightness, firms.loc[6722].brightness))
self.assertAlmostEqual(bf.intensity[2, :].max(),
firms.loc[8105].brightness)
self.assertAlmostEqual(bf.intensity[4, 19367],
firms.loc[2879].brightness)
self.assertAlmostEqual(bf.intensity[5, 10132],
firms.loc[8176].brightness)
self.assertAlmostEqual(
bf.intensity[6, 10696],
max(firms.loc[9322].brightness, firms.loc[9324].brightness))
self.assertAlmostEqual(
bf.intensity[6, 10697],
max(firms.loc[9321].brightness, firms.loc[9323].brightness))
self.assertEqual((bf.intensity[0, :] > 0).sum(), 1)
self.assertEqual((bf.intensity[1, :] > 0).sum(), 424)
self.assertEqual((bf.intensity[2, :] > 0).sum(), 1)
self.assertEqual((bf.intensity[3, :] > 0).sum(), 1112)
self.assertEqual((bf.intensity[4, :] > 0).sum(), 1)
self.assertEqual((bf.intensity[5, :] > 0).sum(), 264)
self.assertEqual((bf.intensity[6, :] > 0).sum(), 2)
def test_set_frequency_pass(self):
""" Test _set_frequency """
bf = BushFire()
bf.date = np.array([736167, 736234, 736235])
bf.orig = np.ones(3, bool)
bf.event_id = np.arange(3)
bf._set_frequency()
self.assertTrue(np.allclose(bf.frequency, np.ones(3, float)))
bf = BushFire()
bf.date = np.array([
736167, 736167, 736167, 736234, 736234, 736234, 736235, 736235,
736235
])
bf.orig = np.zeros(9, bool)
bf.orig[[0, 3, 6]] = True
bf.event_id = np.arange(9)
bf._set_frequency()
self.assertTrue(np.allclose(bf.frequency, np.ones(9, float) / 3))
