def apply_sub_gcm_deltas(settings):
    """    
    Apply substitute gcm delta data to a WATERSimulation \*.xml file(s).  
    User supplies the gcm tiles to a text file that will be 
    contained in the info directory with a name specified in the user_settings.py file 

    Parameters
    ----------
    settings : dictionary
        Dictionary of user settings                 

    Notes
    -----
    Uses settings set in user_settings.py  
    """   

    # create output directories and files   
    info_dir, gcm_delta_dir, info_file = create_output_dirs_files(settings, is_sub_gcm_delta = True)

    # initialize error logging in info_dir
    waterapputils_logging.initialize_loggers(output_dir = info_dir) 

    # write all future print strings to the info_file
    sys.stdout = open(info_file, "w")  

    # get the intersecting points (centroids) based on wateruse non-intersecting_file
    intersecting_tiles = spatialvectors.read_field_values_file(filepath = os.path.join(info_dir, settings["gcm_delta_non_intersecting_file_name"]))

    # apply the wateruse     
    process_intersecting_centroids(intersecting_centroids, settings, gcm_delta_dir)

    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()
Example #3
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()
def apply_gcm_deltas(settings):
    """    
    Apply global climate model delta factor data to a WATERSimulation \*.xml file(s). 

    Parameters
    ----------
    settings : dictionary
        Dictionary of user settings                 

    Notes
    -----
    Uses settings set in user_settings.py  
    """   

	# create output directories and files   
    info_dir, gcm_delta_dir, info_file = create_output_dirs_files(settings)

    # initialize error logging in info_dir
    waterapputils_logging.initialize_loggers(output_dir = info_dir) 

    # write all future print strings to the info_file
    sys.stdout = open(info_file, "w")  
    
    # open shapefiles
    gcm_delta_tile_shapefile = osgeo.ogr.Open(settings["gcm_delta_tile_shapefile"]) 
    basin_shapefile = osgeo.ogr.Open(os.path.join(settings["simulation_directory"], settings["basin_shapefile_name"])) 

    # find intersecting points (centroids) based on water basin supplied
    intersecting_tiles_all = spatialvectors.get_intersected_field_values(intersector = basin_shapefile, intersectee = gcm_delta_tile_shapefile, intersectee_field = settings["gcm_delta_tile_shapefile_id_field"], intersector_field = settings["basin_shapefile_id_field"])

    intersecting_tiles, nonintersecting_tiles = spatialvectors.validate_field_values(field_values_dict = intersecting_tiles_all)     

    # apply gcm deltas
    if intersecting_tiles:    
        process_intersecting_tiles(intersecting_tiles, settings, gcm_delta_dir)

    # if no intersecting centroids, then warn the user and ask user to supply the water use points to a text file that will be contained in the info directory with a name specified in the user_settings.py file
    if nonintersecting_tiles:
        
        spatialvectors.write_field_values_file(filepath = info_dir, filename = settings["gcm_delta_non_intersecting_file_name"], field_values_dict = nonintersecting_tiles, field_id = "Tile")

        warn_str = "The following basin(s) do not intersect with the gcm delta tile shapefile:\n    {}\n\n    gcm delta tile shapefile: {}\n    basin shapefile: {}\n".format(nonintersecting_centroids, 
                                                                                                                                                                              settings["gcm_delta_tile_shapefile"] , 
                                                                                                                                                                              os.path.join(settings["simulation_directory"], settings["basin_shapefile_name"]))
        instruction_str1 = "Using gcm delta tile: 000. This special tile id specifies a delta factor of 0 for Tmax type (additive) and a delta factor of 1 for Ppt type (multiplicative).\n"
        instruction_str2 = "Writing the following gcm delta non intersecting file that specifies the non intersecting basin(s) with the gcm delta tiles:\n    {}\n".format(os.path.join(info_dir, settings["gcm_delta_non_intersecting_file_name"]))
        instruction_str3 = "To apply gcm delta factor(s) to the non intersecting basin(s), add tile ids (separated by commas) that you would like to use for each non intersecting basin to the gcm delta non intersecting non intersecting file."
        logging.warn("\n{}\n{}\n{}\n{}\n".format(warn_str, instruction_str1, instruction_str2, instruction_str3)) 

        # apply a delta factor of 0 for Tmax type (additive) and a delta factor of 1 for Ppt type (multiplicative)
        sub_intersecting_tiles = spatialvectors.read_field_values_file(filepath = os.path.join(info_dir, settings["gcm_delta_non_intersecting_file_name"]))

        # apply gcm deltas    
        process_intersecting_tiles(sub_intersecting_tiles, settings, gcm_delta_dir)        

    # create map of study area
    map_processing.create_simulation_map(settings = settings)

    # remove error logger
    waterapputils_logging.remove_loggers()
