Пример #1
0
def test_apply_factors():
    
    expected = {"q_dates": [np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)])],
                "p_dates": [np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)])],
                "t_dates": [np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)])],
                
                "q_values": [np.array([200.0, 220.0])],
                "p_values": [np.array([6, 9.])],
                "t_values": [np.array([13.1, 14.2])],           
            
                "q_units": ["mm per day"],
                "p_units": ["mm"],
                "t_units": ["Celsius"]
                }
    
    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(waterxml_tree = fixture["xml_tree1"], simulation_dict = simulation)

    q_dates, q_values, q_units = waterxml.get_timeseries_data(simulation_dict = simulation, timeseries_key = "StudyUnitDischargeSeries")
    p_dates, p_values, p_units = waterxml.get_timeseries_data(simulation_dict = simulation, timeseries_key = "ClimaticPrecipitationSeries")
    t_dates, t_values, t_units = waterxml.get_timeseries_data(simulation_dict = simulation, timeseries_key = "ClimaticTemperatureSeries")
    
    waterxml.apply_factors(waterxml_tree = fixture["xml_tree1"], element = "StudyUnitDischargeSeries", factors = fixture["factors"])
    waterxml.apply_factors(waterxml_tree = fixture["xml_tree1"], element = "ClimaticPrecipitationSeries", factors = fixture["factors"])
    waterxml.apply_factors(waterxml_tree = fixture["xml_tree1"], element = "ClimaticTemperatureSeries", factors = fixture["factors"])

    simulation_updated = waterxml.create_simulation_dict()

    simulation_updated = waterxml.fill_simulation_dict(waterxml_tree = fixture["xml_tree1"], simulation_dict = simulation_updated)
    
    actual = {}
    actual["q_dates"], actual["q_values"], actual["q_units"] = waterxml.get_timeseries_data(simulation_dict = simulation_updated, timeseries_key = "StudyUnitDischargeSeries")
    actual["p_dates"], actual["p_values"], actual["p_units"] = waterxml.get_timeseries_data(simulation_dict = simulation_updated, timeseries_key = "ClimaticPrecipitationSeries")
    actual["t_dates"], actual["t_values"], actual["t_units"] = waterxml.get_timeseries_data(simulation_dict = simulation_updated, timeseries_key = "ClimaticTemperatureSeries")

    nose.tools.assert_equals(len(expected["q_dates"]), len(actual["q_dates"]))
    nose.tools.assert_equals(len(expected["p_dates"]), len(actual["p_dates"]))
    nose.tools.assert_equals(len(expected["t_dates"]), len(actual["t_dates"]))

    np.testing.assert_equal(actual["q_dates"][0], expected["q_dates"][0])
    np.testing.assert_equal(actual["p_dates"][0], expected["p_dates"][0])
    np.testing.assert_equal(actual["t_dates"][0], expected["t_dates"][0])

    np.testing.assert_equal(actual["q_values"][0], expected["q_values"][0])
    np.testing.assert_equal(actual["p_values"][0], expected["p_values"][0])
    np.testing.assert_equal(actual["t_values"][0], expected["t_values"][0])

    np.testing.assert_equal(actual["q_units"][0], expected["q_units"][0])
    np.testing.assert_equal(actual["p_units"][0], expected["p_units"][0])
    np.testing.assert_equal(actual["t_units"][0], expected["t_units"][0])
Пример #2
0
def test_get_topographic_wetness_index_data_file1():

    expected = {
        "bin_ids": [np.array([1., 2.])],
        "bin_value_means": [np.array([3.1, 4.2])],
        "bin_value_fractions": [np.array([0.002, 0.005])]
    }

    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(
        waterxml_tree=fixture["xml_tree1"], simulation_dict=simulation)

    actual = {}
    actual["bin_ids"], actual["bin_value_means"], actual[
        "bin_value_fractions"] = waterxml.get_topographic_wetness_index_data(
            simulation_dict=simulation)

    nose.tools.assert_equals(len(actual["bin_ids"]), len(expected["bin_ids"]))
    nose.tools.assert_equals(len(actual["bin_value_means"]),
                             len(expected["bin_value_means"]))
    nose.tools.assert_equals(len(actual["bin_value_fractions"]),
                             len(expected["bin_value_fractions"]))

    np.testing.assert_equal(actual["bin_ids"][0], expected["bin_ids"][0])
    np.testing.assert_equal(actual["bin_value_means"][0],
                            expected["bin_value_means"][0])
    np.testing.assert_equal(actual["bin_value_fractions"][0],
                            expected["bin_value_fractions"][0])
