def test_build_station_list():
# Build list of stations
stations = build_station_list()
# Find station 'Cam'
for station in stations:
if station.name == 'Cam':
station_cam = station
break
# Assert that station is found
assert station_cam
# Fetch data over past 2 days
dt = 2
dates2, levels2 = fetch_measure_levels(station_cam.measure_id,
dt=datetime.timedelta(days=dt))
assert len(dates2) == len(levels2)
# Fetch data over past 10 days
dt = 10
dates10, levels10 = fetch_measure_levels(station_cam.measure_id,
dt=datetime.timedelta(days=dt))
assert len(dates10) == len(levels10)
assert len(dates10) > len(levels2)
def run():
#Building list of stations to fetch data for
stations = build_station_list()
update_water_levels(stations)
N_stations_at_risk = stations_highest_rel_level(stations, 5)
#Variables
dt = 2 # Fetch data over past 2 days
p = 4 #Polynomial degree
i = 0 #Counter
for s in N_stations_at_risk:
i += 1
dates, levels = fetch_measure_levels(
s[0].measure_id,
dt=datetime.timedelta(days=dt)) #Compiling dates and water levels
if not dates:
print('Insufficient Data')
else:
d0, poly = polyfit(dates, levels, p) #Creating polynomial
#Plotting data, polynomial and typical high/low
plt.subplot(3, 3, i + 1)
plt.plot(dates, levels)
plt.plot(dates, poly((mpl.dates.date2num(dates) - d0)))
plt.axhline(y=s[0].typical_range[0], color='y')
plt.axhline(y=s[0].typical_range[1], color='r')
plt.xlabel('date')
plt.ylabel('water level (m)')
plt.xticks(rotation=45)
plt.title(s[0].name)
plt.show()
def run():
N = 5
DT = 2
P = 4
stations = build_station_list()
update_water_levels(stations)
at_risk_stations = stations_highest_rel_level(stations, N)
for station in at_risk_stations:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=DT))
# plot real data
date_nums = date2num(dates) - date2num(dates[0])
plt.plot(date_nums, levels, color="orange")
# plot line of best fit
plot_water_level_with_fit(station, dates, levels, P)
# plot high/low
plt.axhline(station.typical_range[0],
linestyle="dashed",
color="green")
plt.axhline(station.typical_range[1], linestyle="dashed", color="red")
plt.legend(("Real values", "Best fit", "Typical low", "Typical high"))
plt.show()
def run():
#Requirements for Task2E
n = 6
dt = 10
stations = build_station_list()
update_water_levels(stations)
#build list of tuples of stations
b_tuples = stations_highest_rel_level(stations, n)
#Let"s convert the list of tuples into a list of stations!
b = []
for station in stations: #maybe change the order of these two functions?
for station_tuple in b_tuples:
if station.name == station_tuple[0]:
b.append(station)
break
print(b)
# plot data for each station
for station in b:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
if len(dates) == 0 or len(levels) == 0:
continue # Test for the stations with incorrect datafetcher responses
plot_water_levels(station, dates, levels)
plt.show()
def run():
#get the stations data and sorted by latest water level
stations = build_station_list()
#get the six stations with the largest water level
highest_six = stations_highest_rel_level(stations, 6)
#set the length of time for wanted water level
dt = 10
#plotting water level against time of those six stations
i = 0
station_name = []
date_and_level = []
for station in highest_six:
dates, levels = fetch_measure_levels(station.measure_id, dt=datetime.timedelta(days=dt))
plt.subplots()
plot_water_levels(station, dates, levels)
station_name.append(station.name)
date_and_level.append((dates, levels))
i += 1
plt.show()
print(station_name)
return station_name, date_and_level
def test_polyfit():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
station_and_relative_water_levels = []
for station in stations:
station_and_relative_water_levels.append(
(station.relative_water_level(), station.name, station))
p = 2
dt = 2
dates, levels = fetch_measure_levels(stations[3].measure_id,
dt=datetime.timedelta(days=dt))
#fit data to a polynomial
x = matplotlib.dates.date2num(dates)
y = levels
#shift axis
d0 = x - x[0]
# Find coefficients of best-fit polynomial f(x) of degree p
p_coeff = np.polyfit(d0, y, p)
# Convert coefficient into a polynomial that can be evaluated,
# e.g. poly(0.3)
poly = np.poly1d(p_coeff)
assert len(poly(d0)) == len(d0)
def run():
"""Requirements for Task 2E"""
# Build list of stations
stations = build_station_list()
# Find 5 stations at which the current level is the highest
stations_highest_rel_level_list = []
N = 5
for i in range(len(stations_highest_rel_level(stations, N))):
stations_highest_rel_level_list.append(
stations_highest_rel_level(stations, N)[i][0])
# Plot the water level for each of these stations over the past 10 days
# First fetch the time history for a station
for station in stations:
if station.name in stations_highest_rel_level_list:
dt = 10
dates, levels = fetch_measure_levels(
station.measure_id, dt=datetime.timedelta(days=dt))
# This gives list of dates and levels to be passed into a plot
plot_water_level(station, dates, levels)
else:
pass
def run():
"""Requirement for task 2G"""
#build a list of stations
stations = build_station_list()
update_water_levels(stations)
stations_at_risk = stations_highest_rel_level(stations, 10)
# Fetch data over past 2 days
dt = 0.5
danger_stations = []
for station in stations_at_risk:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
try:
prediction = predicted_value(dates, levels)
danger_level = danger_assigning(station, prediction)
if danger_level is not None:
if danger_level[1] == "severe" or danger_level[1] == "high":
danger_stations.append(danger_level)
except:
pass
sorted_stations = sorted_by_key(danger_stations, 1, reverse=True)
for i in sorted_stations:
print(i[0] + ":" + i[1])
def run():
# Build list of stations
stations = build_station_list()
# Update latest level data for all stations
update_water_levels(stations)
#create list of names stations to be plotted with their measure_id
highest_levels=stations_highest_rel_level(stations, 5)
stations_to_plot = []
#retrieve the rest of station data for the high
for j in highest_levels:
for i in stations:
if j[0] == i.name:
stations_to_plot.append(i)
dt = 10
#plot data for each station
for i in stations_to_plot:
dates, levels = fetch_measure_levels(i.measure_id,
dt=timedelta(days=dt))
plot_water_levels(i.name,dates,levels)
plt.show()
def update_text_select(attr, old, new):
"""Function that updates the selected plot according to the name text provided."""
global current_selection
logger.info('Current Selection: {}'.format(current_selection))
input_text = select_input.value
if input_text == current_selection[0]: # without fuzzy match, the new station is equal to the current station
return
if input_text != '':
selected_station_name = process.extractOne(input_text, source.data['name'])[0]
if selected_station_name == current_selection[0]:
# after fuzzy match, the new station is equal to the current station
select_input.value = selected_station_name
return
logger.info('Input: {}, Matched: {}'.format(input_text, selected_station_name))
indx = name_to_indx[selected_station_name]
current_selection = [selected_station_name, indx] # update the current selection cache
r.data_source.selected.indices = [indx] # update the selection on map
select_input.value = selected_station_name # update the displayed text in the text input box
# TODO recenter map
dates, levels = fetch_measure_levels(source.data['measure_id'][indx],
dt=timedelta(days=30)) # get the data for the newly selected station
selected_plot_source.data.update(dict(dates=dates, levels=levels))
else:
current_selection = [None, None] # update the current selection
r.data_source.selected.indices = []
selected_plot_source.data.update(dict(dates=[], levels=[]))
def run(N=5):
#get the stations data and sorted by latest water level
stations = build_station_list()
#get the six stations with the largest water level
highest_five = stations_highest_rel_level(stations, N) # NB Graylingwell does not give any date data
#set the length of time for wanted water level
dt = 365
i = 0
for station in highest_five:
dates, levels = fetch_measure_levels(station.measure_id, dt=datetime.timedelta(days=dt))
if len(dates) == 0:
print("This station:\n", station, "\ndoes not give any date data")
continue
plt.figure(i)
plot_water_level_with_fit(station, dates, levels, 10)
i += 1
print(i, ' out of ', N, ' were printed')
plt.show()
def assess_risk(stations):
"""A function that given a list of MonitoringStations, calculates the risk
of each station and places it in severe, high, moderate or low category"""
ls = []
for station in stations:
#Get data
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=5))
#Pass inconsistent data
if levels == []:
pass
else:
poly, d0 = polyfit(dates, levels, 1)
if poly[1] < 0.01:
status = 'Low'
elif poly[1] < 0.05:
status = 'Moderate'
elif poly[1] < 0.1:
status = 'High'
else:
status = 'Severe'
ls.append(status)
return ls
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
station_and_relative_water_levels = []
for station in stations:
station_and_relative_water_levels.append(
(station.relative_water_level(), station.name, station))
stations_with_values_for_water_levels = []
for x in station_and_relative_water_levels:
if x[0] is None:
pass
else:
stations_with_values_for_water_levels.append(x)
stations_with_values_for_water_levels.sort(reverse=True)
greatest_5 = stations_with_values_for_water_levels[1:6]
p = 4
for n in greatest_5:
#Fetch data over past 2 days
dt = 2
dates, levels = fetch_measure_levels(n[2].measure_id,
dt=datetime.timedelta(days=dt))
#fit data to a polynomial
k = polyfit(dates, levels, p)
#plot graph with data and also polynomial
plot_water_level_with_fit(n[2], dates, levels, k)
#plot lines of typical high and low
plt.axhline(n[2].typical_range[0], linewidth=2, color='r')
plt.axhline(n[2].typical_range[1], linewidth=2, color='r')
plt.show()
def run():
stations = stationdata.build_station_list()
stationdata.update_water_levels(stations)
stations = station.consistant_typical_range_stations(stations)
top10Stations = flood.stations_highest_rel_level(stations, 10)
topStations = []
topStationsDates = []
topStationsLevels = []
counter = 0
NUMBER_PLOTS = 5
for st in top10Stations:
stationDates, stationLevels = datafetcher.fetch_measure_levels(
st.measure_id, timedelta(days=2))
# only consistant ones get saved
if all(isinstance(x, (int, float))
for x in stationLevels) and stationDates != []:
counter += 1
topStations.append(st)
topStationsDates.append(stationDates)
topStationsLevels.append(stationLevels)
if counter == NUMBER_PLOTS:
break
# single object input
# plot.plot_water_level_with_fit(topStations[0], topStationsDates[0], topStationsLevels[0], 4)
# list of object input
plot.plot_water_level_with_fit(topStations, topStationsDates,
topStationsLevels, 4)
def test_polyfit():
stations = build_station_list()
station = stations[0]
dt = 2
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
N = randint(1, 5)
assert type(polyfit(dates, levels, N)) == tuple
def run():
stations = build_station_list()
update_water_levels(stations)
key = stations[0].measure_id
station = stations[0]
dt = 5
dates, levels = fetch_measure_levels(key, dt=datetime.timedelta(days=dt))
p = 4
plot_water_level_with_fit(station, dates, levels, p)
def average_of_latest_level(station, p, dt, dt_future):
'''
This function is to get average of the water levels in recent 2 days and the predicting water level of
the following 2 days
Input:
station: a MonitoringStaiion object
p : degree of the best fit polynomial
dt : the number of sample past days
'''
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
if len(levels) == 0:
return None
poly, d0 = polyfit(dates, levels, p)
# get dates float
dates_f = matplotlib.dates.date2num(dates)
future_dates_float = dates_f + (dates_f[0] - dates_f[-1])
# get future date from future date float
future_dates = []
for date in future_dates_float:
future_dates.append(matplotlib.dates.num2date(date))
future_dates_float_c = future_dates_float - dates_f[0]
# predict future water level by poly
# x = np.linspace(date_f[0], date_f[-1], len(date_f))
# print(type(x))
future_level = list(poly(future_dates_float_c))
#Cuz the predicted level at the end of the future 2 days are too large to be exaxt, so only
#fetch part of the future predicted levels
a = int(float(dt_future) / float(dt) * len(future_level))
# prepare to calculate average value of past and future levels
merge_water_level = future_level[-a:-1] + levels
merge_dates = future_dates[-a:-1] + dates
'''
for date in future_dates[-a:-1]:
print(date)
print('\n')
for date in dates:
print(date)
print('a station')
'''
average_level = future_level[-a:-1] + levels[0:a]
#calculate average level
return sum(average_level) / float(
len(average_level)), merge_water_level, merge_dates
def run():
# Build list of stations
stations = build_station_list()
N = 5
update_water_levels(stations)
list_of_5_stations_greatest_level = stations_highest_rel_level(stations, N)
dt = 10
for station in list_of_5_stations_greatest_level:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def run():
stations = build_station_list()
update_water_levels(stations)
stations_relative = stations_highest_rel_level(stations, 5)
dt = 10
for station in stations_relative:
dates, levels = fetch_measure_levels(station.measure_id,
datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def test_polyfit():
dt = 10
#create time and level data to be testerd
times, levels = fetch_measure_levels(stations[0].measure_id,
dt=timedelta(days=dt))
x = dates.date2num(times)
#run polyfit
poly, d0 = polyfit(times, levels, 2)
assert d0 == x[0]
assert isinstance(poly, np.poly1d)
def run():
# Build list of stations
stations = build_station_list()
N=5 #number of stations we consider of having highest risk of flood
update_water_levels(stations)
list_of_5_stations_greatest_level=stations_highest_rel_level(stations , N)
dt=2
p=4 #degree 4 against time
for station in list_of_5_stations_greatest_level:
dates, levels = fetch_measure_levels(station.measure_id, dt=datetime.timedelta(days=dt))
poly, d0 = polyfit(dates, levels, p)
plot_water_level_with_fit(station, dates, levels, p)
def run():
stations = build_station_list()
update_water_levels(stations)
high_risk_stations = stations_highest_rel_level(stations, 5)
for station in high_risk_stations:
dates, levels = fetch_measure_levels(station.measure_id,
dt=timedelta(days=2))
try:
graph = plot_water_level_with_fit(station, dates, levels, 4)
show(graph)
except TypeError:
print('No data')
def run():
stations = build_station_list()
dt = 10
update_water_levels(stations)
greatest_relative_level_stations = stations_highest_rel_level(stations, 5)
for station in greatest_relative_level_stations:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
plt.show()
def test_analyse():
stations = build_station_list()
dt = 10
stations=sorted(stations, key=lambda x: x.name)
for station in stations[:10]:
dates, levels = fetch_measure_levels(
station.measure_id, dt=datetime.timedelta(days=dt))
p=4
poly, d0 = polyfit(dates,levels,p)
dydx=np.polyder(poly)
assert dydx==np.poly1d.deriv(poly)
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
# Fetch data over past 2 days
dt = 10
x=stations_highest_rel_level(stations,5)
for station, ratio in x:
dates, levels = fetch_measure_levels(
station.measure_id, dt=datetime.timedelta(days=dt))
print(station.name)
plot_water_levels(station, dates, levels)
def plot_graph(risk_level):
for sample in risk_level:
for station in stations:
if station.name == sample:
dt = 5
dates, levels = fetch_measure_levels(
station.measure_id, dt=datetime.timedelta(days=dt))
if len(dates) == 0:
print("NO AVAILABLE DATA for:", station.name)
else:
plot_water_level_with_fit(station, dates, levels, 4)
#print ("Gradient of curve:", grad(dates,levels,4))
grad_risk.append((station.name, grad(dates, levels, 4)))
def run():
"""Requirement for task 2F"""
#build a list of stations
stations = build_station_list()
update_water_levels(stations)
stations_at_risk = stations_highest_rel_level(stations, 5)
# Fetch data over past 2 days
dt = 2
for station in stations_at_risk:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_level_with_polyfit(station, dates, levels)
def run():
# Build list of stations
stations = build_station_list()
update_water_levels(stations)
stations_at_risk = stations_highest_rel_level(stations, 5)
print(stations_at_risk)
# Fetch data over past 10 days
dt = 10
for station in stations_at_risk:
dates, levels = fetch_measure_levels(station.measure_id,
dt=datetime.timedelta(days=dt))
plot_water_levels(station, dates, levels)
def test_plot_water_level_with_fit():
stations = build_station_list()
update_water_levels(stations)
p = 4
dt = 10
x = random.randrange(0, len(stations) - 1, 1)
y = random.randrange(0, len(stations) - 1, 1)
for i in [x, y]:
station = stations[i]
dates, levels = fetch_measure_levels(station.measure_id,
datetime.timedelta(days=dt))
plot_water_level_with_fit(station, dates, levels, p)
def run():
stations = stationdata.build_station_list()
stationdata.update_water_levels(stations)
stations = station.consistant_typical_range_stations(stations)
top5Stations = flood.stations_highest_rel_level(stations, 5)
top5StationsDates = []
top5StationsLevels = []
for top5station in top5Stations:
stationDates, stationLevels = datafetcher.fetch_measure_levels(
top5station.measure_id, timedelta(days=10))
top5StationsDates.append(stationDates)
top5StationsLevels.append(stationLevels)
plot.plot_water_levels(top5Stations, top5StationsDates, top5StationsLevels)