Example #5
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()
Example #6
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()
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()
Example #12
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 apply_sub_gcm_deltas(settings):
    """    
    Apply substitute gcm delta data to a WATERSimulation \*.xml file(s).  
    User supplies the gcm tiles to a text file that will be 
    contained in the info directory with a name specified in the user_settings.py file 

    Parameters
    ----------
    settings : dictionary
        Dictionary of user settings                 

    Notes
    -----
    Uses settings set in user_settings.py  
    """

    # create output directories and files
    info_dir, gcm_delta_dir, info_file = create_output_dirs_files(
        settings, is_sub_gcm_delta=True)

    # initialize error logging in info_dir
    waterapputils_logging.initialize_loggers(output_dir=info_dir)

    # write all future print strings to the info_file
    sys.stdout = open(info_file, "w")

    # get the intersecting points (centroids) based on wateruse non-intersecting_file
    intersecting_tiles = spatialvectors.read_field_values_file(
        filepath=os.path.join(
            info_dir, settings["gcm_delta_non_intersecting_file_name"]))

    # apply the wateruse
    process_intersecting_centroids(intersecting_centroids, settings,
                                   gcm_delta_dir)

    waterapputils_logging.remove_loggers()
def process_intersecting_centroids(intersecting_centroids, settings, ecoflow_dir, oasis_dir):
    """    
    Apply water use data to a WATER \*.txt file. The new file created is saved to the same
    directory as the \*.xml file.

    Parameters
    ----------
    intersecting_centroids : dictionary
        Dictionary containing lists of values for a particular field that were intersected by another shapefile.  
    settings : dictionary
        Dictionary of user settings
    ecoflow_dir : string
        String path to directory that will contain output specific for ecoflow program
    oasis_dir : string
        String path to directory that will contain output specific for oasis

    Notes
    -----
    Uses settings set in user_settings.py 
    """      
    # create a file for the output  
    for featureid, centroids in intersecting_centroids.iteritems():

        # get sum of the water use data
        if settings["wateruse_factor_file"]:
            total_wateruse_dict = wateruse.get_all_total_wateruse(wateruse_files = settings["wateruse_files"], id_list = centroids, wateruse_factor_file = settings["wateruse_factor_file"], in_cfs = True)

        else:
            total_wateruse_dict = wateruse.get_all_total_wateruse(wateruse_files = settings["wateruse_files"], id_list = centroids, wateruse_factor_file = None, in_cfs = True)

        # print monthly output in nice format to info file
        print("FeatureId: {}\n    Centroids: {}\n    Total Water Use:\n".format(featureid, centroids))  
        helpers.print_monthly_dict(monthly_dict = total_wateruse_dict)
       
        # get the txt data file that has a parent directory matching the current featureid
        if settings["is_batch_simulation"]:
            path = os.path.join(settings["simulation_directory"], featureid)
        else:
            path = settings["simulation_directory"]

        # find the WATER.txt file 
        watertxt_file = helpers.find_file(name = settings["water_text_file_name"], path = path)

        # get file info
        watertxt_dir, watertxt_filename = helpers.get_file_info(watertxt_file)       

        # create an output directory
        output_dir = helpers.make_directory(path = watertxt_dir, directory_name = settings["wateruse_directory_name"])
        
        # initialize error logging
        waterapputils_logging.initialize_loggers(output_dir = output_dir)

        # read the txt
        watertxt_data = watertxt.read_file(watertxt_file)            

        # apply water use
        watertxt_data = watertxt.apply_wateruse(watertxt_data, wateruse_totals = total_wateruse_dict) 

        # write updated txt
        watertxt_with_wateruse_file = settings["wateruse_prepend_name"] + watertxt_filename

        watertxt.write_file(watertxt_data = watertxt_data, save_path = output_dir, filename = watertxt_with_wateruse_file)              

        # plot 
        updated_watertxt_file = os.path.join(output_dir, watertxt_with_wateruse_file)
        water_files_processing.process_water_files(file_list = [updated_watertxt_file], settings = settings, print_data = True)

        # write timeseries of discharge + water use for OASIS
        watertxt.write_timeseries_file(watertxt_data = watertxt_data, name = settings["ecoflow_parameter_name"], save_path = oasis_dir, filename = "-".join([watertxt_data["stationid"], settings["oasis_file_name"]]))

        # write timeseries of dishcarge + water use for ecoflow program
        watertxt.write_timeseries_file_stationid(watertxt_data, name = settings["ecoflow_parameter_name"], save_path = ecoflow_dir, filename = "", stationid = watertxt_data["stationid"])
