def test_invalid_arguments(self):
points = titanlib.Points(lats, lons, elevs)
N = 3
args0 = [points, values, num_min, num_max, inner_radius,
outer_radius, num_iterations, num_min_prof, min_elev_diff, min_horizontal_scale,
vertical_scale, pos, neg, eps2]
invalid_arguments = [(2, -1), (3, -1), (4, -1000),
(5, -1000), (6, -1), (7, -1), (8, -1), (9, -1),
(10, -1), (11, [-1] * N), (12, [-1] * N), (13, [-1] * N), (13, [0] * N)]
for invalid_argument in invalid_arguments:
with self.subTest(argument=invalid_argument[0]):
with self.assertRaises(ValueError):
args = args0
args[invalid_argument[0]] = invalid_argument[1]
titanlib.sct(*args)
def test_simple(self):
elevs0 = [0, 0, 0]
values0 = [0, 1, 100]
points0 = titanlib.Points(lats, lons, elevs0)
flags, sct, rep = titanlib.sct(points0, values0, num_min, num_max, inner_radius,
outer_radius, num_iterations, num_min_prof, min_elev_diff, min_horizontal_scale,
vertical_scale, pos, neg, eps2)
np.testing.assert_array_equal(flags, [0, 0, 1])
def test_obs_to_check(self):
elevs0 = [0, 0, 0, 0, 0, 0]
values0 = [0, 1, 1, 1, 100, 100]
points0 = titanlib.Points(lats*2, lons*2, elevs0)
obs_to_check0 = [0, 1, 1, 1, 1, 0]
flags, sct, rep = titanlib.sct(points0, values0, num_min, num_max, inner_radius,
outer_radius, num_iterations, num_min_prof, min_elev_diff, min_horizontal_scale,
vertical_scale, np.ones(6), np.ones(6), 0.5 * np.ones(6), obs_to_check0)
np.testing.assert_array_equal(flags, [0, 0, 0, 0, 1, 0])
def test_valid_input(self):
"""Check that the test doesn't fail"""
N = 100
lats = np.random.randn(N) * 10000
lons = np.random.randn(N) * 10000
elevs = np.random.rand(N) * 100
values = np.random.randn(N) * 6
t2pos = np.ones(N) * 4
t2neg = np.ones(N) * 4
eps2 = np.ones(N) * 0.5
sct, rep, flags = titanlib.sct(lats, lons, elevs, values, 100, 1000,
100, 100, 10000, 100, t2pos, t2neg,
eps2)
def test_time(self):
s_time = time.time()
N = 3000
lats = np.random.randn(N) * 1;
lons = np.random.randn(N) * 1;
elevs = np.random.rand(N) * 100;
points = titanlib.Points(lats, lons, elevs)
values = np.random.randn(N) * 6;
pos = np.ones(N) * 4;
neg = np.ones(N) * 4;
eps2 = np.ones(N) * 0.5;
flags, sct, rep = titanlib.sct(points, values, 5, 100, 4000, 10000, 2, 30, 100, 1000, 100, pos, neg, eps2)
print("%.1fs" % (time.time() - s_time))
def test(self, dataset, mask, code=1):
global_flags = dataset.flags
proj = pyproj.Proj(
"+proj=lcc +lat_0=63 +lon_0=15 +lat_1=63 +lat_2=63 +no_defs +R=6.371e+06"
)
x_proj = []
y_proj = []
elevs = []
values = []
for i in range(0, len(mask)):
x_p, y_p = proj(dataset.lons[mask[i]], dataset.lats[mask[i]])
x_proj.append(x_p)
y_proj.append(y_p)
if np.isnan(dataset.elevs[mask[i]]):
elevs.append(0)
print("WARNING: Should have beeen removed. Set elevation to 0")
else:
elevs.append(dataset.elevs[mask[i]])
values.append(dataset.values[mask[i]] - 273.15)
if np.isnan(x_p) or np.isnan(y_p) or np.isnan(dataset.elevs[mask[i]]) \
or np.isnan(dataset.values[mask[i]] - 273.15):
print(x_p, y_p, dataset.elevs[mask[i]],
dataset.values[mask[i]] - 273.15)
status, sct, flags = tit.sct(x_proj, y_proj, elevs, values, self.nmin,
self.nmax, self.nminprof, self.dzmin,
self.dhmin, self.dz, self.t2pos,
self.t2neg, self.eps2)
for i in range(0, len(mask)):
if global_flags[mask[i]] == 0 and flags[i] == 1:
global_flags[mask[i]] = code
dataset.normalize_ci(mask, self.cmin, self.cmax)
if self.debug:
for i in range(0, len(mask)):
print(self.name, i, mask[i], dataset.values[mask[i]], sct[i],
flags[i], global_flags[mask[i]])
return global_flags
def test_nminprof(self):
nminprof = 20
sct, rep, flags = titanlib.sct(len100, len100, len100, z100, 100, 1000,
nminprof, 100, 10000, 100, 2 * o100,
2 * o100, 0.5 * o100)
def test(self, dataset, mask, code=105):
if tit is None:
raise ModuleNotFoundError("titanlib was not loaded properly")
global_flags = dataset.flags
lons = []
lats = []
elevs = []
values = []
old_mask = mask
mask = []
nmissing_elev = 0
for i in range(0, len(old_mask)):
if np.isnan(dataset.elevs[old_mask[i]]):
if not self.missing_elev_to_zero:
ind = i - nmissing_elev
# print(i, old_mask[i], nmissing_elev, ind, len(self.pos))
self.pos.pop(ind)
self.neg.pop(ind)
self.eps2.pop(ind)
else:
mask.append(old_mask[i])
nmissing_elev = nmissing_elev + 1
else:
mask.append(old_mask[i])
for i in range(0, len(mask)):
lons.append(dataset.lons[mask[i]])
lats.append(dataset.lats[mask[i]])
if np.isnan(dataset.elevs[mask[i]] and self.missing_elev_to_zero):
elevs.append(0)
else:
elevs.append(dataset.elevs[mask[i]])
values.append(dataset.values[mask[i]])
# DEBUG
if np.isnan(dataset.lons[mask[i]]):
print(i, "lon")
raise Exception()
if np.isnan(dataset.lats[mask[i]]):
print(i, "lat")
raise Exception
if np.isnan(dataset.values[mask[i]]):
print(i, "value")
raise Exception
if nmissing_elev > 0:
if self.missing_elev_to_zero:
print("Found " + str(nmissing_elev) + "/" + str(len(old_mask)) +
" observations with undefined elevations which were set to zero")
else:
print("Removed " + str(nmissing_elev) + "/" + str(len(old_mask)) +
" obsevations with undefined elevations")
print("Running sct")
if len(values) > 0:
lats = np.asarray(lats)
lons = np.asarray(lons)
elevs = np.asarray(elevs)
values = np.asarray(values)
answer = tit.sct(lats, lons, elevs, values, self.num_min, self.num_max, self.inner_radius,
self.outer_radius, self.num_iterations, self.num_min_prof, self.min_elev_diff,
self.min_horizonal_scale, self.vertical_scale, self.pos, self.neg, self.eps2)
flags = answer[0]
sct = answer[1]
rep = answer[2]
for i in range(0, len(mask)):
if int(global_flags[mask[i]]) == 0 and flags[i] == 1:
global_flags[mask[i]] = code
dataset.normalize_ci(mask, self.cmin, self.cmax)
if self.debug:
for i in range(0, len(mask)):
print(self.name, i, mask[i], dataset.values[mask[i]], sct[i], rep[i], int(flags[i]),
int(global_flags[mask[i]]))
else:
print("No observations to run test on")
return global_flags
inner_radius = 50000
outer_radius = 100000
num_min = 5
num_max = 100
num_iterations = 1
num_min_prof = 20
dzmin = 100
dhmin = 10000
dz = 200
t2pos = np.full([len(obs)], 4)
t2neg = np.full([len(obs)], 4)
eps2 = np.full([len(obs)], 0.5)
print(t2pos.shape)
# Run the SCT
flags, sct, rep = titanlib.sct(obs_lats, obs_lons, obs_elevs, obs, num_min, num_max, inner_radius,
outer_radius, num_iterations, num_min_prof, dzmin, dhmin , dz, t2pos, t2neg, eps2)
index_valid_obs = np.where(flags == 0)[0]
index_invalid_obs = np.where(flags != 0)[0]
print(index_invalid_obs)
# Plot the quality control results
import matplotlib.pylab as mpl
mpl.scatter(obs_lons[index_valid_obs], obs_lats[index_valid_obs],
c=obs[index_valid_obs] - 273.15, s=50, linewidths=0, cmap="RdBu_r", vmin=5, vmax=20)
mpl.scatter(obs_lons[index_invalid_obs], obs_lats[index_invalid_obs],
c=obs[index_invalid_obs] - 273.15, s=50, edgecolors="r", linewidths=1.5, cmap="RdBu_r",
vmin=5, vmax=20)
mpl.xlim(0, 35)
mpl.ylim(55, 75)
mpl.gca().set_aspect(2)
