Exemplo n.º 1
0
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
Exemplo n.º 4
0
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
Exemplo n.º 5
0
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()
Exemplo n.º 6
0
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()
Exemplo n.º 7
0
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()
Exemplo n.º 10
0
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()
Exemplo n.º 14
0
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()