Пример #3
0
def test_fill_simulation_dict():

    expected = {"SimulID": ["1"], "StudyID": ["1"], "RegionType": ["4"], 
                "SimulationFeatures": [[{"SimulID": "1", "AttCode": "1", "AttMinVal": "90.0", "AttName": "Study Unit Total Area", "AttUnits": "(sq Km)", "AttDescription": " Study unit total area", "AttUnitsCode": "303", "AttMaxVal": "110.0", "AttID": "1", "AttstdDev": "0", "AttMeanVal": "100.0"}, 
                                       {"SimulID": "1", "AttCode": "37", "AttMinVal": "4", "AttName": "Total Estimated Stream Area", "AttUnits": "(sq Km)", "AttDescription": "Estimated area of stream coverage", "AttUnitsCode": "303", "AttMaxVal": "6", "AttID": "2", "AttstdDev": "0", "AttMeanVal": "5"}]], 
                                        
                "SimulationTopographicWetnessIndex": [[{"BinID": "1", "SimulID": "1", "BinValueMean": "3.1", "BinValueFraction": "0.002"}, 
                                                       {"BinID": "2", "SimulID": "1", "BinValueMean": "4.2", "BinValueFraction": "0.005"}]],

                "StudyUnitDischargeSeries": [[{"SeriesID": "1", "SeriesDate": "2014-01-01T00:00:00-05:00", "SeriesUnitsCode": "54", "SimulID": "1", "SeriesValue": "100.0", "SeriesUnit": "mm per day"},
                                              {"SeriesID": "2", "SeriesDate": "2014-01-02T00:00:00-05:00", "SeriesUnitsCode": "54", "SimulID": "1", "SeriesValue": "110.0", "SeriesUnit": "mm per day"}]], 

                "ClimaticPrecipitationSeries": [[{"SeriesID": "1", "SeriesDate": "2014-01-01T00:00:00-05:00", "SeriesUnitsCode": "4", "SimulID": "1", "SeriesValue": "3.0", "SeriesUnit": "mm"},
                                                 {"SeriesID": "2", "SeriesDate": "2014-01-02T00:00:00-05:00", "SeriesUnitsCode": "4", "SimulID": "1", "SeriesValue": "4.5", "SeriesUnit": "mm"}]], 
                
                "ClimaticTemperatureSeries": [[{"SeriesID": "1", "SeriesDate": "2014-01-01T00:00:00-05:00", "SeriesUnitsCode": "31", "SimulID": "1", "SeriesValue": "11.1", "SeriesUnit": "Celsius"},
                                               {"SeriesID": "2", "SeriesDate": "2014-01-02T00:00:00-05:00", "SeriesUnitsCode": "31", "SimulID": "1", "SeriesValue": "12.2", "SeriesUnit": "Celsius"}]]
                }
    
    simulation = waterxml.create_simulation_dict()

    actual = waterxml.fill_simulation_dict(waterxml_tree = fixture["xml_tree1"], simulation_dict = simulation)
 
    nose.tools.assert_equals(actual["SimulID"], expected["SimulID"])
    nose.tools.assert_equals(actual["StudyID"], expected["StudyID"])
    nose.tools.assert_equals(actual["RegionType"], expected["RegionType"])
    nose.tools.assert_equals(actual["SimulationFeatures"], expected["SimulationFeatures"])
    nose.tools.assert_equals(actual["SimulationTopographicWetnessIndex"], expected["SimulationTopographicWetnessIndex"])
    nose.tools.assert_equals(actual["StudyUnitDischargeSeries"], expected["StudyUnitDischargeSeries"])    
    nose.tools.assert_equals(actual["ClimaticPrecipitationSeries"], expected["ClimaticPrecipitationSeries"]) 
    nose.tools.assert_equals(actual["ClimaticTemperatureSeries"], expected["ClimaticTemperatureSeries"])     
