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()
Esempio n. 2
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 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_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()
Esempio n. 6
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_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_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 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 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()