示例#1
0
    def test_simulate_water_quality_2(self):
        """
        Test the water quality simulation in the presence of modifications.
        """
        census = {
            "cell_count": 2,
            "distribution": {"a:rock": {"cell_count": 1}, "a:water": {"cell_count": 1}},
            "modifications": [
                {"reclassification": "d:hi_residential", "cell_count": 1, "distribution": {"a:rock": {"cell_count": 1}}}
            ],
        }

        census1 = create_modified_census(census)
        census2 = {
            "cell_count": 2,
            "distribution": {"d:hi_residential": {"cell_count": 1}, "a:water": {"cell_count": 1}},
        }

        def fn(cell, cell_count):
            return simulate_cell_year(cell, cell_count, False)

        simulate_water_quality(census1, 93, fn)
        simulate_water_quality(census2, 93, fn)
        for key in set(census1.keys()) - set(["distribution"]):
            self.assertEqual(census1[key], census2[key])
示例#2
0
    def test_create_modified_census_2(self):
        """
        create_modified_census from a census w/ trivial modifications.
        """
        census = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {"cell_count": 2},
                "a:open_water": {"cell_count": 1}
            },
            "modifications": []
        }

        expected = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 2,
                    "distribution": {"a:barren_land": {"cell_count": 2}}
                },
                "a:open_water": {
                    "cell_count": 1,
                    "distribution": {"a:open_water": {"cell_count": 1}}
                }
            }
        }

        actual = create_modified_census(census)
        self.assertEqual(actual, expected)
示例#3
0
    def test_create_modified_census_3(self):
        """
        create_modified_census with a census tree non-trivial
        modifications.
        """
        census1 = {
            "cell_count": 144,
            "distribution": {"a:rock": {"cell_count": 55}, "a:water": {"cell_count": 89}},
            "modifications": [
                {"bmp": "cluster_housing", "cell_count": 34, "distribution": {"a:rock": {"cell_count": 34}}}
            ],
        }

        census2 = {
            "cell_count": 144,
            "distribution": {
                "a:rock": {
                    "cell_count": 55,
                    "distribution": {"a:cluster_housing": {"cell_count": 34}, "a:rock": {"cell_count": 21}},
                },
                "a:water": {"cell_count": 89},
            },
        }

        result = create_modified_census(census1)
        self.assertEqual(census2, result)
示例#4
0
    def test_create_modified_census_1(self):
        """
        create_modified_census with a census tree without modifications.
        """
        census = {"cell_count": 5, "distribution": {"a:rock": {"cell_count": 3}, "a:water": {"cell_count": 2}}}

        result = create_modified_census(census)
        census.pop("modifications", None)
        self.assertEqual(census, result)
示例#5
0
    def test_create_modified_census_3(self):
        """
        create_modified_census with non-trivial modifications.
        """
        census = {
            "cell_count":
            144,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 55
                },
                "a:open_water": {
                    "cell_count": 89
                }
            },
            "modifications": [{
                "change": "::cluster_housing",
                "cell_count": 34,
                "distribution": {
                    "a:barren_land": {
                        "cell_count": 34
                    }
                }
            }]
        }

        expected = {
            "cell_count": 144,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 55,
                    "distribution": {
                        "a:barren_land:cluster_housing": {
                            "cell_count": 34
                        },
                        "a:barren_land": {
                            "cell_count": 21
                        }
                    }
                },
                "a:open_water": {
                    "cell_count": 89,
                    "distribution": {
                        "a:open_water": {
                            "cell_count": 89
                        }
                    }
                }
            }
        }

        actual = create_modified_census(census)
        self.assertEqual(actual, expected)
示例#6
0
    def test_create_modified_census_4(self):
        """
        create_modified_census with different types of changes.
        """
        census = {
            "distribution": {
                "a:developed_low": {
                    "cell_count": 3
                }
            },
            "cell_count":
            3,
            "modifications": [
                {
                    "distribution": {
                        "a:developed_low": {
                            "cell_count": 1
                        }
                    },
                    "cell_count": 1,
                    "change": ":deciduous_forest:cluster_housing"
                },
                {
                    "distribution": {
                        "a:developed_low": {
                            "cell_count": 1
                        }
                    },
                    "cell_count": 1,
                    "change": ":deciduous_forest:"
                },
                {
                    "distribution": {
                        "a:developed_low": {
                            "cell_count": 1
                        }
                    },
                    "cell_count": 1,
                    "change": "::cluster_housing"
                },
            ]
        }

        expected = set([
            'a:deciduous_forest:', 'a:developed_low',
            'a:deciduous_forest:cluster_housing',
            'a:developed_low:cluster_housing'
        ])
        modified = create_modified_census(census)
        distrib = modified['distribution']['a:developed_low']['distribution']
        actual = set(distrib.keys())
        self.assertEqual(actual, expected)
