def create_output_dir(settings):
"""
Create the output directories and files needed to processes wateruse.
Parameters
----------
settings : dictionary
Dictionary of user settings
Returns
-------
map_dir : string
string path to map directory
Notes
-----
Uses settings set in user_settings.py
"""
# create output directories
map_dir = helpers.make_directory(path = settings["simulation_directory"], directory_name = settings["map_directory_name"])
# print input and output information
helpers.print_input_output_info(
input_dict = {"simulation_directory": settings["simulation_directory"],
"map_directory_name": settings["map_directory_name"],
},
output_dict = {" map_dir": map_dir}
)
return map_dir
def write_ecoflow_file_stationid(file_list, dir_name, file_name, parameter_name = "Discharge + Water Use"):
"""
Write a csv file containing a timeseries for a particular parameter contained in a WATER.txt file
Parameters
----------
file_list : list
List of WATER.txt files to process
dir_name : string
String name for output directory
file_name : string
String name for output file
parameter_name : string
String name for a parameter contained in a WATER.txt file
"""
for f in file_list:
filedir, filename = helpers.get_file_info(f)
ecoflow_dir = helpers.make_directory(path = filedir, directory_name = dir_name)
helpers.print_input_output_info(input_dict = {"input_file": f}, output_dict = {"output_directory": ecoflow_dir})
waterapputils_logging.initialize_loggers(output_dir = ecoflow_dir)
watertxt_data = watertxt.read_file(f)
# write timeseries of discharge + water use for ecoflow program
watertxt.write_timeseries_file_stationid(watertxt_data, name = parameter_name, save_path = ecoflow_dir, filename = file_name, stationid = watertxt_data["stationid"])
waterapputils_logging.remove_loggers()
def create_output_dirs_files(settings, is_sub_gcm_delta=False):
"""
Create the output directories and files needed to processes wateruse.
Parameters
----------
settings : dictionary
Dictionary of user settings
Returns
-------
info_dir : string
string path to info directory
gcm_delta_dir : string
string path to ecoflow directory
info_file : string
string path to info file
Notes
-----
Uses settings set in user_settings.py
"""
# create output directories
info_dir = helpers.make_directory(
path=settings["simulation_directory"],
directory_name=settings["info_directory_name"])
gcm_delta_dir = helpers.make_directory(
path=settings["simulation_directory"],
directory_name=settings["gcm_delta_directory_name"])
# path to info file
if is_sub_gcm_delta:
info_file = os.path.join(info_dir,
settings["sub_gcm_delta_info_file_name"])
else:
info_file = os.path.join(info_dir,
settings["gcm_delta_info_file_name"])
# print input and output information
helpers.print_input_output_info(input_dict={
"simulation_directory":
settings["simulation_directory"],
"gcm_delta_prepend_name":
settings["gcm_delta_prepend_name"],
"gcm_delta_directory_name":
settings["gcm_delta_directory_name"],
"gcm_delta_info_file_name":
settings["gcm_delta_info_file_name"],
"gcm_delta_non_intersecting_file_name":
settings["gcm_delta_non_intersecting_file_name"],
"sub_gcm_delta_info_file_name":
settings["sub_gcm_delta_info_file_name"],
},
output_dict={
"info_dir": info_dir,
"info_file": info_file,
"gcm_delta_dir": gcm_delta_dir
})
return info_dir, gcm_delta_dir, info_file
def create_output_dir(settings):
"""
Create the output directories and files needed to processes wateruse.
Parameters
----------
settings : dictionary
Dictionary of user settings
Returns
-------
map_dir : string
string path to map directory
Notes
-----
Uses settings set in user_settings.py
"""
# create output directories
map_dir = helpers.make_directory(
path=settings["simulation_directory"],
directory_name=settings["map_directory_name"])
# print input and output information
helpers.print_input_output_info(input_dict={
"simulation_directory":
settings["simulation_directory"],
"map_directory_name":
settings["map_directory_name"],
},
output_dict={" map_dir": map_dir})
return map_dir
def write_oasis_file(file_list, dir_name, file_name):
for f in file_list:
filedir, filename = helpers.get_file_info(f)
oasis_dir = helpers.make_directory(path=filedir,
directory_name=dir_name)
helpers.print_input_output_info(
input_dict={"input_file": f},
output_dict={"output_directory": oasis_dir})
waterapputils_logging.initialize_loggers(output_dir=oasis_dir)
watertxt_data = watertxt.read_file(f)
# write timeseries of discharge + water use for OASIS
watertxt.write_timeseries_file(
watertxt_data=watertxt_data,
name="Discharge + Water Use",
save_path=oasis_dir,
filename="-".join([watertxt_data["stationid"], file_name]))
waterapputils_logging.remove_loggers()
def write_ecoflow_file_drainageareaxml(file_list, dir_name, file_name):
"""
Write a csv file containing a label (basin id number) and its corresponding area.
Parameters
----------
file_list : list
List of WATERSimulation.xml files to process
dir_name : string
String name for output directory
file_name : string
String name for output file
"""
area_data = {}
for f in file_list:
filedir, filename = helpers.get_file_info(f)
ecoflow_dir = helpers.make_directory(path=filedir,
directory_name=dir_name)
helpers.print_input_output_info(
input_dict={"input_file": f},
output_dict={"output_directory": ecoflow_dir})
waterapputils_logging.initialize_loggers(output_dir=ecoflow_dir)
# read xml file
waterxml_tree = waterxml.read_file(f)
# get area from each region from the xml file and sum for a total area
project, study, simulation = waterxml.get_xml_data(
waterxml_tree=waterxml_tree)
# get the project name which is the same as the stationid
stationid = project["ProjName"]
# get the area means for each region
areas = waterxml.get_study_unit_areas(simulation_dict=simulation)
# calculate total area
total_area = waterxml.calc_total_study_unit_areas(areas)
# fill area_data with total area
area_data[stationid] = total_area
# convert from km**2 to mi**2
area_data = helpers.convert_area_values(area_data,
in_units="km2",
out_units="mi2")
# write timeseries of dishcarge + water use for ecoflow program
watertxt.write_drainagearea_file(area_data=area_data,
save_path=ecoflow_dir,
filename=file_name)
waterapputils_logging.remove_loggers()
def write_ecoflow_file_drainageareashp(file_list, dir_name, file_name,
label_field, query_field):
"""
Write a csv file containing a label (basin id number) and its corresponding area.
Two methods to get the area from each respective shapefile:
1. if shapefile(s) has an area field and user specifies it in user_settings.py
under the *basin_shapefile_area_field* variable then get the area for each
basin using the specified area field name (query_field)
2. if shapefile(s) do not have an area field or user does not specify is in
user_settings.py, then calculate it using osgeo and label each basin according
to *basin_shapefile_id_field* in user_settings.py
Parameters
----------
file_list : list
List of files to process; files are shapefiles
settings : dictionary
Dictionary of user settings
label_field : string
String name of an id field (basin id number) to associate with a basin
query_field : string
String name of an area field
Notes
-----
Uses settings set in user_settings.py
"""
for f in file_list:
filedir, filename = helpers.get_file_info(f)
ecoflow_dir = helpers.make_directory(path=filedir,
directory_name=dir_name)
waterapputils_logging.initialize_loggers(output_dir=ecoflow_dir)
helpers.print_input_output_info(
input_dict={"input_file": f},
output_dict={"output_directory": ecoflow_dir})
basin_shapefile = osgeo.ogr.Open(f)
# get the areas for each region
areas = spatialvectors.get_areas_dict(shapefile=basin_shapefile,
id_field=label_field,
query_field=query_field)
# write timeseries of dishcarge + water use for ecoflow program
watertxt.write_drainagearea_file(area_data=areas,
save_path=ecoflow_dir,
filename=file_name)
waterapputils_logging.remove_loggers()
def process_water_files(file_list, settings, print_data=True):
"""
Process a list of WATER xml files according to options contained in arguments parameter.
Parameters
----------
file_list : list
List of files to parse, process, and plot.
arguments : argparse object
An argparse object containing user options.
"""
print("Processing WATER files ...\n")
for f in file_list:
ext = os.path.splitext(f)[1]
assert ext == ".txt" or ext == ".xml", "Can not process file {}. File extension {} is not .txt or .xml".format(
f, ext)
filedir, filename = helpers.get_file_info(f)
if ext == ".txt":
output_dir = helpers.make_directory(
path=filedir,
directory_name=settings["watertxt_directory_name"])
helpers.print_input_output_info(
input_dict={"input_file": f},
output_dict={"output_directory": output_dir})
waterapputils_logging.initialize_loggers(output_dir=output_dir)
data = watertxt.read_file(f)
watertxt_viewer.plot_watertxt_data(data, save_path=output_dir)
if print_data:
watertxt_viewer.print_watertxt_data(data)
elif ext == ".xml":
output_dir = helpers.make_directory(
path=filedir,
directory_name=settings["waterxml_directory_name"])
waterapputils_logging.initialize_loggers(output_dir=output_dir)
helpers.print_input_output_info(
input_dict={"input_file": f},
output_dict={"output_directory": output_dir})
data = waterxml.read_file(f)
waterxml_viewer.plot_waterxml_timeseries_data(data,
save_path=output_dir)
waterxml_viewer.plot_waterxml_topographic_wetness_index_data(
data, save_path=output_dir)
if print_data:
waterxml_viewer.print_waterxml_data(data)
waterapputils_logging.remove_loggers()
def write_ecoflow_file_drainageareaxml(file_list, dir_name, file_name):
"""
Write a csv file containing a label (basin id number) and its corresponding area.
Parameters
----------
file_list : list
List of WATERSimulation.xml files to process
dir_name : string
String name for output directory
file_name : string
String name for output file
"""
area_data = {}
for f in file_list:
filedir, filename = helpers.get_file_info(f)
ecoflow_dir = helpers.make_directory(path = filedir, directory_name = dir_name)
helpers.print_input_output_info(input_dict = {"input_file": f}, output_dict = {"output_directory": ecoflow_dir})
waterapputils_logging.initialize_loggers(output_dir = ecoflow_dir)
# read xml file
waterxml_tree = waterxml.read_file(f)
# get area from each region from the xml file and sum for a total area
project, study, simulation = waterxml.get_xml_data(waterxml_tree = waterxml_tree)
# get the project name which is the same as the stationid
stationid = project["ProjName"]
# get the area means for each region
areas = waterxml.get_study_unit_areas(simulation_dict = simulation)
# calculate total area
total_area = waterxml.calc_total_study_unit_areas(areas)
# fill area_data with total area
area_data[stationid] = total_area
# convert from km**2 to mi**2
area_data = helpers.convert_area_values(area_data, in_units = "km2", out_units = "mi2")
# write timeseries of dishcarge + water use for ecoflow program
watertxt.write_drainagearea_file(area_data = area_data, save_path = ecoflow_dir, filename = file_name)
waterapputils_logging.remove_loggers()
def create_output_dirs_files(settings, is_sub_wateruse = False):
"""
Create the output directories and files needed to processes wateruse.
Parameters
----------
settings : dictionary
Dictionary of user settings
Returns
-------
info_dir : string
string path to info directory
ecoflow_dir : string
string path to ecoflow directory
oasis_dir : string
string path to oasis directory
info_file : string
string path to info file
Notes
-----
Uses settings set in user_settings.py
"""
# create output directories
info_dir = helpers.make_directory(path = settings["simulation_directory"], directory_name = settings["info_directory_name"])
ecoflow_dir = helpers.make_directory(path = settings["simulation_directory"], directory_name = settings["ecoflow_directory_name"])
oasis_dir = helpers.make_directory(path = settings["simulation_directory"], directory_name = settings["oasis_directory_name"])
# path to info file
if is_sub_wateruse:
info_file = os.path.join(info_dir, settings["sub_wateruse_info_file_name"])
else:
info_file = os.path.join(info_dir, settings["wateruse_info_file_name"])
# print input and output information
helpers.print_input_output_info(
input_dict = {"simulation_directory": settings["simulation_directory"],
"wateruse_prepend_name": settings["wateruse_prepend_name"],
"wateruse_directory_name": settings["wateruse_directory_name"],
"wateruse_info_file_name": settings["wateruse_info_file_name"],
"wateruse_non_intersecting_file_name": settings["wateruse_non_intersecting_file_name"],
"sub_wateruse_info_file_name": settings["sub_wateruse_info_file_name"],
},
output_dict = {"info_dir": info_dir, "info_file": info_file, "ecoflow_dir": ecoflow_dir, "oasis_dir": oasis_dir}
)
return info_dir, ecoflow_dir, oasis_dir, info_file
def write_ecoflow_file_drainageareashp(file_list, dir_name, file_name, label_field, query_field):
"""
Write a csv file containing a label (basin id number) and its corresponding area.
Two methods to get the area from each respective shapefile:
1. if shapefile(s) has an area field and user specifies it in user_settings.py
under the *basin_shapefile_area_field* variable then get the area for each
basin using the specified area field name (query_field)
2. if shapefile(s) do not have an area field or user does not specify is in
user_settings.py, then calculate it using osgeo and label each basin according
to *basin_shapefile_id_field* in user_settings.py
Parameters
----------
file_list : list
List of files to process; files are shapefiles
settings : dictionary
Dictionary of user settings
label_field : string
String name of an id field (basin id number) to associate with a basin
query_field : string
String name of an area field
Notes
-----
Uses settings set in user_settings.py
"""
for f in file_list:
filedir, filename = helpers.get_file_info(f)
ecoflow_dir = helpers.make_directory(path = filedir, directory_name = dir_name)
waterapputils_logging.initialize_loggers(output_dir = ecoflow_dir)
helpers.print_input_output_info(input_dict = {"input_file": f}, output_dict = {"output_directory": ecoflow_dir})
basin_shapefile = osgeo.ogr.Open(f)
# get the areas for each region
areas = spatialvectors.get_areas_dict(shapefile = basin_shapefile, id_field = label_field, query_field = query_field)
# write timeseries of dishcarge + water use for ecoflow program
watertxt.write_drainagearea_file(area_data = areas, save_path = ecoflow_dir, filename = file_name)
waterapputils_logging.remove_loggers()
def write_oasis_file(file_list, dir_name, file_name):
for f in file_list:
filedir, filename = helpers.get_file_info(f)
oasis_dir = helpers.make_directory(path = filedir, directory_name = dir_name)
helpers.print_input_output_info(input_dict = {"input_file": f}, output_dict = {"output_directory": oasis_dir})
waterapputils_logging.initialize_loggers(output_dir = oasis_dir)
watertxt_data = watertxt.read_file(f)
# write timeseries of discharge + water use for OASIS
watertxt.write_timeseries_file(watertxt_data = watertxt_data, name = "Discharge + Water Use", save_path = oasis_dir, filename = "-".join([watertxt_data["stationid"], file_name]))
waterapputils_logging.remove_loggers()
def process_water_files(file_list, settings, print_data=True):
"""
Process a list of WATER xml files according to options contained in arguments parameter.
Parameters
----------
file_list : list
List of files to parse, process, and plot.
arguments : argparse object
An argparse object containing user options.
"""
print("Processing WATER files ...\n")
for f in file_list:
ext = os.path.splitext(f)[1]
assert ext == ".txt" or ext == ".xml", "Can not process file {}. File extension {} is not .txt or .xml".format(
f, ext
)
filedir, filename = helpers.get_file_info(f)
if ext == ".txt":
output_dir = helpers.make_directory(path=filedir, directory_name=settings["watertxt_directory_name"])
helpers.print_input_output_info(input_dict={"input_file": f}, output_dict={"output_directory": output_dir})
waterapputils_logging.initialize_loggers(output_dir=output_dir)
data = watertxt.read_file(f)
watertxt_viewer.plot_watertxt_data(data, save_path=output_dir)
if print_data:
watertxt_viewer.print_watertxt_data(data)
elif ext == ".xml":
output_dir = helpers.make_directory(path=filedir, directory_name=settings["waterxml_directory_name"])
waterapputils_logging.initialize_loggers(output_dir=output_dir)
helpers.print_input_output_info(input_dict={"input_file": f}, output_dict={"output_directory": output_dir})
data = waterxml.read_file(f)
waterxml_viewer.plot_waterxml_timeseries_data(data, save_path=output_dir)
waterxml_viewer.plot_waterxml_topographic_wetness_index_data(data, save_path=output_dir)
if print_data:
waterxml_viewer.print_waterxml_data(data)
waterapputils_logging.remove_loggers()
def write_ecoflow_file_stationid(file_list,
dir_name,
file_name,
parameter_name="Discharge + Water Use"):
"""
Write a csv file containing a timeseries for a particular parameter contained in a WATER.txt file
Parameters
----------
file_list : list
List of WATER.txt files to process
dir_name : string
String name for output directory
file_name : string
String name for output file
parameter_name : string
String name for a parameter contained in a WATER.txt file
"""
for f in file_list:
filedir, filename = helpers.get_file_info(f)
ecoflow_dir = helpers.make_directory(path=filedir,
directory_name=dir_name)
helpers.print_input_output_info(
input_dict={"input_file": f},
output_dict={"output_directory": ecoflow_dir})
waterapputils_logging.initialize_loggers(output_dir=ecoflow_dir)
watertxt_data = watertxt.read_file(f)
# write timeseries of discharge + water use for ecoflow program
watertxt.write_timeseries_file_stationid(
watertxt_data,
name=parameter_name,
save_path=ecoflow_dir,
filename=file_name,
stationid=watertxt_data["stationid"])
waterapputils_logging.remove_loggers()
def process_cmp(file_list, settings, print_data=True):
"""
Compare two WATER text files according to options contained in arguments parameter.
Parameters
----------
file_list : list
List of files to parse, process, and plot.
arguments : argparse object
An argparse object containing user options.
"""
print("Comparing WATER files ...\n")
water_file1 = file_list[0]
water_file2 = file_list[1]
filedir1, filename1 = helpers.get_file_info(water_file1)
filedir2, filename2 = helpers.get_file_info(water_file2)
ext1 = os.path.splitext(filename1)[1]
ext2 = os.path.splitext(filename2)[1]
assert ext1 == ".txt" or ext1 == ".xml", "Can not process file {}. File extension {} is not .txt or .xml".format(
filename1, ext1)
assert ext2 == ".txt" or ext2 == ".xml", "Can not process file {}. File extension {} is not .txt or .xml".format(
filename2, ext2)
if ext1 == ".txt" and ext2 == ".txt":
output_dir = helpers.make_directory(
path=filedir1, directory_name=settings["watertxt_directory_name"])
helpers.print_input_output_info(
input_dict={
"input_file_1": water_file1,
"input_file_2": water_file2
},
output_dict={"output_directory": output_dir})
waterapputils_logging.initialize_loggers(output_dir=output_dir)
watertxt_data1 = watertxt.read_file(water_file1)
watertxt_data2 = watertxt.read_file(water_file2)
watertxt_viewer.plot_watertxt_comparison(watertxt_data1,
watertxt_data2,
save_path=output_dir)
if print_data:
watertxt_viewer.print_watertxt_data(watertxt_data1)
watertxt_viewer.print_watertxt_data(watertxt_data2)
elif ext1 == ".xml" and ext2 == ".xml":
output_dir = helpers.make_directory(
path=filedir1, directory_name=settings["waterxml_directory_name"])
helpers.print_input_output_info(
input_dict={
"input_file_1": water_file1,
"input_file_2": water_file2
},
output_dict={"output_directory": output_dir})
waterapputils_logging.initialize_loggers(output_dir=output_dir)
waterxml_data1 = waterxml.read_file(water_file1)
waterxml_data2 = waterxml.read_file(water_file2)
waterxml_viewer.plot_waterxml_timeseries_comparison(
waterxml_data1, waterxml_data2, save_path=output_dir)
if print_data:
waterxml_viewer.print_waterxml_data(waterxml_data1)
waterxml_viewer.print_waterxml_data(waterxml_data2)
else:
print(
"Can not process files {} and {}. File extensions {} and {} both need to be .txt or .xml"
.format(filename1, filename2, ext1, ext2))
waterapputils_logging.remove_loggers()
def process_cmp(file_list, settings, print_data=True):
"""
Compare two WATER text files according to options contained in arguments parameter.
Parameters
----------
file_list : list
List of files to parse, process, and plot.
arguments : argparse object
An argparse object containing user options.
"""
print("Comparing WATER files ...\n")
water_file1 = file_list[0]
water_file2 = file_list[1]
filedir1, filename1 = helpers.get_file_info(water_file1)
filedir2, filename2 = helpers.get_file_info(water_file2)
ext1 = os.path.splitext(filename1)[1]
ext2 = os.path.splitext(filename2)[1]
assert ext1 == ".txt" or ext1 == ".xml", "Can not process file {}. File extension {} is not .txt or .xml".format(
filename1, ext1
)
assert ext2 == ".txt" or ext2 == ".xml", "Can not process file {}. File extension {} is not .txt or .xml".format(
filename2, ext2
)
if ext1 == ".txt" and ext2 == ".txt":
output_dir = helpers.make_directory(path=filedir1, directory_name=settings["watertxt_directory_name"])
helpers.print_input_output_info(
input_dict={"input_file_1": water_file1, "input_file_2": water_file2},
output_dict={"output_directory": output_dir},
)
waterapputils_logging.initialize_loggers(output_dir=output_dir)
watertxt_data1 = watertxt.read_file(water_file1)
watertxt_data2 = watertxt.read_file(water_file2)
watertxt_viewer.plot_watertxt_comparison(watertxt_data1, watertxt_data2, save_path=output_dir)
if print_data:
watertxt_viewer.print_watertxt_data(watertxt_data1)
watertxt_viewer.print_watertxt_data(watertxt_data2)
elif ext1 == ".xml" and ext2 == ".xml":
output_dir = helpers.make_directory(path=filedir1, directory_name=settings["waterxml_directory_name"])
helpers.print_input_output_info(
input_dict={"input_file_1": water_file1, "input_file_2": water_file2},
output_dict={"output_directory": output_dir},
)
waterapputils_logging.initialize_loggers(output_dir=output_dir)
waterxml_data1 = waterxml.read_file(water_file1)
waterxml_data2 = waterxml.read_file(water_file2)
waterxml_viewer.plot_waterxml_timeseries_comparison(waterxml_data1, waterxml_data2, save_path=output_dir)
if print_data:
waterxml_viewer.print_waterxml_data(waterxml_data1)
waterxml_viewer.print_waterxml_data(waterxml_data2)
else:
print(
"Can not process files {} and {}. File extensions {} and {} both need to be .txt or .xml".format(
filename1, filename2, ext1, ext2
)
)
waterapputils_logging.remove_loggers()