Esempio n. 1
0
    def setUp(self):
        self.params = {
            'CALCULATION_MODE': 'Hazard',
            'REFERENCE_VS30_VALUE': 500}

        self.imls = [5.0000e-03, 7.0000e-03,
                1.3700e-02, 1.9200e-02, 2.6900e-02, 3.7600e-02, 5.2700e-02,
                7.3800e-02, 9.8000e-02, 1.0300e-01, 1.4500e-01, 2.0300e-01,
                2.8400e-01, 3.9700e-01, 5.5600e-01, 7.7800e-01, 1.0900e+00,
                1.5200e+00, 2.1300e+00]

        self.job = self.create_job_with_mixin(self.params,
                                              opensha.ClassicalMixin)
        self.job_id = self.job.job_id

        self.empty_mean_curve = []

        # deleting server side cached data
        kvs.flush()

        mean_curve = [9.8728e-01, 9.8266e-01, 9.4957e-01,
                9.0326e-01, 8.1956e-01, 6.9192e-01, 5.2866e-01, 3.6143e-01,
                2.4231e-01, 2.2452e-01, 1.2831e-01, 7.0352e-02, 3.6060e-02,
                1.6579e-02, 6.4213e-03, 2.0244e-03, 4.8605e-04, 8.1752e-05,
                7.3425e-06]

        self.site = shapes.Site(2.0, 5.0)
        self._store_curve_at(self.site, mean_curve)
Esempio n. 2
0
    def setUp(self):
        self.job_id = 1234

        self.poes_levels = classical_psha.POES_PARAM_NAME
        self.quantiles_levels = classical_psha.QUANTILE_PARAM_NAME

        self.params = {}
        self.params["REFERENCE_VS30_VALUE"] = 500
        self.params["INTENSITY_MEASURE_LEVELS"] = "5.0000e-03, 7.0000e-03,  \
                1.3700e-02, 1.9200e-02, 2.6900e-02, 3.7600e-02, 5.2700e-02, \
                7.3800e-02, 9.8000e-02, 1.0300e-01, 1.4500e-01, 2.0300e-01, \
                2.8400e-01, 3.9700e-01, 5.5600e-01, 7.7800e-01, 1.0900e+00, \
                1.5200e+00, 2.1300e+00"

        self.engine = job.Job(self.params,  self.job_id)

        self.empty_mean_curve = {"site_lon": 2.0,
                "site_lat": 5.0, "curve": []}

        # deleting server side cached data
        kvs.flush()

        mean_curve = {"site_lon": 2.0, "site_lat": 5.0,
                "curve": classical_psha._reconstruct_curve_list_from(
                [9.8728e-01, 9.8266e-01, 9.4957e-01,
                9.0326e-01, 8.1956e-01, 6.9192e-01, 5.2866e-01, 3.6143e-01,
                2.4231e-01, 2.2452e-01, 1.2831e-01, 7.0352e-02, 3.6060e-02,
                1.6579e-02, 6.4213e-03, 2.0244e-03, 4.8605e-04, 8.1752e-05,
                7.3425e-06])}

        self._store_curve_at(shapes.Site(2.0, 5.0), mean_curve)
Esempio n. 3
0
    def setUp(self):
        self.job_id = 1234

        self.poes_levels = classical_psha.POES_PARAM_NAME
        self.quantiles_levels = classical_psha.QUANTILE_PARAM_NAME

        self.params = {}
        self.params["REFERENCE_VS30_VALUE"] = 500
        self.params["INTENSITY_MEASURE_LEVELS"] = "5.0000e-03, 7.0000e-03,  \
                1.3700e-02, 1.9200e-02, 2.6900e-02, 3.7600e-02, 5.2700e-02, \
                7.3800e-02, 9.8000e-02, 1.0300e-01, 1.4500e-01, 2.0300e-01, \
                2.8400e-01, 3.9700e-01, 5.5600e-01, 7.7800e-01, 1.0900e+00, \
                1.5200e+00, 2.1300e+00"

        self.engine = job.Job(self.params,  self.job_id)

        self.empty_mean_curve = {"site_lon": 2.0,
                "site_lat": 5.0, "curve": []}

        # deleting server side cached data
        kvs.flush()

        mean_curve = {"site_lon": 2.0, "site_lat": 5.0,
                "curve": classical_psha._reconstruct_curve_list_from(
                [9.8728e-01, 9.8266e-01, 9.4957e-01,
                9.0326e-01, 8.1956e-01, 6.9192e-01, 5.2866e-01, 3.6143e-01,
                2.4231e-01, 2.2452e-01, 1.2831e-01, 7.0352e-02, 3.6060e-02,
                1.6579e-02, 6.4213e-03, 2.0244e-03, 4.8605e-04, 8.1752e-05,
                7.3425e-06])}

        self._store_curve_at(shapes.Site(2.0, 5.0), mean_curve)
    def tearDown(self):
        # restoring the default java implementation
        det.DeterministicEventBasedMixin.compute_ground_motion_field = \
            self.default

        flags.FLAGS.include_defaults = True

        kvs.flush()
    def test_load_assets_for_point(self):
        """
        Exercises the function
        :py:func:`openquake.risk.job.deterministic.load_assets_for_point`.
        """

        kvs.flush()

        # Fabricate some test data.
        test_assets = [
            {'assetValue': 2129.5,
             'assetID': '104',
             'listDescription': 'fake_description',
             'structureCategory': 'S4L_MC',
             'lon': 0.11,
             'assetDescription': 'LA building',
             'vulnerabilityFunctionReference': 'HAZUS_S4L_MC',
             'listID': 'LA01',
             'assetValueUnit': 'EUR',
             'lat': 0.11},
            {'assetValue': 2229.5,
             'assetID': '105',
             'listDescription': 'fake_description',
             'structureCategory': 'S4L_MC',
             'lon': 0.11,
             'assetDescription': 'LA building',
             'vulnerabilityFunctionReference': 'HAZUS_S4L_MC',
             'listID': 'LA02',
             'assetValueUnit': 'EUR',
             'lat': 0.12}]

        test_site = shapes.Site(0.1, 0.1)
        test_point = TEST_REGION.grid.point_at(test_site)

        encoder = json.JSONEncoder()

        assets_key = kvs.tokens.asset_key(
            TEST_JOB_ID, test_point.row, test_point.column)

        # Throw the test data into the KVS.
        for asset in test_assets:
            kvs.get_client().rpush(assets_key, encoder.encode(asset))

        # The data should now be in the KVS.
        # Now verify that the load_assets_for_point function returns
        # the appropriate data.
        actual_assets = \
            risk_job_det.load_assets_for_point(TEST_JOB_ID, test_point)

        kvs.flush()

        # They should come out exactly the way they went in.
        self.assertEqual(test_assets, actual_assets)