Пример #4
0
def test_get_study_unit_areas():

    expected = {"area_means": [np.array([100.])],
    }  

    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(waterxml_tree = fixture["xml_tree1"], simulation_dict = simulation)

    actual = {}
    actual["area_means"] = waterxml.get_study_unit_areas(simulation_dict = simulation)
    
    np.testing.assert_equal(actual["area_means"][0], expected["area_means"][0])
Пример #5
0
def test_get_timeseries_data_file2():

    expected = {"q_dates": [np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)]), np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)])],
                "p_dates": [np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)]), np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)])],
                "t_dates": [np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)]), np.array([datetime.datetime(2014, 1, 1, 0, 0), datetime.datetime(2014, 1, 2, 0, 0)])],
                
                "q_values": [np.array([100.0, 110.0]), np.array([100.0, 110.0])],
                "p_values": [np.array([3, 4.5]), np.array([3, 4.5])],
                "t_values": [np.array([11.1, 12.2]), np.array([11.1, 12.2])],           
            
                "q_units": ["mm per day", "mm per day"],
                "p_units": ["mm", "mm"],
                "t_units": ["Celsius", "Celsius"]
                }
    
    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(waterxml_tree = fixture["xml_tree2"], simulation_dict = simulation)

    actual = {}
    actual["q_dates"], actual["q_values"], actual["q_units"] = waterxml.get_timeseries_data(simulation_dict = simulation, timeseries_key = "StudyUnitDischargeSeries")
    actual["p_dates"], actual["p_values"], actual["p_units"] = waterxml.get_timeseries_data(simulation_dict = simulation, timeseries_key = "ClimaticPrecipitationSeries")
    actual["t_dates"], actual["t_values"], actual["t_units"] = waterxml.get_timeseries_data(simulation_dict = simulation, timeseries_key = "ClimaticTemperatureSeries")

    nose.tools.assert_equals(len(expected["q_dates"]), len(actual["q_dates"]))
    nose.tools.assert_equals(len(expected["p_dates"]), len(actual["p_dates"]))
    nose.tools.assert_equals(len(expected["t_dates"]), len(actual["t_dates"]))

    np.testing.assert_equal(actual["q_dates"][0], expected["q_dates"][0])
    np.testing.assert_equal(actual["p_dates"][0], expected["p_dates"][0])
    np.testing.assert_equal(actual["t_dates"][0], expected["t_dates"][0])

    np.testing.assert_equal(actual["q_values"][0], expected["q_values"][0])
    np.testing.assert_equal(actual["p_values"][0], expected["p_values"][0])
    np.testing.assert_equal(actual["t_values"][0], expected["t_values"][0])

    np.testing.assert_equal(actual["q_units"][0], expected["q_units"][0])
    np.testing.assert_equal(actual["p_units"][0], expected["p_units"][0])
    np.testing.assert_equal(actual["t_units"][0], expected["t_units"][0])

    np.testing.assert_equal(actual["q_dates"][1], expected["q_dates"][1])
    np.testing.assert_equal(actual["p_dates"][1], expected["p_dates"][1])
    np.testing.assert_equal(actual["t_dates"][1], expected["t_dates"][1])

    np.testing.assert_equal(actual["q_values"][1], expected["q_values"][1])
    np.testing.assert_equal(actual["p_values"][1], expected["p_values"][1])
    np.testing.assert_equal(actual["t_values"][1], expected["t_values"][1])

    np.testing.assert_equal(actual["q_units"][1], expected["q_units"][1])
    np.testing.assert_equal(actual["p_units"][1], expected["p_units"][1])
    np.testing.assert_equal(actual["t_units"][1], expected["t_units"][1])
Пример #6
0
def test_get_study_unit_areas():

    expected = {
        "area_means": [np.array([100.])],
    }

    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(
        waterxml_tree=fixture["xml_tree1"], simulation_dict=simulation)

    actual = {}
    actual["area_means"] = waterxml.get_study_unit_areas(
        simulation_dict=simulation)

    np.testing.assert_equal(actual["area_means"][0], expected["area_means"][0])
