def test_compute_probability(self):
     impact_function = PAGFatalityFunction.instance()
     result = impact_function.compute_probability(50.0)
     expected_result = [17.0, 50.0, 30.0, 3.0, 0.0, 0.0]
     message = 'Expecting %s, but it returns %s' % (
         expected_result, result)
     self.assertEqual(expected_result, result, msg=message)
    def test_run(self):
        """TestPagerEarthquakeFatalityFunction: Test running the IF."""
        eq_path = test_data_path('hazard', 'earthquake.tif')
        population_path = test_data_path(
            'exposure', 'pop_binary_raster_20_20.asc')

        # For EQ on Pops we need to clip the hazard and exposure first to the
        #  same dimension
        clipped_hazard, clipped_exposure = clip_layers(eq_path,
                                                       population_path)

        # noinspection PyUnresolvedReferences
        eq_layer = read_layer(
            str(clipped_hazard.source()))
        # noinspection PyUnresolvedReferences
        population_layer = read_layer(
            str(clipped_exposure.source()))

        impact_function = PAGFatalityFunction.instance()
        impact_function.hazard = eq_layer
        impact_function.exposure = population_layer
        impact_function.run()
        impact_layer = impact_function.impact
        # Check the question
        expected_question = ('In the event of earthquake how many '
                             'population might die or be displaced according '
                             'pager model')
        message = 'The question should be %s, but it returns %s' % (
            expected_question, impact_function.question)
        self.assertEqual(expected_question, impact_function.question, message)

        expected_exposed_per_mmi = {
            2.0: 0,
            2.5: 0,
            3.0: 0,
            3.5: 0,
            4.0: 0,
            4.5: 0,
            5.0: 0,
            5.5: 0,
            6.5: 0,
            6.0: 0,
            7.0: 0,
            7.5: 60,
            8.0: 140,
            8.5: 0,
            9.0: 0,
            9.5: 0}
        result = impact_layer.get_keywords('exposed_per_mmi')

        message = 'Expecting %s, but it returns %s' % (
            expected_exposed_per_mmi, result)
        self.assertEqual(expected_exposed_per_mmi, result, message)
    def test_round_to_sum(self):
        impact_function = PAGFatalityFunction.instance()
        result = impact_function.round_to_sum([10.26, 10.5, 29.8, 39.5, 9.94])
        expected_result = [10.0, 10.0, 30.0, 40.0, 10.0]
        message = 'Expecting %s, but it returns %s' % (expected_result, result)
        self.assertEqual(expected_result, result, msg=message)

        result = impact_function.round_to_sum(
            [45.844, 43.02, 10.59, 0.54, 0.0055, 5.e-4])
        expected_result = [46.0, 43.0, 11.0, 0.0, 0.0, 0.0]
        message = 'Expecting %s, but it returns %s' % (expected_result, result)
        self.assertEqual(expected_result, result, msg=message)
Example #4
0
    def test_run(self):
        """TestPagerEarthquakeFatalityFunction: Test running the IF."""
        eq_path = test_data_path('hazard', 'earthquake.tif')
        population_path = test_data_path('exposure',
                                         'pop_binary_raster_20_20.asc')

        # For EQ on Pops we need to clip the hazard and exposure first to the
        #  same dimension
        clipped_hazard, clipped_exposure = clip_layers(eq_path,
                                                       population_path)

        # noinspection PyUnresolvedReferences
        eq_layer = read_layer(str(clipped_hazard.source()))
        # noinspection PyUnresolvedReferences
        population_layer = read_layer(str(clipped_exposure.source()))

        impact_function = PAGFatalityFunction.instance()
        impact_function.hazard = eq_layer
        impact_function.exposure = population_layer
        impact_function.run()
        impact_layer = impact_function.impact
        # Check the question
        expected_question = ('In the event of earthquake how many '
                             'population might die or be displaced according '
                             'pager model')
        message = 'The question should be %s, but it returns %s' % (
            expected_question, impact_function.question)
        self.assertEqual(expected_question, impact_function.question, message)

        expected_exposed_per_mmi = {
            2.0: 0,
            2.5: 0,
            3.0: 0,
            3.5: 0,
            4.0: 0,
            4.5: 0,
            5.0: 0,
            5.5: 0,
            6.5: 0,
            6.0: 0,
            7.0: 0,
            7.5: 60,
            8.0: 140,
            8.5: 0,
            9.0: 0,
            9.5: 0
        }
        result = impact_layer.get_keywords('exposed_per_mmi')

        message = 'Expecting %s, but it returns %s' % (
            expected_exposed_per_mmi, result)
        self.assertEqual(expected_exposed_per_mmi, result, message)
