Esempio n. 1
0
    def compute_loss_ratio_curve(self, col, row, asset, gmf_slice, loss_ratios):
        """Compute the loss ratio curve for a single asset."""

        vuln_function = self.vuln_curves.get(asset["vulnerabilityFunctionReference"], None)

        if not vuln_function:
            LOGGER.error(
                "Unknown vulnerability function %s for asset %s"
                % (asset["vulnerabilityFunctionReference"], asset["assetID"])
            )

            return None

        epsilon_provider = general.EpsilonProvider(self.params)

        loss_ratio_curve = prob.compute_loss_ratio_curve(
            vuln_function, gmf_slice, epsilon_provider, asset, self._get_number_of_samples(), loss_ratios=loss_ratios
        )

        # NOTE (jmc): Early exit if the loss ratio is all zeros
        if not False in (loss_ratio_curve.ordinates == 0.0):
            return None

        key = kvs.tokens.loss_ratio_key(self.job_id, row, col, asset["assetID"])

        kvs.set(key, loss_ratio_curve.to_json())

        LOGGER.debug("Loss ratio curve is %s, write to key %s" % (loss_ratio_curve, key))

        return loss_ratio_curve
Esempio n. 2
0
    def compute_loss_ratio_curve(self, col, row, asset, gmf_slice):
        """Compute the loss ratio curve for a single site."""

        # fail if the asset has an unknown vulnerability code
        vuln_function = self.vuln_curves.get(
                asset["vulnerabilityFunctionReference"], None)

        if not vuln_function:
            LOGGER.error(
                "Unknown vulnerability function %s for asset %s"
                % (asset["vulnerabilityFunctionReference"], asset["assetID"]))

            return None

        epsilon_provider = risk_job.EpsilonProvider(self.params)
        loss_ratio_curve = probabilistic_event_based.compute_loss_ratio_curve(
                vuln_function, gmf_slice, epsilon_provider, asset,
                self._get_number_of_samples())

        # NOTE(JMC): Early exit if the loss ratio is all zeros
        if not False in (loss_ratio_curve.ordinates == 0.0):
            return None

        key = kvs.tokens.loss_ratio_key(self.id, row, col, asset["assetID"])
        kvs.set(key, loss_ratio_curve.to_json())

        LOGGER.warn("RESULT: loss ratio curve is %s, write to key %s" % (
                loss_ratio_curve, key))

        return loss_ratio_curve
Esempio n. 3
0
    def test_loss_ratio_curve_with_null_gmf(self):
        gmfs = {"IMLs": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
                "TSES": 900, "TimeSpan": 50}
        
        expected_curve = shapes.Curve([
                (0.014583333333333332, 0.0),
                (0.043749999999999997, 0.0),
                (0.072916666666666657, 0.0),
                (0.10208333333333333, 0.0),
                (0.13124999999999998, 0.0),
                (0.16041666666666665, 0.0),
                (0.18958333333333333, 0.0),
                (0.21874999999999997, 0.0),
                (0.24791666666666662, 0.0),
                (0.27708333333333329, 0.0),
                (0.30624999999999997, 0.0),
                (0.33541666666666664, 0.0),
                (0.36458333333333331, 0.0),
                (0.39374999999999993, 0.0),
                (0.42291666666666661, 0.0),
                (0.45208333333333328, 0.0),
                (0.48124999999999996, 0.0),
                (0.5395833333333333, 0.0),
                (0.59791666666666665, 0.0),
                (0.51041666666666663, 0.0),
                (0.56874999999999987, 0.0),
                (0.62708333333333321, 0.0),
                (0.65625, 0.0),
                (0.68541666666666656, 0.0)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function, gmfs))