Пример #7
0
def test_get_topographic_wetness_index_data_file1():

    expected = {"bin_ids": [np.array([1., 2.])],
                "bin_value_means": [np.array([3.1, 4.2])],
                "bin_value_fractions": [np.array([0.002, 0.005])]}
    
    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(waterxml_tree = fixture["xml_tree1"], simulation_dict = simulation)

    actual = {}
    actual["bin_ids"], actual["bin_value_means"], actual["bin_value_fractions"] = waterxml.get_topographic_wetness_index_data(simulation_dict = simulation)

    nose.tools.assert_equals(len(actual["bin_ids"]), len(expected["bin_ids"]))
    nose.tools.assert_equals(len(actual["bin_value_means"]), len(expected["bin_value_means"]))
    nose.tools.assert_equals(len(actual["bin_value_fractions"]), len(expected["bin_value_fractions"]))

    np.testing.assert_equal(actual["bin_ids"][0], expected["bin_ids"][0])
    np.testing.assert_equal(actual["bin_value_means"][0], expected["bin_value_means"][0])
    np.testing.assert_equal(actual["bin_value_fractions"][0], expected["bin_value_fractions"][0])
Пример #8
0
def test_apply_factors():

    expected = {
        "q_dates": [
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ])
        ],
        "p_dates": [
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ])
        ],
        "t_dates": [
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ])
        ],
        "q_values": [np.array([200.0, 220.0])],
        "p_values": [np.array([6, 9.])],
        "t_values": [np.array([13.1, 14.2])],
        "q_units": ["mm per day"],
        "p_units": ["mm"],
        "t_units": ["Celsius"]
    }

    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(
        waterxml_tree=fixture["xml_tree1"], simulation_dict=simulation)

    q_dates, q_values, q_units = waterxml.get_timeseries_data(
        simulation_dict=simulation, timeseries_key="StudyUnitDischargeSeries")
    p_dates, p_values, p_units = waterxml.get_timeseries_data(
        simulation_dict=simulation,
        timeseries_key="ClimaticPrecipitationSeries")
    t_dates, t_values, t_units = waterxml.get_timeseries_data(
        simulation_dict=simulation, timeseries_key="ClimaticTemperatureSeries")

    waterxml.apply_factors(waterxml_tree=fixture["xml_tree1"],
                           element="StudyUnitDischargeSeries",
                           factors=fixture["factors"])
    waterxml.apply_factors(waterxml_tree=fixture["xml_tree1"],
                           element="ClimaticPrecipitationSeries",
                           factors=fixture["factors"])
    waterxml.apply_factors(waterxml_tree=fixture["xml_tree1"],
                           element="ClimaticTemperatureSeries",
                           factors=fixture["factors"])

    simulation_updated = waterxml.create_simulation_dict()

    simulation_updated = waterxml.fill_simulation_dict(
        waterxml_tree=fixture["xml_tree1"], simulation_dict=simulation_updated)

    actual = {}
    actual["q_dates"], actual["q_values"], actual[
        "q_units"] = waterxml.get_timeseries_data(
            simulation_dict=simulation_updated,
            timeseries_key="StudyUnitDischargeSeries")
    actual["p_dates"], actual["p_values"], actual[
        "p_units"] = waterxml.get_timeseries_data(
            simulation_dict=simulation_updated,
            timeseries_key="ClimaticPrecipitationSeries")
    actual["t_dates"], actual["t_values"], actual[
        "t_units"] = waterxml.get_timeseries_data(
            simulation_dict=simulation_updated,
            timeseries_key="ClimaticTemperatureSeries")

    nose.tools.assert_equals(len(expected["q_dates"]), len(actual["q_dates"]))
    nose.tools.assert_equals(len(expected["p_dates"]), len(actual["p_dates"]))
    nose.tools.assert_equals(len(expected["t_dates"]), len(actual["t_dates"]))

    np.testing.assert_equal(actual["q_dates"][0], expected["q_dates"][0])
    np.testing.assert_equal(actual["p_dates"][0], expected["p_dates"][0])
    np.testing.assert_equal(actual["t_dates"][0], expected["t_dates"][0])

    np.testing.assert_equal(actual["q_values"][0], expected["q_values"][0])
    np.testing.assert_equal(actual["p_values"][0], expected["p_values"][0])
    np.testing.assert_equal(actual["t_values"][0], expected["t_values"][0])

    np.testing.assert_equal(actual["q_units"][0], expected["q_units"][0])
    np.testing.assert_equal(actual["p_units"][0], expected["p_units"][0])
    np.testing.assert_equal(actual["t_units"][0], expected["t_units"][0])