Esempio n. 6
0
    def setUp(self):
        self.job_id = 1234

        self.expected_mean_curve = numpy.array([9.8542200e-01, 9.8196600e-01,
                9.5842000e-01, 9.2639600e-01, 8.6713000e-01, 7.7081800e-01,
                6.3448600e-01, 4.7256800e-01, 3.3523400e-01, 3.1255000e-01,
                1.7832000e-01, 9.0883400e-02, 4.2189200e-02, 1.7874200e-02,
                6.7449200e-03, 2.1658200e-03, 5.3878600e-04, 9.4369400e-05,
                8.9830380e-06])

        self.empty_curve = {"curve": []}

        # deleting server side cached data
        kvs.flush()
Esempio n. 7
0
    def setUp(self):
        self.job_id = 1234

        self.expected_mean_curve = numpy.array([9.8542200e-01, 9.8196600e-01,
                9.5842000e-01, 9.2639600e-01, 8.6713000e-01, 7.7081800e-01,
                6.3448600e-01, 4.7256800e-01, 3.3523400e-01, 3.1255000e-01,
                1.7832000e-01, 9.0883400e-02, 4.2189200e-02, 1.7874200e-02,
                6.7449200e-03, 2.1658200e-03, 5.3878600e-04, 9.4369400e-05,
                8.9830380e-06])

        self.empty_curve = {"curve": []}

        # deleting server side cached data
        kvs.flush()
    def setUp(self):
        kvs.flush()

        self.job = helpers.job_from_file(SCENARIO_SMOKE_TEST)

        self.job.params[NUMBER_OF_CALC_KEY] = "1"

        self.job.params["SERIALIZE_RESULTS_TO"] = "xml"

        # saving the default java implementation
        self.default = det.ScenarioEventBasedMixin.compute_ground_motion_field

        self.grid = self.job.region.grid

        self.job.to_kvs()
Esempio n. 9
0
    def setUp(self):
        self.params = {'CALCULATION_MODE': 'Hazard'}
        self.job = self.create_job_with_mixin(self.params,
                                              opensha.ClassicalMixin)
        self.job_id = self.job.job_id

        self.expected_curve = numpy.array([9.9178000e-01, 9.8892000e-01,
                9.6903000e-01, 9.4030000e-01, 8.8405000e-01, 7.8782000e-01,
                6.4897250e-01, 4.8284250e-01, 3.4531500e-01, 3.2337000e-01,
                1.8880500e-01, 9.5574000e-02, 4.3707250e-02, 1.9643000e-02,
                8.1923000e-03, 2.9157000e-03, 7.9955000e-04, 1.5233000e-04,
                1.5582000e-05])

        # deleting server side cached data
        kvs.flush()
Esempio n. 10
0
    def setUp(self):
        self.job_id = 1234

        self.params = {}
        self.quantiles_levels = classical_psha.QUANTILE_PARAM_NAME
        self.engine = job.Job(self.params,  self.job_id)

        self.expected_curve = numpy.array([9.9178000e-01, 9.8892000e-01,
                9.6903000e-01, 9.4030000e-01, 8.8405000e-01, 7.8782000e-01,
                6.4897250e-01, 4.8284250e-01, 3.4531500e-01, 3.2337000e-01,
                1.8880500e-01, 9.5574000e-02, 4.3707250e-02, 1.9643000e-02,
                8.1923000e-03, 2.9157000e-03, 7.9955000e-04, 1.5233000e-04,
                1.5582000e-05])

        # deleting server side cached data
        kvs.flush()