def apply_wateruse(settings):
    """    
    Apply water use data to WATER.txt file(s). 

    Parameters
    ----------
    settings : dictionary
        Dictionary of user settings                 

    Notes
    -----
    Uses settings set in user_settings.py  
    """   

	# create output directories and files   
    info_dir, ecoflow_dir, oasis_dir, info_file = create_output_dirs_files(settings)

    # initialize error logging in info_dir
    waterapputils_logging.initialize_loggers(output_dir = info_dir) 

    # write all future print strings to the info_file
    sys.stdout = open(info_file, "w")  
    
    # open shapefiles
    centroids_shapefile = osgeo.ogr.Open(settings["wateruse_centroids_shapefile"]) 
    basin_shapefile = osgeo.ogr.Open(os.path.join(settings["simulation_directory"], settings["basin_shapefile_name"])) 

    # find intersecting points (centroids) based on water basin supplied
    intersecting_centroids_all = spatialvectors.get_intersected_field_values(intersector = basin_shapefile, intersectee = centroids_shapefile, intersectee_field = settings["wateruse_centroids_shapefile_id_field"], intersector_field = settings["basin_shapefile_id_field"])

    intersecting_centroids, nonintersecting_centroids = spatialvectors.validate_field_values(field_values_dict = intersecting_centroids_all)     

    # apply water use
    if intersecting_centroids:    
        process_intersecting_centroids(intersecting_centroids, settings, ecoflow_dir, oasis_dir)

    # if no intersecting centroids, then warn the user and ask user to supply the water use points to a text file that will be contained in the info directory with a name specified in the user_settings.py file
    if nonintersecting_centroids:
        
        spatialvectors.write_field_values_file(filepath = info_dir, filename = settings["wateruse_non_intersecting_file_name"], field_values_dict = nonintersecting_centroids)

        warn_str = "The following basin(s) do not intersect with the water use centroids shapefile:\n    {}\n\n    centroids shapefile: {}\n    basin shapefile: {}\n".format(nonintersecting_centroids, 
                                                                                                                                                                     settings["wateruse_centroids_shapefile"] , 
                                                                                                                                                                     os.path.join(settings["simulation_directory"], settings["basin_shapefile_name"]))
        instruction_str1 = "Using water use centriod id: 000.  This special water use centroid id specifies 0 cubic feet per second water use.\n"
        instruction_str2 = "Writing the following wateruse non intersecting file that specifies the non intersecting basin(s) with the special water use centroid id:\n    {}\n".format(os.path.join(info_dir, settings["wateruse_non_intersecting_file_name"]))
        instruction_str3 = "To apply water use to the non intersecting basin(s), add centroid(s) ids (newhydroid) (separated by commas) that you would like to use for each non intersecting basin to the wateruse non intersecting file."
        logging.warn("\n{}\n{}\n{}\n{}\n".format(warn_str, instruction_str1, instruction_str2, instruction_str3)) 
        
        # apply 0 cfs water use using the special centroid id of 000 
        sub_intersecting_centroids = spatialvectors.read_field_values_file(filepath = os.path.join(info_dir, settings["wateruse_non_intersecting_file_name"]))

        # apply the wateruse     
        process_intersecting_centroids(sub_intersecting_centroids, settings, ecoflow_dir, oasis_dir)        

    # get the areas (in square miles) for each region 
    areas = spatialvectors.get_areas_dict(shapefile = basin_shapefile, id_field = settings["basin_shapefile_id_field"], query_field = settings["basin_shapefile_area_field"])

    # write the drainage area csv file for ecoflow program
    watertxt.write_drainagearea_file(area_data = areas, save_path = ecoflow_dir, filename = settings["ecoflow_drainage_area_file_name"])

    # create map of study area
    map_processing.create_simulation_map(settings = settings)

    # remove error logger
    waterapputils_logging.remove_loggers()