Пример #9
0
def test_get_timeseries_data_file2():

    expected = {
        "q_dates": [
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ]),
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ])
        ],
        "p_dates": [
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ]),
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ])
        ],
        "t_dates": [
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ]),
            np.array([
                datetime.datetime(2014, 1, 1, 0, 0),
                datetime.datetime(2014, 1, 2, 0, 0)
            ])
        ],
        "q_values": [np.array([100.0, 110.0]),
                     np.array([100.0, 110.0])],
        "p_values": [np.array([3, 4.5]),
                     np.array([3, 4.5])],
        "t_values": [np.array([11.1, 12.2]),
                     np.array([11.1, 12.2])],
        "q_units": ["mm per day", "mm per day"],
        "p_units": ["mm", "mm"],
        "t_units": ["Celsius", "Celsius"]
    }

    simulation = waterxml.create_simulation_dict()

    simulation = waterxml.fill_simulation_dict(
        waterxml_tree=fixture["xml_tree2"], simulation_dict=simulation)

    actual = {}
    actual["q_dates"], actual["q_values"], actual[
        "q_units"] = waterxml.get_timeseries_data(
            simulation_dict=simulation,
            timeseries_key="StudyUnitDischargeSeries")
    actual["p_dates"], actual["p_values"], actual[
        "p_units"] = waterxml.get_timeseries_data(
            simulation_dict=simulation,
            timeseries_key="ClimaticPrecipitationSeries")
    actual["t_dates"], actual["t_values"], actual[
        "t_units"] = waterxml.get_timeseries_data(
            simulation_dict=simulation,
            timeseries_key="ClimaticTemperatureSeries")

    nose.tools.assert_equals(len(expected["q_dates"]), len(actual["q_dates"]))
    nose.tools.assert_equals(len(expected["p_dates"]), len(actual["p_dates"]))
    nose.tools.assert_equals(len(expected["t_dates"]), len(actual["t_dates"]))

    np.testing.assert_equal(actual["q_dates"][0], expected["q_dates"][0])
    np.testing.assert_equal(actual["p_dates"][0], expected["p_dates"][0])
    np.testing.assert_equal(actual["t_dates"][0], expected["t_dates"][0])

    np.testing.assert_equal(actual["q_values"][0], expected["q_values"][0])
    np.testing.assert_equal(actual["p_values"][0], expected["p_values"][0])
    np.testing.assert_equal(actual["t_values"][0], expected["t_values"][0])

    np.testing.assert_equal(actual["q_units"][0], expected["q_units"][0])
    np.testing.assert_equal(actual["p_units"][0], expected["p_units"][0])
    np.testing.assert_equal(actual["t_units"][0], expected["t_units"][0])

    np.testing.assert_equal(actual["q_dates"][1], expected["q_dates"][1])
    np.testing.assert_equal(actual["p_dates"][1], expected["p_dates"][1])
    np.testing.assert_equal(actual["t_dates"][1], expected["t_dates"][1])

    np.testing.assert_equal(actual["q_values"][1], expected["q_values"][1])
    np.testing.assert_equal(actual["p_values"][1], expected["p_values"][1])
    np.testing.assert_equal(actual["t_values"][1], expected["t_values"][1])

    np.testing.assert_equal(actual["q_units"][1], expected["q_units"][1])
    np.testing.assert_equal(actual["p_units"][1], expected["p_units"][1])
    np.testing.assert_equal(actual["t_units"][1], expected["t_units"][1])