Esempio n. 4
0
    def test_computes_the_loss_ratio_curve(self):
        expected_curve = shapes.Curve([
                (0.014583333333333332, 0.99801517),
                (0.043749999999999997, 0.82133133505033484),
                (0.072916666666666657, 0.61110443601077713),
                (0.10208333333333333, 0.48658288096740798),
                (0.13124999999999998, 0.32219042199454972),
                (0.16041666666666665, 0.32219042199454972),
                (0.18958333333333333, 0.24253487160303355),
                (0.21874999999999997, 0.19926259708319194),
                (0.24791666666666662, 0.19926259708319194),
                (0.27708333333333329, 0.19926259708319194),
                (0.30624999999999997, 0.054040531093234589),
                (0.33541666666666664, 0.054040531093234589),
                (0.36458333333333331, 0.054040531093234589),
                (0.39374999999999993, 0.054040531093234589),
                (0.42291666666666661, 0.054040531093234589),
                (0.45208333333333328, 0.0), (0.48124999999999996, 0.0),
                (0.5395833333333333, 0.0), (0.59791666666666665, 0.0),
                (0.51041666666666663, 0.0), (0.56874999999999987, 0.0),
                (0.62708333333333321, 0.0), (0.65625, 0.0),
                (0.68541666666666656, 0.0)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function, self.gmfs))
Esempio n. 5
0
    def compute_loss_ratio_curve(self, col, row, asset, gmf_slice):
        """Compute the loss ratio curve for a single site."""

        # fail if the asset has an unknown vulnerability code
        vuln_function = self.vuln_curves.get(
            asset["vulnerabilityFunctionReference"], None)

        if not vuln_function:
            LOGGER.error(
                "Unknown vulnerability function %s for asset %s" %
                (asset["vulnerabilityFunctionReference"], asset["assetID"]))

            return None

        epsilon_provider = risk_job.EpsilonProvider(self.params)
        loss_ratio_curve = probabilistic_event_based.compute_loss_ratio_curve(
            vuln_function, gmf_slice, epsilon_provider, asset,
            self._get_number_of_samples())

        # NOTE(JMC): Early exit if the loss ratio is all zeros
        if not False in (loss_ratio_curve.ordinates == 0.0):
            return None

        key = kvs.tokens.loss_ratio_key(self.id, row, col, asset["assetID"])
        kvs.set(key, loss_ratio_curve.to_json())

        LOGGER.warn("RESULT: loss ratio curve is %s, write to key %s" %
                    (loss_ratio_curve, key))

        return loss_ratio_curve
Esempio n. 6
0
    def test_with_not_earthquakes_we_have_an_empty_curve(self):
        gmfs = dict(self.gmfs)
        gmfs["IMLs"] = ()

        curve = prob.compute_loss_ratio_curve(
                self.vuln_function_1, gmfs, None, None)

        self.assertEqual(shapes.EMPTY_CURVE, curve)
Esempio n. 7
0
    def test_with_not_earthquakes_we_have_an_empty_curve(self):
        gmfs = dict(self.gmfs)
        gmfs["IMLs"] = ()

        curve = prob.compute_loss_ratio_curve(
                self.vuln_function_1, gmfs, None, None)

        self.assertEqual(shapes.EMPTY_CURVE, curve)
