def test_computes_the_iml(self): self.params[self.poes_levels] = "0.10" mean_curve = {"site_lon": 3.0, "site_lat": 3.0, "curve": classical_psha._reconstruct_curve_list_from( [9.8784e-01, 9.8405e-01, 9.5719e-01, 9.1955e-01, 8.5019e-01, 7.4038e-01, 5.9153e-01, 4.2626e-01, 2.9755e-01, 2.7731e-01, 1.6218e-01, 8.8035e-02, 4.3499e-02, 1.9065e-02, 7.0442e-03, 2.1300e-03, 4.9498e-04, 8.1768e-05, 7.3425e-06])} self._store_curve_at(shapes.Site(3.0, 3.0), mean_curve) self._run() im_level = self._get_iml_at(shapes.Site(2.0, 5.0), 0.10) self.assertEqual(2.0, im_level["site_lon"]) self.assertEqual(5.0, im_level["site_lat"]) self.assertTrue(numpy.allclose([1.6789e-01], numpy.array(im_level["IML"]), atol=0.005)) im_level = self._get_iml_at(shapes.Site(3.0, 3.0), 0.10) self.assertEqual(3.0, im_level["site_lon"]) self.assertEqual(3.0, im_level["site_lat"]) self.assertTrue(numpy.allclose([1.9078e-01], numpy.array(im_level["IML"]), atol=0.005))
def test_accepts_also_signs(self): self.params[self.quantiles_levels] = "-0.33 +0.0 XYZ +0.5 +1.00" self._run([shapes.Site(2.0, 5.0)]) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.00) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.50) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 1.00)
def test_write_multiple_result_nodes(self): result_data = [ dict(groundMotionValue=0.25, path="filea"), dict(groundMotionValue=0.76, path="fileb"), dict(groundMotionValue=0.11, path="filec"), ] expected_result_attrib = [ dict(groundMotionValue="0.25", path="filea"), dict(groundMotionValue="0.76", path="fileb"), dict(groundMotionValue="0.11", path="filec"), ] self.writer.open() self.writer.write(shapes.Site(1.0, 2.0), result_data[0]) self.writer.write(shapes.Site(2.0, 3.0), result_data[1]) self.writer.write(shapes.Site(3.0, 4.0), result_data[2]) self.writer.close() site_nodes = self._xpath("//gml:pos") disagg_nodes = self._xpath("//nrml:disaggregationResultNode") results = self._xpath("//nrml:disaggregationResult") self.assertEquals(3, len(site_nodes)) self.assertEquals(3, len(disagg_nodes)) self.assertEquals(3, len(results)) self.assertEquals("1.0 2.0", site_nodes[0].text) self.assertEquals("2.0 3.0", site_nodes[1].text) self.assertEquals("3.0 4.0", site_nodes[2].text) for i, res in enumerate(results): self.assertEquals(expected_result_attrib[i], res.attrib) self.assertTrue(xml.validates_against_xml_schema(self.FILENAME))
def make_assets(self): [ism] = models.inputs4job(self.job.id, input_type="exposure") em = models.ExposureModel( owner=ism.owner, input=ism, name="AAA", category="single_asset", reco_type="aggregated", reco_unit="USD", stco_type="aggregated", stco_unit="USD") em.save() site_1 = shapes.Site(-116.0, 41.0) site_2 = shapes.Site(-117.0, 42.0) asset_1 = models.ExposureData( exposure_model=em, taxonomy="RC", asset_ref="asset_1", number_of_units=100, stco=1, site=geos.GEOSGeometry(site_1.point.to_wkt()), reco=1) asset_2 = models.ExposureData( exposure_model=em, taxonomy="RM", asset_ref="asset_2", number_of_units=40, stco=1, site=geos.GEOSGeometry(site_2.point.to_wkt()), reco=1) asset_3 = models.ExposureData( exposure_model=em, taxonomy="RM", asset_ref="asset_3", number_of_units=40, stco=1, site=geos.GEOSGeometry(site_2.point.to_wkt()), reco=1) asset_1.save() asset_2.save() asset_3.save() return asset_1, asset_2, asset_3
def test_computes_all_the_levels_specified(self): self.params[self.quantiles_levels] = "0.25 0.50 0.75" self._run([shapes.Site(2.0, 5.0)]) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.25) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.50) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.75)
def test_eq(self): # Test the __eq__ method. # __eq__ is a shallow test and only compares ids. block1 = Block(7, 0, [shapes.Site(1.0, 1.0)]) block2 = Block(7, 0, [shapes.Site(1.0, 0.0)]) self.assertTrue(block1 == block2)
def test_reads_multiple_curves_in_multiple_branches_nrml(self): self.python_client.set("KEY", MULTIPLE_CURVES_MULTIPLE_BRANCHES) nrmls = self.reader.for_nrml("KEY") data = {shapes.Site(4.0, 4.0): { "IMT": "PGA", "IDmodel": "FIXED", "timeSpanDuration": 50.0, "endBranchLabel": "label1", "IMLValues": [1.0, 2.0, 3.0], "Values": [1.8,2.8,3.8]}, shapes.Site(4.0, 1.0): { "IMT": "PGA", "IDmodel": "FIXED", "timeSpanDuration": 50.0, "endBranchLabel": "label2", "IMLValues": [1.0, 2.0, 3.0], "Values": [1.5,2.5,3.5]} } print "data: %s" % data print nrmls self.assertEqual(2, len(nrmls.items())) self.assertEquals(data, nrmls)
def test_the_same_calculator_is_used_between_multiple_invocations(self): calculator = scenario.ScenarioHazardCalculator(self.job_ctxt) gmf_calculator1 = calculator.gmf_calculator([shapes.Site(1.0, 1.0)]) gmf_calculator2 = calculator.gmf_calculator([shapes.Site(1.0, 1.0)]) self.assertTrue(gmf_calculator1 == gmf_calculator2)
def setUp(self): self.loss_curve_path = helpers.get_output_path(LOSS_XML_OUTPUT_FILE) self.loss_ratio_curve_path = helpers.get_output_path( LOSS_RATIO_XML_OUTPUT_FILE) self.single_loss_curve_path = helpers.get_output_path( SINGLE_LOSS_XML_OUTPUT_FILE) self.single_loss_ratio_curve_path = helpers.get_output_path( SINGLE_LOSS_RATIO_XML_OUTPUT_FILE) self.schema_path = NRML_SCHEMA_PATH # Build up some sample loss/loss ratio curves here first_site = shapes.Site(-117.0, 38.0) second_site = shapes.Site(-118.0, 39.0) first_asset = models.ExposureData(asset_ref='a1711') second_asset = models.ExposureData(asset_ref='a1712') self.loss_curves = [(first_site, (TEST_LOSS_CURVE, first_asset)), (second_site, (TEST_LOSS_CURVE, second_asset))] self.loss_ratio_curves = [ (first_site, (TEST_LOSS_RATIO_CURVE, first_asset)), (second_site, (TEST_LOSS_RATIO_CURVE, second_asset)) ] self.single_loss_curve = [(first_site, (TEST_LOSS_CURVE, first_asset))] self.single_loss_ratio_curve = [(first_site, (TEST_LOSS_RATIO_CURVE, first_asset))] # loss curve that fails with inconsistent sites for an asset self.loss_curves_fail = [(first_site, (TEST_LOSS_CURVE, first_asset)), (second_site, (TEST_LOSS_CURVE, first_asset))]
def test_asset_losses_per_site(self): mm = mock.MagicMock(spec=redis.Redis) mm.get.return_value = 0.123 with helpers.patch('openquake.kvs.get_client') as mgc: mgc.return_value = mm def coords(item): return item[0].coords expected = [(shapes.Site(10.0, 10.0), [({ 'value': 0.123 }, GRID_ASSETS[(0, 0)])]), (shapes.Site(10.1, 10.0), [({ 'value': 0.123 }, GRID_ASSETS[(0, 1)])]), (shapes.Site(10.0, 10.1), [({ 'value': 0.123 }, GRID_ASSETS[(1, 0)])]), (shapes.Site(10.1, 10.1), [({ 'value': 0.123 }, GRID_ASSETS[(1, 1)])])] calculator = general.BaseRiskCalculator(self.job_ctxt) actual = calculator.asset_losses_per_site(0.5, self.grid_assets) expected = sorted(expected, key=coords) actual = sorted(actual, key=coords) self.assertEqual(expected, actual)
def test_region_sites_boundary_2(self): # same as above, but for latitude region = shapes.Region.from_coordinates([(1.0, 2.0), (2.0, 2.0), (2.0, 0.6), (1.0, 0.6)]) region.cell_size = 0.5 self.assertTrue( region.grid.site_at(region.grid.point_at(shapes.Site(1.5, 0.61))) in region.grid.centers()) self.assertTrue( region.grid.site_at(region.grid.point_at(shapes.Site(1.5, 0.60))) in region.grid.centers()) self.assertTrue( region.grid.site_at(region.grid.point_at(shapes.Site(1.5, 2.0))) in region.grid.centers()) self.assertTrue( region.grid.site_at(region.grid.point_at(shapes.Site(1.5, 1.9))) in region.grid.centers()) self.assertTrue( region.grid.site_at(region.grid.point_at(shapes.Site(1.5, 1.8))) in region.grid.centers()) # check we can ask for valid grid points from # the sites that represent the center of the cells for cell_center in region.grid.centers(): self.assertTrue(region.grid.site_inside(cell_center))
def test_writes_the_config_only_once(self): data = [(shapes.Site(-122.5000, 37.5000), { "IDmodel": "MMI_3_1", "investigationTimeSpan": 50.0, "endBranchLabel": "3_1", "IMLValues": [5.0, 6.0, 7.0], "saPeriod": 0.1, "saDamping": 1.0, "IMT": "PGA", "PoEValues": [0.1, 0.2, 0.3] }), (shapes.Site(-122.4000, 37.5000), { "IDmodel": "MMI_3_1", "investigationTimeSpan": 50.0, "endBranchLabel": "3_2", "IMLValues": [5.0, 6.0, 7.0], "saPeriod": 0.1, "saDamping": 1.0, "IMT": "PGA", "PoEValues": [0.4, 0.5, 0.6] })] path = test.do_test_output_file(TEST_FILE_CONFIG_ONCE) self._initialize_writer(path) self.writer.serialize(data) self._is_xml_valid(path)
def test_the_same_calculator_is_used_between_multiple_invocations(self): calculator = det.DeterministicEventBasedMixin(None, None) calculator.params = self.engine.params gmf_calculator1 = calculator.gmf_calculator([shapes.Site(1.0, 1.0)]) gmf_calculator2 = calculator.gmf_calculator([shapes.Site(1.0, 1.0)]) self.assertTrue(gmf_calculator1 == gmf_calculator2)
def test_computes_all_the_levels_specified(self): self._store_dummy_hazard_curve(shapes.Site(2.0, 5.0)) self._run([shapes.Site(2.0, 5.0)], 1, [0.25, 0.50, 0.75]) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.25) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.50) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.75)
def test_computes_all_the_levels_specified(self): self.params[self.poes_levels] = "0.10 0.20 0.50" self._run() self._has_computed_IML_for_site(shapes.Site(2.0, 5.0), 0.10) self._has_computed_IML_for_site(shapes.Site(2.0, 5.0), 0.20) self._has_computed_IML_for_site(shapes.Site(2.0, 5.0), 0.50)
def test_eq_with_rounded_lon_lat(self): """ Test Site equality comparisons when using high-precision lon/lat values (which are rounded down when the Site object is created). """ site1 = shapes.Site(-121.0, 29.0000001) site2 = shapes.Site(-121.00000004, 29.00000006) self.assertEqual(site1, site2)
def test_not_eq(self): # Test __eq__ with 2 Blocks that should not be equal block1 = Block(7, 0, [shapes.Site(1.0, 1.0)]) block2 = Block(8, 0, [shapes.Site(1.0, 1.0)]) self.assertFalse(block1 == block2) block1 = Block(7, 0, [shapes.Site(1.0, 1.0)]) block2 = Block(7, 1, [shapes.Site(1.0, 1.0)]) self.assertFalse(block1 == block2)
def test_hazard_input_is_the_exposure_site(self): # when `COMPUTE_HAZARD_AT_ASSETS_LOCATIONS` is specified, # the hazard must be looked up on the same risk location # (the input parameter of the function) params = {config.COMPUTE_HAZARD_AT_ASSETS: True} job_ctxt = engine.JobContext(params, None) self.assertEqual(shapes.Site(1.0, 1.0), hazard_input_site(job_ctxt, shapes.Site(1.0, 1.0)))
def __init__(self, *args, **kwargs): super(DoCurvesTestCase, self).__init__(*args, **kwargs) self.keys = [] self.sites = [ shapes.Site(-121.9, 38.0), shapes.Site(-121.8, 38.0), shapes.Site(-122.9, 38.0), shapes.Site(-122.8, 38.0) ]
def test_hash_with_rounded_lon_lat(self): """ Test the __hash__() equality of two Sites when using high-precision lon/lat values (which are rounded down when the Site object is created). """ site1 = shapes.Site(-121.0, 29.0000001) site2 = shapes.Site(-121.00000004, 29.00000006) self.assertEqual(site1.__hash__(), site2.__hash__())
def test_hash(self): """ Verify that two Sites with the same lon/lat have the same __hash__(). """ lon = 121.0 lat = 29.0 site1 = shapes.Site(lon, lat) site2 = shapes.Site(lon, lat) self.assertEqual(site1.__hash__(), site2.__hash__())
def test_site_precision_matters(self): FLAGS.distance_precision = 11 lat = 10.5 lon = -49.5 first_site = shapes.Site(lon, lat) lat += 0.0000001 lon += 0.0000001 second_site = shapes.Site(lon, lat) self.assertEqual(first_site, second_site) FLAGS.distance_precision = 12 self.assertNotEqual(first_site, second_site)
def test_just_numeric_values_are_allowed(self): self.params[self.quantiles_levels] = \ "-0.33 0.00 XYZ 0.50 ;;; 1.00 BBB" self._run([shapes.Site(2.0, 5.0)]) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.00) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 0.50) self._has_computed_quantile_for_site(shapes.Site(2.0, 5.0), 1.00) self._no_computed_quantiles_for(0.33)
def test_eq(self): """ Test Site equality comparisons. Two sites with the same lon/lat should be considered equal. """ lon = 121.0 lat = 29.0 site1 = shapes.Site(lon, lat) site2 = shapes.Site(lon, lat) self.assertEqual(site1, site2)
def test_an_empty_hazard_curve_produces_an_empty_quantile_curve(self): hazard_curve = [] self._store_hazard_curve_at(shapes.Site(2.0, 5.0), hazard_curve) self._run([shapes.Site(2.0, 5.0)], 1, [0.75]) result = kvs.get_value_json_decoded( kvs.tokens.quantile_hazard_curve_key(self.job_id, shapes.Site(2.0, 5.0), 0.75)) # no values self.assertTrue(numpy.allclose([], numpy.array(result)))
def test_serialize(self): data = [(shapes.Site(1.0, 1.0), { "groundMotionValue": 0.25, "path": "filea" }), (shapes.Site(1.0, 2.0), { "groundMotionValue": 0.35, "path": "fileb" })] self.writer.serialize(data) self.assertTrue(xml.validates_against_xml_schema(self.FILENAME))
def test_prepares_blocks_using_the_exposure(self): a_job = Job({ EXPOSURE: os.path.join(test.SCHEMA_EXAMPLES_DIR, EXPOSURE_TEST_FILE) }) a_job._partition() blocks_keys = a_job.blocks_keys expected_block = job.Block( (shapes.Site(9.15000, 45.16667), shapes.Site(9.15333, 45.12200), shapes.Site(9.14777, 45.17999))) self.assertEqual(1, len(blocks_keys)) self.assertEqual(expected_block, job.Block.from_kvs(blocks_keys[0]))
def test_sites_can_be_keys(self): """ Site objects can be dictionary keys, So must hash reliably.""" lat = 10.5 lon = -49.5 first_site = shapes.Site(lon, lat) second_site = shapes.Site(lon, lat) sites = {} sites[first_site] = "one" sites[second_site] = "two" # BOTH will now be "two"! This is correct self.assertEqual(first_site, second_site) self.assertEqual(sites[first_site], "two") self.assertEqual(sites[second_site], "two")
def test_block_kvs_serialization(self): # Test that a Block is properly serialized/deserialized from the cache. job_id = 7 block_id = 0 expected_block = Block(job_id, block_id, [shapes.Site(1.0, 1.0), shapes.Site(2.0, 2.0)]) expected_block.to_kvs() actual_block = Block.from_kvs(job_id, block_id) self.assertEqual(expected_block, actual_block) # The sites are not compared in Block.__eq__; we need to check those # also. self.assertEqual(expected_block.sites, actual_block.sites)
def test_hazard_input_is_the_cell_center(self): # when `COMPUTE_HAZARD_AT_ASSETS_LOCATIONS` is not specified, # the hazard must be looked up on the center of the cell # where the given site falls in params = {config.INPUT_REGION: \ "1.0, 1.0, 2.0, 1.0, 2.0, 2.0, 1.0, 2.0", config.REGION_GRID_SPACING: 0.5} job_ctxt = engine.JobContext(params, None) self.assertEqual(shapes.Site(1.0, 1.0), hazard_input_site(job_ctxt, shapes.Site(1.2, 1.2))) self.assertEqual(shapes.Site(1.5, 1.5), hazard_input_site(job_ctxt, shapes.Site(1.6, 1.6)))