Пример #10
0
def test_fill_simulation_dict():

    expected = {
        "SimulID": ["1"],
        "StudyID": ["1"],
        "RegionType": ["4"],
        "SimulationFeatures": [[{
            "SimulID": "1",
            "AttCode": "1",
            "AttMinVal": "90.0",
            "AttName": "Study Unit Total Area",
            "AttUnits": "(sq Km)",
            "AttDescription": " Study unit total area",
            "AttUnitsCode": "303",
            "AttMaxVal": "110.0",
            "AttID": "1",
            "AttstdDev": "0",
            "AttMeanVal": "100.0"
        }, {
            "SimulID": "1",
            "AttCode": "37",
            "AttMinVal": "4",
            "AttName": "Total Estimated Stream Area",
            "AttUnits": "(sq Km)",
            "AttDescription": "Estimated area of stream coverage",
            "AttUnitsCode": "303",
            "AttMaxVal": "6",
            "AttID": "2",
            "AttstdDev": "0",
            "AttMeanVal": "5"
        }]],
        "SimulationTopographicWetnessIndex": [[{
            "BinID": "1",
            "SimulID": "1",
            "BinValueMean": "3.1",
            "BinValueFraction": "0.002"
        }, {
            "BinID": "2",
            "SimulID": "1",
            "BinValueMean": "4.2",
            "BinValueFraction": "0.005"
        }]],
        "StudyUnitDischargeSeries": [[{
            "SeriesID": "1",
            "SeriesDate": "2014-01-01T00:00:00-05:00",
            "SeriesUnitsCode": "54",
            "SimulID": "1",
            "SeriesValue": "100.0",
            "SeriesUnit": "mm per day"
        }, {
            "SeriesID": "2",
            "SeriesDate": "2014-01-02T00:00:00-05:00",
            "SeriesUnitsCode": "54",
            "SimulID": "1",
            "SeriesValue": "110.0",
            "SeriesUnit": "mm per day"
        }]],
        "ClimaticPrecipitationSeries": [[{
            "SeriesID": "1",
            "SeriesDate": "2014-01-01T00:00:00-05:00",
            "SeriesUnitsCode": "4",
            "SimulID": "1",
            "SeriesValue": "3.0",
            "SeriesUnit": "mm"
        }, {
            "SeriesID": "2",
            "SeriesDate": "2014-01-02T00:00:00-05:00",
            "SeriesUnitsCode": "4",
            "SimulID": "1",
            "SeriesValue": "4.5",
            "SeriesUnit": "mm"
        }]],
        "ClimaticTemperatureSeries": [[{
            "SeriesID": "1",
            "SeriesDate": "2014-01-01T00:00:00-05:00",
            "SeriesUnitsCode": "31",
            "SimulID": "1",
            "SeriesValue": "11.1",
            "SeriesUnit": "Celsius"
        }, {
            "SeriesID": "2",
            "SeriesDate": "2014-01-02T00:00:00-05:00",
            "SeriesUnitsCode": "31",
            "SimulID": "1",
            "SeriesValue": "12.2",
            "SeriesUnit": "Celsius"
        }]]
    }

    simulation = waterxml.create_simulation_dict()

    actual = waterxml.fill_simulation_dict(waterxml_tree=fixture["xml_tree1"],
                                           simulation_dict=simulation)

    nose.tools.assert_equals(actual["SimulID"], expected["SimulID"])
    nose.tools.assert_equals(actual["StudyID"], expected["StudyID"])
    nose.tools.assert_equals(actual["RegionType"], expected["RegionType"])
    nose.tools.assert_equals(actual["SimulationFeatures"],
                             expected["SimulationFeatures"])
    nose.tools.assert_equals(actual["SimulationTopographicWetnessIndex"],
                             expected["SimulationTopographicWetnessIndex"])
    nose.tools.assert_equals(actual["StudyUnitDischargeSeries"],
                             expected["StudyUnitDischargeSeries"])
    nose.tools.assert_equals(actual["ClimaticPrecipitationSeries"],
                             expected["ClimaticPrecipitationSeries"])
    nose.tools.assert_equals(actual["ClimaticTemperatureSeries"],
                             expected["ClimaticTemperatureSeries"])