def apply_wateruse(settings):
    """    
    Apply water use data to WATER.txt file(s). 

    Parameters
    ----------
    settings : dictionary
        Dictionary of user settings                 

    Notes
    -----
    Uses settings set in user_settings.py  
    """

    # create output directories and files
    info_dir, ecoflow_dir, oasis_dir, info_file = create_output_dirs_files(
        settings)

    # initialize error logging in info_dir
    waterapputils_logging.initialize_loggers(output_dir=info_dir)

    # write all future print strings to the info_file
    sys.stdout = open(info_file, "w")

    # open shapefiles
    centroids_shapefile = osgeo.ogr.Open(
        settings["wateruse_centroids_shapefile"])
    basin_shapefile = osgeo.ogr.Open(
        os.path.join(settings["simulation_directory"],
                     settings["basin_shapefile_name"]))

    # find intersecting points (centroids) based on water basin supplied
    intersecting_centroids_all = spatialvectors.get_intersected_field_values(
        intersector=basin_shapefile,
        intersectee=centroids_shapefile,
        intersectee_field=settings["wateruse_centroids_shapefile_id_field"],
        intersector_field=settings["basin_shapefile_id_field"])

    intersecting_centroids, nonintersecting_centroids = spatialvectors.validate_field_values(
        field_values_dict=intersecting_centroids_all)

    # apply water use
    if intersecting_centroids:
        process_intersecting_centroids(intersecting_centroids, settings,
                                       ecoflow_dir, oasis_dir)

    # if no intersecting centroids, then warn the user and ask user to supply the water use points to a text file that will be contained in the info directory with a name specified in the user_settings.py file
    if nonintersecting_centroids:

        spatialvectors.write_field_values_file(
            filepath=info_dir,
            filename=settings["wateruse_non_intersecting_file_name"],
            field_values_dict=nonintersecting_centroids)

        warn_str = "The following basin(s) do not intersect with the water use centroids shapefile:\n    {}\n\n    centroids shapefile: {}\n    basin shapefile: {}\n".format(
            nonintersecting_centroids,
            settings["wateruse_centroids_shapefile"],
            os.path.join(settings["simulation_directory"],
                         settings["basin_shapefile_name"]))
        instruction_str1 = "Using water use centriod id: 000.  This special water use centroid id specifies 0 cubic feet per second water use.\n"
        instruction_str2 = "Writing the following wateruse non intersecting file that specifies the non intersecting basin(s) with the special water use centroid id:\n    {}\n".format(
            os.path.join(info_dir,
                         settings["wateruse_non_intersecting_file_name"]))
        instruction_str3 = "To apply water use to the non intersecting basin(s), add centroid(s) ids (newhydroid) (separated by commas) that you would like to use for each non intersecting basin to the wateruse non intersecting file."
        logging.warn("\n{}\n{}\n{}\n{}\n".format(warn_str, instruction_str1,
                                                 instruction_str2,
                                                 instruction_str3))

        # apply 0 cfs water use using the special centroid id of 000
        sub_intersecting_centroids = spatialvectors.read_field_values_file(
            filepath=os.path.join(
                info_dir, settings["wateruse_non_intersecting_file_name"]))

        # apply the wateruse
        process_intersecting_centroids(sub_intersecting_centroids, settings,
                                       ecoflow_dir, oasis_dir)

    # get the areas (in square miles) for each region
    areas = spatialvectors.get_areas_dict(
        shapefile=basin_shapefile,
        id_field=settings["basin_shapefile_id_field"],
        query_field=settings["basin_shapefile_area_field"])

    # write the drainage area csv file for ecoflow program
    watertxt.write_drainagearea_file(
        area_data=areas,
        save_path=ecoflow_dir,
        filename=settings["ecoflow_drainage_area_file_name"])

    # create map of study area
    map_processing.create_simulation_map(settings=settings)

    # remove error logger
    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_intersecting_tiles(intersecting_tiles, settings, gcm_delta_dir):
    """    
    Apply water use data to a WATER \*.txt file. The new file created is saved to the same
    directory as the \*.xml file.

    Parameters
    ----------
    intersecting_tiles : dictionary
        Dictionary containing lists of values for a particular field that were intersected by another shapefile.  
    settings : dictionary
        Dictionary of user settings
    gcm_delta_dir : string 
        string path to ecoflow directory

    Notes
    -----
    Uses settings set in user_settings.py 
    """      
    # create a file for the output  
    for featureid, tiles in intersecting_tiles.iteritems():

        # get monthly average gcm delta values
        deltas_data_list, deltas_avg_dict = deltas.get_deltas(delta_files = settings["gcm_delta_files"], tiles = tiles) 

        # print monthly output in nice format to info file
        print("FeatureId: {}\n    Tiles: {}\n    Average GCM Deltas:\n".format(featureid, tiles))  
        for key in deltas_avg_dict.keys():
            print("    {}\n".format(key))
            helpers.print_monthly_dict(monthly_dict = deltas_avg_dict[key])
       
        # get the txt data file that has a parent directory matching the current featureid
        if settings["is_batch_simulation"]:
            path = os.path.join(settings["simulation_directory"], featureid)
        else:
            path = settings["simulation_directory"]

        # find the WATERSimulation.xml and WATER.txt files
        waterxml_file = helpers.find_file(name = settings["water_database_file_name"], path = path)
        watertxt_file = helpers.find_file(name = settings["water_text_file_name"], path = path)

        # get file info
        waterxml_dir, waterxml_filename = helpers.get_file_info(waterxml_file)       
        watertxt_dir, watertxt_filename = helpers.get_file_info(watertxt_file)   

        # create an output directory
        output_dir = helpers.make_directory(path = waterxml_dir, directory_name = settings["gcm_delta_directory_name"])
        
        # initialize error logging
        waterapputils_logging.initialize_loggers(output_dir = output_dir)

        # read the xml file
        waterxml_tree = waterxml.read_file(waterxml_file) 
        watertxt_data = watertxt.read_file(watertxt_file)            

        # apply gcm delta
        for key, value in deltas_avg_dict.iteritems():
            if key == "Ppt":
                waterxml.apply_factors(waterxml_tree = waterxml_tree, element = "ClimaticPrecipitationSeries", factors = deltas_avg_dict[key])

            elif key == "Tmax":
                waterxml.apply_factors(waterxml_tree = waterxml_tree, element = "ClimaticTemperatureSeries", factors = deltas_avg_dict[key])

            elif key == "PET":
                watertxt.apply_factors(watertxt_data, name = "PET", factors = deltas_avg_dict[key], is_additive = False)

        # update the project name in the updated xml
        project = waterxml.create_project_dict() 
        project = waterxml.fill_dict(waterxml_tree = waterxml_tree, data_dict = project, element = "Project", keys = project.keys())
        waterxml.change_element_value(waterxml_tree = waterxml_tree, element = "Project", child = "ProjName" , new_value = settings["gcm_delta_prepend_name"] + project["ProjName"])

        # write updated xml
        waterxml_with_gcm_delta_file = settings["gcm_delta_prepend_name"] + waterxml_filename

        waterxml.write_file(waterxml_tree = waterxml_tree, save_path = output_dir, filename = waterxml_with_gcm_delta_file)              

        # write the pet timeseries file
        watertxt.write_timeseries_file(watertxt_data, name = "PET", save_path = output_dir, filename = settings["pet_timeseries_file_name"])

        # plot 
        updated_waterxml_file = os.path.join(output_dir, waterxml_with_gcm_delta_file)
        water_files_processing.process_water_files(file_list = [updated_waterxml_file ], settings = settings, print_data = False)
        water_files_processing.process_cmp(file_list = [updated_waterxml_file, waterxml_file], settings = settings, print_data = False)

    # plot the gcm deltas 
    for deltas_data in deltas_data_list:
        deltas_viewer.plot_deltas_data(deltas_data = deltas_data, save_path = helpers.make_directory(path = gcm_delta_dir, directory_name = settings["gcm_delta_directory_name"]))