Example #5
0
    def test_round_to_sum(self):
        impact_function = PAGFatalityFunction.instance()
        result = impact_function.round_to_sum([
            10.26, 10.5, 29.8, 39.5, 9.94])
        expected_result = [10.0, 10.0, 30.0, 40.0, 10.0]
        message = 'Expecting %s, but it returns %s' % (
            expected_result, result)
        self.assertEqual(expected_result, result, msg=message)

        result = impact_function.round_to_sum([
            45.844, 43.02, 10.59, 0.54, 0.0055, 5.e-4])
        expected_result = [46.0, 43.0, 11.0, 0.0, 0.0, 0.0]
        message = 'Expecting %s, but it returns %s' % (
            expected_result, result)
        self.assertEqual(expected_result, result, msg=message)
 def test_compute_fatality_rate(self):
     impact_function = PAGFatalityFunction.instance()
     expected_result = {2: 0,
                        3: 0,
                        4: 1.110e-15,
                        5: 5.463e-11,
                        6: 7.767e-8,
                        7: 1.193e-5,
                        8: 4.174e-4,
                        9: 5.219e-3,
                        10: 3.121e-2}
     result = impact_function.compute_fatality_rate()
     for item in expected_result.keys():
         message = 'Expecting %s, but it returns %s' % (
             expected_result[item], result[item])
         self.assertAlmostEqual(expected_result[item],
                                result[item], places=4, msg=message)
    def test_run(self):
        """TestPagerEarthquakeFatalityFunction: Test running the IF."""
        # FIXME(Hyeuk): test requires more realistic hazard and population data
        eq_path = test_data_path('hazard', 'earthquake.tif')
        population_path = test_data_path(
            'exposure', 'pop_binary_raster_20_20.asc')

        # For EQ on Pops we need to clip the hazard and exposure first to the
        #  same dimension
        clipped_hazard, clipped_exposure = clip_layers(
            eq_path, population_path)

        # noinspection PyUnresolvedReferences
        eq_layer = read_layer(
            str(clipped_hazard.source()))
        # noinspection PyUnresolvedReferences
        population_layer = read_layer(
            str(clipped_exposure.source()))

        impact_function = PAGFatalityFunction.instance()
        impact_function.hazard = SafeLayer(eq_layer)
        impact_function.exposure = SafeLayer(population_layer)
        impact_function.run()
        impact_layer = impact_function.impact
        # Check the question
        expected_question = (
            'In the event of earthquake how many population might die or '
            'be displaced according pager model')
        message = 'The question should be %s, but it returns %s' % (
            expected_question, impact_function.question)
        self.assertEqual(expected_question, impact_function.question, message)

        expected_result = {
            'total_population': 200,
            'total_fatalities': 0,  # should be zero FIXME
            'total_displaced': 200
        }
        for key_ in expected_result.keys():
            result = impact_layer.get_keywords(key_)
            message = 'Expecting %s, but it returns %s' % (
                expected_result[key_], result)
            self.assertEqual(expected_result[key_], result, message)

        expected_result = {}
        expected_result['fatalities_per_mmi'] = {
            2: 0,
            3: 0,
            4: 0,
            5: 0,
            6: 0,
            7: 0,
            8: 0.083498,  # FIXME should be rounded to zero!! not 10.
            9: 0,
            10: 0
        }
        expected_result['exposed_per_mmi'] = {
            2: 0,
            3: 0,
            4: 0,
            5: 0,
            6: 0,
            7: 0,
            8: 200,
            9: 0,
            10: 0
        }
        expected_result['displaced_per_mmi'] = {
            2: 0,
            3: 0,
            4: 0,
            5: 0,
            6: 0,
            7: 0,
            8: 199.91650,  # FIXME should be 200.0
            9: 0,
            10: 0
        }

        for key_ in expected_result.keys():
            result = impact_layer.get_keywords(key_)
            for item in expected_result[key_].keys():
                message = 'Expecting %s, but it returns %s' % (
                    expected_result[key_][item], result[item])
                self.assertAlmostEqual(
                    expected_result[key_][item],
                    result[item], places=4, msg=message)

        # expected_result = [
        #    8.0, 42.0, 42.0, 8.0, 0.0, 0.0, 0.0] # corresponds to 10
        expected_result = [
            100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  # corresponds to <= 1
        result = impact_function.compute_probability(
            impact_layer.get_keywords('total_fatalities_raw'))
        message = 'Expecting %s, but it returns %s' % (
            expected_result, result)
        self.assertEqual(expected_result, result, message)
    def test_run(self):
        """TestPagerEarthquakeFatalityFunction: Test running the IF."""
        # FIXME(Hyeuk): test requires more realistic hazard and population data
        eq_path = standard_data_path('hazard', 'earthquake.tif')
        population_path = standard_data_path(
            'exposure', 'pop_binary_raster_20_20.asc')

        # For EQ on Pops we need to clip the hazard and exposure first to the
        #  same dimension
        clipped_hazard, clipped_exposure = clip_layers(
            eq_path, population_path)

        # noinspection PyUnresolvedReferences
        eq_layer = read_layer(
            str(clipped_hazard.source()))
        # noinspection PyUnresolvedReferences
        population_layer = read_layer(
            str(clipped_exposure.source()))

        impact_function = PAGFatalityFunction.instance()
        impact_function.hazard = SafeLayer(eq_layer)
        impact_function.exposure = SafeLayer(population_layer)
        impact_function.run()
        impact_layer = impact_function.impact
        # Check the question
        expected_question = (
            'In the event of earthquake how many population might die or '
            'be displaced according pager model?')
        self.assertEqual(expected_question, impact_function.question)

        expected_result = {
            'total_population': 200,
            'total_fatalities': 0,  # should be zero FIXME
            'total_displaced': 200
        }
        for key_ in expected_result.keys():
            result = impact_layer.get_keywords(key_)
            message = 'Expecting %s, but it returns %s' % (
                expected_result[key_], result)
            self.assertEqual(expected_result[key_], result, message)

        expected_result = {}
        expected_result['fatalities_per_mmi'] = {
            2: 0,
            3: 0,
            4: 0,
            5: 0,
            6: 0,
            7: 0,
            8: 0.083498,
            9: 0,
            10: 0
        }
        expected_result['exposed_per_mmi'] = {
            2: 0,
            3: 0,
            4: 0,
            5: 0,
            6: 0,
            7: 0,
            8: 200,
            9: 0,
            10: 0
        }
        expected_result['displaced_per_mmi'] = {
            2: 0,
            3: 0,
            4: 0,
            5: 0,
            6: 0,
            7: 0,
            8: 199.91650,
            9: 0,
            10: 0
        }

        for key_ in expected_result.keys():
            result = impact_layer.get_keywords(key_)
            for item in expected_result[key_].keys():
                message = 'Expecting %s, but it returns %s' % (
                    expected_result[key_][item], result[item])
                self.assertAlmostEqual(
                    expected_result[key_][item],
                    result[item], places=4, msg=message)

        expected_result = [
            100.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        result = impact_layer.get_keywords('prob_fatality_mag')
        message = 'Expecting %s, but it returns %s' % (
            expected_result, result)
        self.assertEqual(expected_result, result, message)