示例#7
0
    def test_create_modified_census_4(self):
        """
        create_modified_census with different types of changes.
        """
        census = {
            "distribution": {
                "a:developed_low": {
                    "cell_count": 3
                }
            },
            "cell_count": 3,
            "modifications": [
                {
                    "distribution": {
                        "a:developed_low": {
                            "cell_count": 1
                        }
                    },
                    "cell_count": 1,
                    "change": ":deciduous_forest:cluster_housing"
                },
                {
                    "distribution": {
                        "a:developed_low": {
                            "cell_count": 1
                        }
                    },
                    "cell_count": 1,
                    "change": ":deciduous_forest:"
                },
                {
                    "distribution": {
                        "a:developed_low": {
                            "cell_count": 1
                        }
                    },
                    "cell_count": 1,
                    "change": "::cluster_housing"
                },
            ]
        }

        expected = set([
            'a:deciduous_forest:',
            'a:developed_low',
            'a:deciduous_forest:cluster_housing',
            'a:developed_low:cluster_housing'])
        modified = create_modified_census(census)
        distrib = modified['distribution']['a:developed_low']['distribution']
        actual = set(distrib.keys())
        self.assertEqual(actual, expected)
示例#8
0
    def test_create_modified_census_2(self):
        """
        create_modified_census with a census tree with trivial
        modifications.
        """
        census = {
            "cell_count": 3,
            "distribution": {"a:rock": {"cell_count": 2}, "a:water": {"cell_count": 1}},
            "modifications": [],
        }

        result = create_modified_census(census)
        census.pop("modifications", None)
        self.assertEqual(census, result)
示例#9
0
    def test_simulate_water_quality_2(self):
        """
        Test the water quality simulation in the presence of modifications.
        """
        census = {
            "cell_count":
            3,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 2
                },
                "a:open_water": {
                    "cell_count": 1
                }
            },
            "modifications": [{
                "change": "d:developed_med:",
                "cell_count": 1,
                "distribution": {
                    "a:barren_land": {
                        "cell_count": 1
                    }
                }
            }]
        }

        census1 = create_modified_census(census)
        census2 = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 1
                },
                "d:developed_med": {
                    "cell_count": 1
                },
                "a:open_water": {
                    "cell_count": 1
                }
            }
        }

        def fn(cell, cell_count):
            return simulate_cell_day(5, 0.207, cell, cell_count)

        simulate_water_quality(census1, 93, fn)
        simulate_water_quality(census2, 93, fn)
        for key in set(census1.keys()) - set(['distribution']):
            self.assertEqual(census1[key], census2[key])
示例#10
0
    def test_create_modified_census_3(self):
        """
        create_modified_census with non-trivial modifications.
        """
        census = {
            "cell_count": 144,
            "distribution": {
                "a:barren_land": {"cell_count": 55},
                "a:open_water": {"cell_count": 89}
            },
            "modifications": [
                {
                    "change": "::cluster_housing",
                    "cell_count": 34,
                    "distribution": {
                        "a:barren_land": {"cell_count": 34}
                    }
                }
            ]
        }

        expected = {
            "cell_count": 144,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 55,
                    "distribution": {
                        "a:barren_land:cluster_housing": {"cell_count": 34},
                        "a:barren_land": {"cell_count": 21}
                    }
                },
                "a:open_water": {
                    "cell_count": 89,
                    "distribution": {
                        "a:open_water": {"cell_count": 89}
                    }
                }
            }
        }

        actual = create_modified_census(census)
        self.assertEqual(actual, expected)
示例#11
0
    def test_create_modified_census_2(self):
        """
        create_modified_census from a census w/ trivial modifications.
        """
        census = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 2
                },
                "a:open_water": {
                    "cell_count": 1
                }
            },
            "modifications": []
        }

        expected = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {
                    "cell_count": 2,
                    "distribution": {
                        "a:barren_land": {
                            "cell_count": 2
                        }
                    }
                },
                "a:open_water": {
                    "cell_count": 1,
                    "distribution": {
                        "a:open_water": {
                            "cell_count": 1
                        }
                    }
                }
            }
        }

        actual = create_modified_census(census)
        self.assertEqual(actual, expected)
示例#12
0
    def test_simulate_water_quality_2(self):
        """
        Test the water quality simulation in the presence of modifications.
        """
        census = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {"cell_count": 2},
                "a:open_water": {"cell_count": 1}
            },
            "modifications": [
                {
                    "change": "d:developed_med:",
                    "cell_count": 1,
                    "distribution": {
                        "a:barren_land": {"cell_count": 1}
                    }
                }
            ]
        }

        census1 = create_modified_census(census)
        census2 = {
            "cell_count": 3,
            "distribution": {
                "a:barren_land": {"cell_count": 1},
                "d:developed_med": {"cell_count": 1},
                "a:open_water": {"cell_count": 1}
            }
        }

        def fn(cell, cell_count):
            return simulate_cell_day(5, 0.207, cell, cell_count)

        simulate_water_quality(census1, 93, fn)
        simulate_water_quality(census2, 93, fn)
        for key in set(census1.keys()) - set(['distribution']):
            self.assertEqual(census1[key], census2[key])