def process_intersecting_centroids(intersecting_centroids, settings,
                                   ecoflow_dir, oasis_dir):
    """    
    Apply water use data to a WATER \*.txt file. The new file created is saved to the same
    directory as the \*.xml file.

    Parameters
    ----------
    intersecting_centroids : dictionary
        Dictionary containing lists of values for a particular field that were intersected by another shapefile.  
    settings : dictionary
        Dictionary of user settings
    ecoflow_dir : string
        String path to directory that will contain output specific for ecoflow program
    oasis_dir : string
        String path to directory that will contain output specific for oasis

    Notes
    -----
    Uses settings set in user_settings.py 
    """
    # create a file for the output
    for featureid, centroids in intersecting_centroids.iteritems():

        # get sum of the water use data
        if settings["wateruse_factor_file"]:
            total_wateruse_dict = wateruse.get_all_total_wateruse(
                wateruse_files=settings["wateruse_files"],
                id_list=centroids,
                wateruse_factor_file=settings["wateruse_factor_file"],
                in_cfs=True)

        else:
            total_wateruse_dict = wateruse.get_all_total_wateruse(
                wateruse_files=settings["wateruse_files"],
                id_list=centroids,
                wateruse_factor_file=None,
                in_cfs=True)

        # print monthly output in nice format to info file
        print(
            "FeatureId: {}\n    Centroids: {}\n    Total Water Use:\n".format(
                featureid, centroids))
        helpers.print_monthly_dict(monthly_dict=total_wateruse_dict)

        # get the txt data file that has a parent directory matching the current featureid
        if settings["is_batch_simulation"]:
            path = os.path.join(settings["simulation_directory"], featureid)
        else:
            path = settings["simulation_directory"]

        # find the WATER.txt file
        watertxt_file = helpers.find_file(
            name=settings["water_text_file_name"], path=path)

        # get file info
        watertxt_dir, watertxt_filename = helpers.get_file_info(watertxt_file)

        # create an output directory
        output_dir = helpers.make_directory(
            path=watertxt_dir,
            directory_name=settings["wateruse_directory_name"])

        # initialize error logging
        waterapputils_logging.initialize_loggers(output_dir=output_dir)

        # read the txt
        watertxt_data = watertxt.read_file(watertxt_file)

        # apply water use
        watertxt_data = watertxt.apply_wateruse(
            watertxt_data, wateruse_totals=total_wateruse_dict)

        # write updated txt
        watertxt_with_wateruse_file = settings[
            "wateruse_prepend_name"] + watertxt_filename

        watertxt.write_file(watertxt_data=watertxt_data,
                            save_path=output_dir,
                            filename=watertxt_with_wateruse_file)

        # plot
        updated_watertxt_file = os.path.join(output_dir,
                                             watertxt_with_wateruse_file)
        water_files_processing.process_water_files(
            file_list=[updated_watertxt_file],
            settings=settings,
            print_data=True)

        # write timeseries of discharge + water use for OASIS
        watertxt.write_timeseries_file(watertxt_data=watertxt_data,
                                       name=settings["ecoflow_parameter_name"],
                                       save_path=oasis_dir,
                                       filename="-".join([
                                           watertxt_data["stationid"],
                                           settings["oasis_file_name"]
                                       ]))

        # write timeseries of dishcarge + water use for ecoflow program
        watertxt.write_timeseries_file_stationid(
            watertxt_data,
            name=settings["ecoflow_parameter_name"],
            save_path=ecoflow_dir,
            filename="",
            stationid=watertxt_data["stationid"])
