def extract_mean_rainfall_from_shp_file(nc_f, wrf_output, output_prefix, output_name, basin_shp_file, basin_extent,
curw_db_adapter=None, curw_db_upsert=False, run_prefix='WRF',
run_name='Cloud-1'):
lon_min, lat_min, lon_max, lat_max = basin_extent
nc_vars = ext_utils.extract_variables(nc_f, ['RAINC', 'RAINNC'], lat_min, lat_max, lon_min, lon_max)
lats = nc_vars['XLAT']
lons = nc_vars['XLONG']
prcp = nc_vars['RAINC'] + nc_vars['RAINNC']
times = nc_vars['Times']
diff = ext_utils.get_two_element_average(prcp)
polys = shapefile.Reader(basin_shp_file)
output_dir = utils.create_dir_if_not_exists(os.path.join(wrf_output, output_prefix))
with TemporaryDirectory(prefix=output_prefix) as temp_dir:
output_file_path = os.path.join(temp_dir, output_prefix + '.txt')
kub_rf = {}
with open(output_file_path, 'w') as output_file:
kub_rf[output_name] = []
for t in range(0, len(times) - 1):
cnt = 0
rf_sum = 0.0
for y in range(0, len(lats)):
for x in range(0, len(lons)):
if utils.is_inside_polygon(polys, lats[y], lons[x]):
cnt = cnt + 1
rf_sum = rf_sum + diff[t, y, x]
mean_rf = rf_sum / cnt
t_str = (
utils.datetime_utc_to_lk(dt.datetime.strptime(times[t], '%Y-%m-%d_%H:%M:%S'),
shift_mins=30)).strftime('%Y-%m-%d %H:%M:%S')
output_file.write('%s\t%.4f\n' % (t_str, mean_rf))
kub_rf[output_name].append([t_str, mean_rf])
utils.move_files_with_prefix(temp_dir, '*.txt', output_dir)
if curw_db_adapter is not None:
station = [Station.CUrW, output_name, output_name, -999, -999, 0, 'Kelani upper basin mean rainfall']
if ext_utils.create_station_if_not_exists(curw_db_adapter, station):
logging.info('%s station created' % output_name)
logging.info('Pushing data to the db...')
ext_utils.push_rainfall_to_db(curw_db_adapter, kub_rf, upsert=curw_db_upsert, name=run_name,
source=run_prefix)
else:
logging.info('curw_db_adapter not available. Unable to push data!')
def extract_weather_stations(nc_f, wrf_output, weather_stations=None, curw_db_adapter=None, curw_db_upsert=False,
run_prefix='WRF', run_name='Cloud-1'):
if weather_stations is None:
weather_stations = res_mgr.get_resource_path('extraction/local/kelani_basin_stations.txt')
nc_fid = Dataset(nc_f, 'r')
times_len, times = ext_utils.extract_time_data(nc_f)
prefix = 'stations_rf'
stations_dir = utils.create_dir_if_not_exists(os.path.join(wrf_output, prefix))
stations_rf = {}
with TemporaryDirectory(prefix=prefix) as temp_dir:
with open(weather_stations, 'r') as csvfile:
stations = csv.reader(csvfile, delimiter=' ')
for row in stations:
logging.info(' '.join(row))
lon = row[1]
lat = row[2]
station_prcp = nc_fid.variables['RAINC'][:, lat, lon] + nc_fid.variables['RAINNC'][:, lat, lon]
station_diff = ext_utils.get_two_element_average(station_prcp)
stations_rf[row[0]] = []
station_file_path = os.path.join(temp_dir, row[0] + '_%s.txt' % prefix)
with open(station_file_path, 'w') as station_file:
for t in range(0, len(times) - 1):
t_str = (
utils.datetime_utc_to_lk(dt.datetime.strptime(times[t], '%Y-%m-%d_%H:%M:%S'),
shift_mins=30)).strftime('%Y-%m-%d %H:%M:%S')
station_file.write('%s\t%.4f\n' % (t_str, station_diff[t]))
stations_rf[row[0]].append([t_str, station_diff[t]])
utils.move_files_with_prefix(temp_dir, '*.txt', stations_dir)
if curw_db_adapter is not None:
logging.info('Pushing data to the db...')
ext_utils.push_rainfall_to_db(curw_db_adapter, stations_rf, upsert=curw_db_upsert, name=run_name,
source=run_prefix)
else:
logging.info('curw_db_adapter not available. Unable to push data!')
nc_fid.close()
def extract_point_rf_series(nc_f, lat, lon):
nc_fid = Dataset(nc_f, 'r')
times_len, times = ext_utils.extract_time_data(nc_f)
lats = nc_fid.variables['XLAT'][0, :, 0]
lons = nc_fid.variables['XLONG'][0, 0, :]
lat_start_idx = np.argmin(abs(lats - lat))
lon_start_idx = np.argmin(abs(lons - lon))
prcp = nc_fid.variables['RAINC'][:, lat_start_idx, lon_start_idx] + \
nc_fid.variables['RAINNC'][:, lat_start_idx, lon_start_idx] + \
nc_fid.variables['SNOWNC'][:, lat_start_idx, lon_start_idx] + \
nc_fid.variables['GRAUPELNC'][:, lat_start_idx, lon_start_idx]
diff = ext_utils.get_two_element_average(prcp)
nc_fid.close()
return diff, np.array(times[0:times_len - 1])
def create_rf_plots_wrf(nc_f, plots_output_dir, plots_output_base_dir, lon_min=None, lat_min=None, lon_max=None,
lat_max=None, filter_threshold=0.05, run_prefix='WRF'):
if not all([lon_min, lat_min, lon_max, lat_max]):
lon_min, lat_min, lon_max, lat_max = constants.SRI_LANKA_EXTENT
variables = ext_utils.extract_variables(nc_f, 'RAINC, RAINNC', lat_min, lat_max, lon_min, lon_max)
lats = variables['XLAT']
lons = variables['XLONG']
# cell size is calc based on the mean between the lat and lon points
cz = np.round(np.mean(np.append(lons[1:len(lons)] - lons[0: len(lons) - 1], lats[1:len(lats)]
- lats[0: len(lats) - 1])), 3)
clevs = [0, 1, 2.5, 5, 7.5, 10, 15, 20, 30, 40, 50, 70, 100, 150, 200, 250, 300, 400, 500, 600, 750]
cmap = cm.s3pcpn
basemap = Basemap(projection='merc', llcrnrlon=lon_min, llcrnrlat=lat_min, urcrnrlon=lon_max,
urcrnrlat=lat_max, resolution='h')
data = variables['RAINC'] + variables['RAINNC']
logging.info('Filtering with the threshold %f' % filter_threshold)
data[data < filter_threshold] = 0.0
variables['PRECIP'] = data
prefix = 'wrf_plots'
with TemporaryDirectory(prefix=prefix) as temp_dir:
t0 = dt.datetime.strptime(variables['Times'][0], '%Y-%m-%d_%H:%M:%S')
t1 = dt.datetime.strptime(variables['Times'][1], '%Y-%m-%d_%H:%M:%S')
step = (t1 - t0).total_seconds() / 3600.0
inst_precip = ext_utils.get_two_element_average(variables['PRECIP'])
cum_precip = ext_utils.get_two_element_average(variables['PRECIP'], return_diff=False)
for i in range(1, len(variables['Times'])):
time = variables['Times'][i]
ts = dt.datetime.strptime(time, '%Y-%m-%d_%H:%M:%S')
lk_ts = utils.datetime_utc_to_lk(ts, shift_mins=30)
logging.info('processing %s', time)
# instantaneous precipitation (hourly)
inst_file = os.path.join(temp_dir, 'wrf_inst_' + lk_ts.strftime('%Y-%m-%d_%H:%M:%S'))
ext_utils.create_asc_file(np.flip(inst_precip[i - 1], 0), lats, lons, inst_file + '.asc', cell_size=cz)
title = {
'label': 'Hourly rf for %s LK' % lk_ts.strftime('%Y-%m-%d_%H:%M:%S'),
'fontsize': 30
}
ext_utils.create_contour_plot(inst_precip[i - 1], inst_file + '.png', lat_min, lon_min, lat_max, lon_max,
title, clevs=clevs, cmap=cmap, basemap=basemap)
if (i * step) % 24 == 0:
t = 'Daily rf from %s LK to %s LK' % (
(lk_ts - dt.timedelta(hours=24)).strftime('%Y-%m-%d_%H:%M:%S'), lk_ts.strftime('%Y-%m-%d_%H:%M:%S'))
d = int(i * step / 24) - 1
logging.info('Creating images for D%d' % d)
cum_file = os.path.join(temp_dir, 'wrf_cum_%dd' % d)
if i * step / 24 > 1:
cum_precip_24h = cum_precip[i - 1] - cum_precip[i - 1 - int(24 / step)]
else:
cum_precip_24h = cum_precip[i - 1]
ext_utils.create_asc_file(np.flip(cum_precip_24h, 0), lats, lons, cum_file + '.asc', cell_size=cz)
ext_utils.create_contour_plot(cum_precip_24h, cum_file + '.png', lat_min, lon_min, lat_max, lon_max, t,
clevs=clevs, cmap=cmap, basemap=basemap)
gif_file = os.path.join(temp_dir, 'wrf_inst_%dd' % d)
images = [os.path.join(temp_dir, 'wrf_inst_' + j.strftime('%Y-%m-%d_%H:%M:%S') + '.png') for j in
np.arange(lk_ts - dt.timedelta(hours=24 - step), lk_ts + dt.timedelta(hours=step),
dt.timedelta(hours=step)).astype(dt.datetime)]
ext_utils.create_gif(images, gif_file + '.gif')
logging.info('Creating the zips')
utils.create_zip_with_prefix(temp_dir, '*.png', os.path.join(temp_dir, 'pngs.zip'))
utils.create_zip_with_prefix(temp_dir, '*.asc', os.path.join(temp_dir, 'ascs.zip'))
logging.info('Cleaning up instantaneous pngs and ascs - wrf_inst_*')
utils.delete_files_with_prefix(temp_dir, 'wrf_inst_*.png')
utils.delete_files_with_prefix(temp_dir, 'wrf_inst_*.asc')
logging.info('Copying pngs to ' + plots_output_dir)
utils.move_files_with_prefix(temp_dir, '*.png', plots_output_dir)
logging.info('Copying ascs to ' + plots_output_dir)
utils.move_files_with_prefix(temp_dir, '*.asc', plots_output_dir)
logging.info('Copying gifs to ' + plots_output_dir)
utils.copy_files_with_prefix(temp_dir, '*.gif', plots_output_dir)
logging.info('Copying zips to ' + plots_output_dir)
utils.copy_files_with_prefix(temp_dir, '*.zip', plots_output_dir)
plots_latest_dir = os.path.join(plots_output_base_dir, 'latest', run_prefix, os.path.basename(plots_output_dir))
# <nfs>/latest/wrf0 .. 3
utils.create_dir_if_not_exists(plots_latest_dir)
# todo: this needs to be adjusted to handle the multiple runs
logging.info('Copying gifs to ' + plots_latest_dir)
utils.copy_files_with_prefix(temp_dir, '*.gif', plots_latest_dir)
def push_wrf_rainfall_to_db(nc_f, curw_db_adapter=None, lon_min=None, lat_min=None, lon_max=None,
lat_max=None, run_prefix='WRF', upsert=False, run_name='Cloud-1', station_prefix='wrf'):
"""
:param run_name:
:param nc_f:
:param curw_db_adapter: If not none, data will be pushed to the db
:param run_prefix:
:param lon_min:
:param lat_min:
:param lon_max:
:param lat_max:
:param upsert:
:return:
"""
if curw_db_adapter is None:
logging.info('curw_db_adapter not available. Unable to push data!')
return
if not all([lon_min, lat_min, lon_max, lat_max]):
lon_min, lat_min, lon_max, lat_max = constants.SRI_LANKA_EXTENT
nc_vars = ext_utils.extract_variables(nc_f, ['RAINC', 'RAINNC'], lat_min, lat_max, lon_min, lon_max)
lats = nc_vars['XLAT']
lons = nc_vars['XLONG']
prcp = nc_vars['RAINC'] + nc_vars['RAINNC']
times = nc_vars['Times']
diff = ext_utils.get_two_element_average(prcp)
width = len(lons)
height = len(lats)
def random_check_stations_exist():
for _ in range(10):
_x = lons[int(random() * width)]
_y = lats[int(random() * height)]
_name = '%s_%.6f_%.6f' % (station_prefix, _x, _y)
_query = {'name': _name}
if curw_db_adapter.get_station(_query) is None:
logging.debug('Random stations check fail')
return False
logging.debug('Random stations check success')
return True
stations_exists = random_check_stations_exist()
rf_ts = {}
for y in range(height):
for x in range(width):
lat = lats[y]
lon = lons[x]
station_id = '%s_%.6f_%.6f' % (station_prefix, lon, lat)
name = station_id
if not stations_exists:
logging.info('Creating station %s ...' % name)
station = [Station.WRF, station_id, name, str(lon), str(lat), str(0), "WRF point"]
curw_db_adapter.create_station(station)
# add rf series to the dict
ts = []
for i in range(len(diff)):
t = utils.datetime_utc_to_lk(dt.datetime.strptime(times[i], '%Y-%m-%d_%H:%M:%S'), shift_mins=30)
ts.append([t.strftime('%Y-%m-%d %H:%M:%S'), diff[i, y, x]])
rf_ts[name] = ts
ext_utils.push_rainfall_to_db(curw_db_adapter, rf_ts, source=run_prefix, upsert=upsert, name=run_name)
def extract_metro_colombo(nc_f, wrf_output, wrf_output_base, curw_db_adapter=None, curw_db_upsert=False,
run_prefix='WRF', run_name='Cloud-1'):
"""
extract Metro-Colombo rf and divide area into to 4 quadrants
:param wrf_output_base:
:param run_name:
:param nc_f:
:param wrf_output:
:param curw_db_adapter: If not none, data will be pushed to the db
:param run_prefix:
:param curw_db_upsert:
:return:
"""
prefix = 'met_col'
lon_min, lat_min, lon_max, lat_max = constants.COLOMBO_EXTENT
nc_vars = ext_utils.extract_variables(nc_f, ['RAINC', 'RAINNC'], lat_min, lat_max, lon_min, lon_max)
lats = nc_vars['XLAT']
lons = nc_vars['XLONG']
prcp = nc_vars['RAINC'] + nc_vars['RAINNC']
times = nc_vars['Times']
diff = ext_utils.get_two_element_average(prcp)
width = len(lons)
height = len(lats)
output_dir = utils.create_dir_if_not_exists(os.path.join(wrf_output, prefix))
basin_rf = np.mean(diff[0:(len(times) - 1 if len(times) < 24 else 24), :, :])
alpha_file_path = os.path.join(wrf_output_base, prefix + '_alphas.txt')
utils.create_dir_if_not_exists(os.path.dirname(alpha_file_path))
with open(alpha_file_path, 'a+') as alpha_file:
t = utils.datetime_utc_to_lk(dt.datetime.strptime(times[0], '%Y-%m-%d_%H:%M:%S'), shift_mins=30)
alpha_file.write('%s\t%f\n' % (t.strftime('%Y-%m-%d_%H:%M:%S'), basin_rf))
cz = ext_utils.get_mean_cell_size(lats, lons)
no_data = -99
divs = (2, 2)
div_rf = {}
for i in range(divs[0] * divs[1]):
div_rf[prefix + str(i)] = []
with TemporaryDirectory(prefix=prefix) as temp_dir:
subsection_file_path = os.path.join(temp_dir, 'sub_means.txt')
with open(subsection_file_path, 'w') as subsection_file:
for tm in range(0, len(times) - 1):
t_str = (
utils.datetime_utc_to_lk(dt.datetime.strptime(times[tm], '%Y-%m-%d_%H:%M:%S'),
shift_mins=30)).strftime('%Y-%m-%d %H:%M:%S')
output_file_path = os.path.join(temp_dir, 'rf_' + t_str.replace(' ', '_') + '.asc')
ext_utils.create_asc_file(np.flip(diff[tm, :, :], 0), lats, lons, output_file_path, cell_size=cz,
no_data_val=no_data)
# writing subsection file
x_idx = [round(i * width / divs[0]) for i in range(0, divs[0] + 1)]
y_idx = [round(i * height / divs[1]) for i in range(0, divs[1] + 1)]
subsection_file.write(t_str)
for j in range(len(y_idx) - 1):
for i in range(len(x_idx) - 1):
quad = j * divs[1] + i
sub_sec_mean = np.mean(diff[tm, y_idx[j]:y_idx[j + 1], x_idx[i]: x_idx[i + 1]])
subsection_file.write('\t%.4f' % sub_sec_mean)
div_rf[prefix + str(quad)].append([t_str, sub_sec_mean])
subsection_file.write('\n')
utils.create_zip_with_prefix(temp_dir, 'rf_*.asc', os.path.join(temp_dir, 'ascs.zip'), clean_up=True)
utils.move_files_with_prefix(temp_dir, '*', output_dir)
# writing to the database
if curw_db_adapter is not None:
for i in range(divs[0] * divs[1]):
name = prefix + str(i)
station = [Station.CUrW, name, name, -999, -999, 0, "met col quadrant %d" % i]
if ext_utils.create_station_if_not_exists(curw_db_adapter, station):
logging.info('%s station created' % name)
logging.info('Pushing data to the db...')
ext_utils.push_rainfall_to_db(curw_db_adapter, div_rf, upsert=curw_db_upsert, source=run_prefix, name=run_name)
else:
logging.info('curw_db_adapter not available. Unable to push data!')
return basin_rf