Esempio n. 8
0
    def test_with_no_ground_motion_the_curve_is_a_single_point(self):
        gmfs = {"IMLs": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
                "TSES": 900, "TimeSpan": 50}

        # sounds like a curve, but it's a point :-)
        expected_curve = shapes.Curve([
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_1, gmfs, None, None))
Esempio n. 9
0
    def test_with_no_ground_motion_the_curve_is_a_single_point(self):
        gmfs = {"IMLs": (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
                "TSES": 900, "TimeSpan": 50}

        # sounds like a curve, but it's a point :-)
        expected_curve = shapes.Curve([
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0),
                (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_1, gmfs, None, None))
Esempio n. 10
0
    def test_computes_the_loss_ratio_curve(self):
        # manually computed results from V. Silva
        expected_curve = shapes.Curve([(0.085255, 0.988891),
                (0.255765, 0.82622606), (0.426275, 0.77686984),
                (0.596785, 0.52763345), (0.767295, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_1,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.0935225, 0.99326205),
                (0.2640675, 0.917915), (0.4346125, 0.77686984),
                (0.6051575, 0.52763345), (0.7757025, 0.22119922)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_2,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.1047, 0.99326205),
                (0.2584, 0.89460078), (0.4121, 0.63212056),
                (0.5658, 0.39346934), (0.7195, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_3,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.09012, 0.99326205),
                (0.25551, 0.93607214), (0.4209, 0.77686984),
                (0.58629, 0.52763345), (0.75168, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_4,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.08089, 0.99326205),
                (0.23872, 0.95021293), (0.39655, 0.7134952),
                (0.55438, 0.52763345), (0.71221, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_5,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.0717025, 0.99326205),
                (0.2128575, 0.917915), (0.3540125, 0.82622606),
                (0.4951675, 0.77686984), (0.6363225, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_6,
                None, None, number_of_samples=6))
Esempio n. 11
0
    def test_computes_the_loss_ratio_curve(self):
        # manually computed results from V. Silva
        expected_curve = shapes.Curve([(0.085255, 0.988891),
                (0.255765, 0.82622606), (0.426275, 0.77686984),
                (0.596785, 0.52763345), (0.767295, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_1,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.0935225, 0.99326205),
                (0.2640675, 0.917915), (0.4346125, 0.77686984),
                (0.6051575, 0.52763345), (0.7757025, 0.22119922)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_2,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.1047, 0.99326205),
                (0.2584, 0.89460078), (0.4121, 0.63212056),
                (0.5658, 0.39346934), (0.7195, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_3,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.09012, 0.99326205),
                (0.25551, 0.93607214), (0.4209, 0.77686984),
                (0.58629, 0.52763345), (0.75168, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_4,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.08089, 0.99326205),
                (0.23872, 0.95021293), (0.39655, 0.7134952),
                (0.55438, 0.52763345), (0.71221, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_5,
                None, None, number_of_samples=6))

        expected_curve = shapes.Curve([(0.0717025, 0.99326205),
                (0.2128575, 0.917915), (0.3540125, 0.82622606),
                (0.4951675, 0.77686984), (0.6363225, 0.39346934)])

        self.assertEqual(expected_curve, prob.compute_loss_ratio_curve(
                self.vuln_function_2, self.gmfs_6,
                None, None, number_of_samples=6))
Esempio n. 12
0
    def compute_loss_ratio_curve(self, col, row, asset, gmf_slice ): # site_id
        """Compute the loss ratio curve for a single site."""
        # If the asset has a vuln function code we don't have loaded, return
        # fail
        vuln_function = self.vuln_curves.get(
                asset["VulnerabilityFunction"], None)
        if not vuln_function:
            LOGGER.error("Unknown vulnerability function %s for asset %s"
                % (asset["VulnerabilityFunction"], asset["AssetID"]))
            return None

        loss_ratio_curve = probabilistic_event_based.compute_loss_ratio_curve(
                vuln_function, gmf_slice)
        # NOTE(JMC): Early exit if the loss ratio is all zeros
        if not False in (loss_ratio_curve.ordinates == 0.0):
            return None
        key = kvs.tokens.loss_ratio_key(self.id, row, col, asset["AssetID"])
        
        LOGGER.warn("RESULT: loss ratio curve is %s, write to key %s" % (
                loss_ratio_curve, key))
            
        kvs.set(key, loss_ratio_curve.to_json())
        return loss_ratio_curve
Esempio n. 13
0
    def test_an_empty_gmfs_produces_an_empty_loss_ratio_curve(self):
        gmfs = dict(self.gmfs)
        gmfs["IMLs"] = ()

        curve = prob.compute_loss_ratio_curve(self.vuln_function, gmfs)
        self.assertEqual(shapes.EMPTY_CURVE, curve)