def apply_gcm_deltas(settings):
    """    
    Apply global climate model delta factor data to a WATERSimulation \*.xml file(s). 

    Parameters
    ----------
    settings : dictionary
        Dictionary of user settings                 

    Notes
    -----
    Uses settings set in user_settings.py  
    """

    # create output directories and files
    info_dir, gcm_delta_dir, info_file = create_output_dirs_files(settings)

    # initialize error logging in info_dir
    waterapputils_logging.initialize_loggers(output_dir=info_dir)

    # write all future print strings to the info_file
    sys.stdout = open(info_file, "w")

    # open shapefiles
    gcm_delta_tile_shapefile = osgeo.ogr.Open(
        settings["gcm_delta_tile_shapefile"])
    basin_shapefile = osgeo.ogr.Open(
        os.path.join(settings["simulation_directory"],
                     settings["basin_shapefile_name"]))

    # find intersecting points (centroids) based on water basin supplied
    intersecting_tiles_all = spatialvectors.get_intersected_field_values(
        intersector=basin_shapefile,
        intersectee=gcm_delta_tile_shapefile,
        intersectee_field=settings["gcm_delta_tile_shapefile_id_field"],
        intersector_field=settings["basin_shapefile_id_field"])

    intersecting_tiles, nonintersecting_tiles = spatialvectors.validate_field_values(
        field_values_dict=intersecting_tiles_all)

    # apply gcm deltas
    if intersecting_tiles:
        process_intersecting_tiles(intersecting_tiles, settings, gcm_delta_dir)

    # if no intersecting centroids, then warn the user and ask user to supply the water use points to a text file that will be contained in the info directory with a name specified in the user_settings.py file
    if nonintersecting_tiles:

        spatialvectors.write_field_values_file(
            filepath=info_dir,
            filename=settings["gcm_delta_non_intersecting_file_name"],
            field_values_dict=nonintersecting_tiles,
            field_id="Tile")

        warn_str = "The following basin(s) do not intersect with the gcm delta tile shapefile:\n    {}\n\n    gcm delta tile shapefile: {}\n    basin shapefile: {}\n".format(
            nonintersecting_centroids, settings["gcm_delta_tile_shapefile"],
            os.path.join(settings["simulation_directory"],
                         settings["basin_shapefile_name"]))
        instruction_str1 = "Using gcm delta tile: 000. This special tile id specifies a delta factor of 0 for Tmax type (additive) and a delta factor of 1 for Ppt type (multiplicative).\n"
        instruction_str2 = "Writing the following gcm delta non intersecting file that specifies the non intersecting basin(s) with the gcm delta tiles:\n    {}\n".format(
            os.path.join(info_dir,
                         settings["gcm_delta_non_intersecting_file_name"]))
        instruction_str3 = "To apply gcm delta factor(s) to the non intersecting basin(s), add tile ids (separated by commas) that you would like to use for each non intersecting basin to the gcm delta non intersecting non intersecting file."
        logging.warn("\n{}\n{}\n{}\n{}\n".format(warn_str, instruction_str1,
                                                 instruction_str2,
                                                 instruction_str3))

        # apply a delta factor of 0 for Tmax type (additive) and a delta factor of 1 for Ppt type (multiplicative)
        sub_intersecting_tiles = spatialvectors.read_field_values_file(
            filepath=os.path.join(
                info_dir, settings["gcm_delta_non_intersecting_file_name"]))

        # apply gcm deltas
        process_intersecting_tiles(sub_intersecting_tiles, settings,
                                   gcm_delta_dir)

    # create map of study area
    map_processing.create_simulation_map(settings=settings)

    # remove error logger
    waterapputils_logging.remove_loggers()