Esempio n. 11
0
    def setUp(self):
        self.job_id = 1234

        self.params = {}
        self.quantiles_levels = classical_psha.QUANTILE_PARAM_NAME
        self.engine = job.Job(self.params,  self.job_id)

        self.expected_curve = numpy.array([9.9178000e-01, 9.8892000e-01,
                9.6903000e-01, 9.4030000e-01, 8.8405000e-01, 7.8782000e-01,
                6.4897250e-01, 4.8284250e-01, 3.4531500e-01, 3.2337000e-01,
                1.8880500e-01, 9.5574000e-02, 4.3707250e-02, 1.9643000e-02,
                8.1923000e-03, 2.9157000e-03, 7.9955000e-04, 1.5233000e-04,
                1.5582000e-05])

        # deleting server side cached data
        kvs.flush()
Esempio n. 12
0
    def setUp(self):
        flags.FLAGS.include_defaults = False

        self.engine = job.Job.from_file(DETERMINISTIC_SMOKE_TEST)
        self.engine.job_id = 1234

        self.engine.params[NUMBER_OF_CALC_KEY] = "1"

        # saving the default java implementation
        self.default = \
            det.DeterministicEventBasedMixin.compute_ground_motion_field

        kvs.flush()
        self.kvs_client = kvs.get_client(binary=False)

        self.grid = self.engine.region.grid

        self.engine.to_kvs()
    def setUp(self):
        flags.FLAGS.include_defaults = False

        self.engine = job.Job.from_file(DETERMINISTIC_SMOKE_TEST)
        self.engine.job_id = 1234

        self.engine.params[NUMBER_OF_CALC_KEY] = "1"

        # saving the default java implementation
        self.default = \
            det.DeterministicEventBasedMixin.compute_ground_motion_field

        kvs.flush()
        self.kvs_client = kvs.get_client(binary=False)

        self.grid = self.engine.region.grid

        self.engine.to_kvs()
    def setUp(self):
        kvs.flush()

        flags.FLAGS.include_defaults = False

        self.job = helpers.job_from_file(DETERMINISTIC_SMOKE_TEST)

        self.job.params[NUMBER_OF_CALC_KEY] = "1"

        self.job.params['SERIALIZE_RESULTS_TO'] = 'xml'

        # saving the default java implementation
        self.default = \
            det.DeterministicEventBasedMixin.compute_ground_motion_field

        self.grid = self.job.region.grid

        self.job.to_kvs()
    def test_load_gmvs_for_point(self):
        """
        Exercises the function
        :py:func:`openquake.risk.job.deterministic.load_gmvs_for_point`.
        """

        # clear the kvs before running the test
        kvs.flush()

        # values to place in the kvs
        test_gmvs = [
            {'site_lon': 0.1, 'site_lat': 0.2, 'mag': 0.117},
            {'site_lon': 0.1, 'site_lat': 0.2, 'mag': 0.167},
            {'site_lon': 0.1, 'site_lat': 0.2, 'mag': 0.542}]

        expected_gmvs = [0.117, 0.167, 0.542]

        test_point = TEST_REGION.grid.point_at(shapes.Site(0.1, 0.2))

        # we expect this point to be at row 1, column 0
        self.assertEqual(1, test_point.row)
        self.assertEqual(0, test_point.column)

        gmvs_key = kvs.tokens.ground_motion_values_key(TEST_JOB_ID, test_point)

        # place the test values in kvs
        for gmv in test_gmvs:
            json_gmv = json.JSONEncoder().encode(gmv)
            kvs.get_client().rpush(gmvs_key, json_gmv)

        actual_gmvs = risk_job_det.load_gmvs_for_point(TEST_JOB_ID, test_point)

        # clear the kvs again before the test concludes
        kvs.flush()

        self.assertEqual(expected_gmvs, actual_gmvs)
Esempio n. 16
0
    def setUp(self):
        self.expected_results = _load_expected_results()
        kvs.flush()

        self.engine = job.Job.from_file(
            helpers.smoketest_file("HazardMapTest/config.gem"))
    def setUp(self):
        self.parser = vulnerability.VulnerabilityModelFile(
                os.path.join(helpers.SCHEMA_DIR, TEST_FILE))

        # delete server side cached data
        kvs.flush()
Esempio n. 18
0
    def tearDown(self):
        # restoring the default java implementation
        det.ScenarioEventBasedMixin.compute_ground_motion_field = self.default

        kvs.flush()
    def setUp(self):
        self.parser = vulnerability.VulnerabilityModelFile(
            os.path.join(test.SCHEMA_DIR, TEST_FILE))

        # delete server side cached data
        kvs.flush()
Esempio n. 20
0
    def setUp(self):
        self.expected_results = _load_expected_results()
        kvs.flush()

        self.engine = job.Job.from_file(
            helpers.smoketest_file("HazardMapTest/config.gem"))