def process_intersecting_tiles(intersecting_tiles, settings, gcm_delta_dir):
    """    
    Apply water use data to a WATER \*.txt file. The new file created is saved to the same
    directory as the \*.xml file.

    Parameters
    ----------
    intersecting_tiles : dictionary
        Dictionary containing lists of values for a particular field that were intersected by another shapefile.  
    settings : dictionary
        Dictionary of user settings
    gcm_delta_dir : string 
        string path to ecoflow directory

    Notes
    -----
    Uses settings set in user_settings.py 
    """
    # create a file for the output
    for featureid, tiles in intersecting_tiles.iteritems():

        # get monthly average gcm delta values
        deltas_data_list, deltas_avg_dict = deltas.get_deltas(
            delta_files=settings["gcm_delta_files"], tiles=tiles)

        # print monthly output in nice format to info file
        print("FeatureId: {}\n    Tiles: {}\n    Average GCM Deltas:\n".format(
            featureid, tiles))
        for key in deltas_avg_dict.keys():
            print("    {}\n".format(key))
            helpers.print_monthly_dict(monthly_dict=deltas_avg_dict[key])

        # get the txt data file that has a parent directory matching the current featureid
        if settings["is_batch_simulation"]:
            path = os.path.join(settings["simulation_directory"], featureid)
        else:
            path = settings["simulation_directory"]

        # find the WATERSimulation.xml and WATER.txt files
        waterxml_file = helpers.find_file(
            name=settings["water_database_file_name"], path=path)
        watertxt_file = helpers.find_file(
            name=settings["water_text_file_name"], path=path)

        # get file info
        waterxml_dir, waterxml_filename = helpers.get_file_info(waterxml_file)
        watertxt_dir, watertxt_filename = helpers.get_file_info(watertxt_file)

        # create an output directory
        output_dir = helpers.make_directory(
            path=waterxml_dir,
            directory_name=settings["gcm_delta_directory_name"])

        # initialize error logging
        waterapputils_logging.initialize_loggers(output_dir=output_dir)

        # read the xml file
        waterxml_tree = waterxml.read_file(waterxml_file)
        watertxt_data = watertxt.read_file(watertxt_file)

        # apply gcm delta
        for key, value in deltas_avg_dict.iteritems():
            if key == "Ppt":
                waterxml.apply_factors(waterxml_tree=waterxml_tree,
                                       element="ClimaticPrecipitationSeries",
                                       factors=deltas_avg_dict[key])

            elif key == "Tmax":
                waterxml.apply_factors(waterxml_tree=waterxml_tree,
                                       element="ClimaticTemperatureSeries",
                                       factors=deltas_avg_dict[key])

            elif key == "PET":
                watertxt.apply_factors(watertxt_data,
                                       name="PET",
                                       factors=deltas_avg_dict[key],
                                       is_additive=False)

        # update the project name in the updated xml
        project = waterxml.create_project_dict()
        project = waterxml.fill_dict(waterxml_tree=waterxml_tree,
                                     data_dict=project,
                                     element="Project",
                                     keys=project.keys())
        waterxml.change_element_value(
            waterxml_tree=waterxml_tree,
            element="Project",
            child="ProjName",
            new_value=settings["gcm_delta_prepend_name"] + project["ProjName"])

        # write updated xml
        waterxml_with_gcm_delta_file = settings[
            "gcm_delta_prepend_name"] + waterxml_filename

        waterxml.write_file(waterxml_tree=waterxml_tree,
                            save_path=output_dir,
                            filename=waterxml_with_gcm_delta_file)

        # write the pet timeseries file
        watertxt.write_timeseries_file(
            watertxt_data,
            name="PET",
            save_path=output_dir,
            filename=settings["pet_timeseries_file_name"])

        # plot
        updated_waterxml_file = os.path.join(output_dir,
                                             waterxml_with_gcm_delta_file)
        water_files_processing.process_water_files(
            file_list=[updated_waterxml_file],
            settings=settings,
            print_data=False)
        water_files_processing.process_cmp(
            file_list=[updated_waterxml_file, waterxml_file],
            settings=settings,
            print_data=False)

    # plot the gcm deltas
    for deltas_data in deltas_data_list:
        deltas_viewer.plot_deltas_data(
            deltas_data=deltas_data,
            save_path=helpers.make_directory(
                path=gcm_delta_dir,
                directory_name=settings["gcm_delta_directory_name"]))
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()