def test_invalid_disagg_calc(self):
expected_errors = {
'mag_bin_width': ['Magnitude bin width must be > 0.0'],
'distance_bin_width': ['Distance bin width must be > 0.0'],
'coordinate_bin_width': ['Coordinate bin width must be > 0.0'],
'num_epsilon_bins': ['Number of epsilon bins must be > 0'],
'truncation_level': ['Truncation level must be > 0 for'
' disaggregation calculations'],
'poes_disagg': ['PoEs for disaggregation must be in the range'
' [0, 1]'],
}
self.hc.mag_bin_width = 0.0
self.hc.distance_bin_width = 0.0
self.hc.coordinate_bin_width = 0.0 # decimal degrees
self.hc.num_epsilon_bins = 0
self.hc.poes_disagg = [1.00001, -0.5, 0.0]
self.hc.truncation_level = 0.0
form = validation.DisaggHazardForm(instance=self.hc, files=None)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
# test with an empty `poes_disagg` list
self.hc.poes_disagg = []
form = validation.DisaggHazardForm(instance=self.hc, files=None)
expected_errors['poes_disagg'] = [(
'`poes_disagg` must contain at least 1 value')]
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_simple_to_hazardlib(self):
exp = self._expected_simple
actual = self.nrml_to_hazardlib(self.simple)
eq, msg = helpers.deep_eq(exp, actual)
self.assertTrue(eq, msg)
def test_characteristic_multi(self):
exp = self._expected_char_multi
actual = self.nrml_to_hazardlib(self.char_multi)
eq, msg = helpers.deep_eq(exp, actual)
self.assertTrue(eq, msg)
def test_point_to_hazardlib(self):
exp = self._expected_point
actual = self.nrml_to_hazardlib(self.point)
eq, msg = helpers.deep_eq(exp, actual)
self.assertTrue(eq, msg)
def test_area_to_hazardlib(self):
exp = self._expected_area
actual = self.nrml_to_hazardlib(self.area)
eq, msg = helpers.deep_eq(exp, actual)
self.assertTrue(eq, msg)
def test_complex_to_hazardlib(self):
exp = self._expected_complex
actual = self.nrml_to_hazardlib(self.cmplx)
eq, msg = helpers.deep_eq(exp, actual)
self.assertTrue(eq, msg)
def test_invalid_disagg_calc_truncation_not_set(self):
expected_errors = {
'mag_bin_width': ['Magnitude bin width must be > 0.0'],
'distance_bin_width': ['Distance bin width must be > 0.0'],
'coordinate_bin_width': ['Coordinate bin width must be > 0.0'],
'num_epsilon_bins': ['Number of epsilon bins must be > 0'],
'truncation_level': ['Truncation level must be set for'
' disaggregation calculations'],
'poes_disagg': ['PoEs for disaggregation must be in the range'
' [0, 1]'],
}
self.hc.truncation_level = None
self.hc.mag_bin_width = 0.0
self.hc.distance_bin_width = 0.0
self.hc.coordinate_bin_width = 0.0 # decimal degrees
self.hc.num_epsilon_bins = 0
self.hc.poes_disagg = [1.00001, -0.5, 0.0]
form = validation.DisaggHazardForm(instance=self.hc, files=None)
self.assertFalse(form.is_valid())
helpers.deep_eq(expected_errors, dict(form.errors))
def test_hazard_calculation_is_not_valid_missing_grid_spacing(self):
expected_errors = {
'region': ['`region` requires `region_grid_spacing`'],
}
self.hc.region_grid_spacing = None
form = validation.ClassicalHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_ses_per_logic_tree_path_is_not_valid(self):
expected_errors = {
'ses_per_logic_tree_path': [
'`Stochastic Event Sets Per Sample` (ses_per_logic_tree_path) '
'must be > 0'],
}
self.hc.ses_per_logic_tree_path = -1
form = validation.EventBasedHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_hazard_calculation_is_not_valid_missing_export_dir(self):
# When the user specifies '--exports' on the command line the
# 'export_dir' parameter must be present in the .ini file.
err = ('--exports specified on the command line but the '
'"export_dir" parameter is missing in the .ini file')
expected_errors = {
'export_dir': [err],
}
form = validation.ClassicalHazardForm(
instance=self.hc, files=None, exports=['xml']
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_gmfs_false_hazard_curves_true(self):
# An error should be raised if `hazard_curves_from_gmfs` is `True`, but
# `ground_motion_fields` is `False`.
# GMFs are needed to compute hazard curves.
expected_errors = {
'hazard_curves_from_gmfs': ['`hazard_curves_from_gmfs` requires '
'`ground_motion_fields` to be `true`'],
}
self.hc.ground_motion_fields = False
self.hc.hazard_curves_from_gmfs = True
form = validation.EventBasedHazardForm(instance=self.hc, files=None)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_invalid_scenario_calc(self):
expected_errors = {
'gsim': ["The gsim u'BooreAtkinson208' is not in in \
openquake.hazardlib.gsim"],
'number_of_ground_motion_fields': [
'The number_of_ground_motion_fields must be a positive '
'integer, got -10']
}
self.hc.number_of_ground_motion_fields = -10
self.hc.gsim = 'BooreAtkinson208'
form = validation.ScenarioHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_classical_hc_hazard_maps_uhs_no_poes(self):
# Test that errors are reported if `hazard_maps` and
# `uniform_hazard_spectra` are `true` but no `poes` are
# specified.
expected_errors = {
'hazard_maps': ['`poes` are required to compute hazard maps'],
'uniform_hazard_spectra': ['`poes` are required to compute UHS'],
}
self.hc.hazard_maps = True
self.hc.uniform_hazard_spectra = True
self.hc.poes = None
form = validation.ClassicalHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_hazard_calculation_is_not_valid_sites_only(self):
expected_errors = {
'sites': [
'Longitude values must in the range [-180, 180]',
'Latitude values must be in the range [-90, 90]',
],
}
self.hc.region = None
self.hc.region_grid_spacing = None
self.hc.sites = 'MULTIPOINT((-180.001 90.001), (180.001 -90.001))'
form = validation.ClassicalHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_hazard_curves_from_gmf_no_iml_imt(self):
# Test a configuration where the user has requested to post-process
# GMFs into hazard curves.
# In this case, the configuration is missing the required
# `intensity_measure_types_and_levels`.
expected_errors = {
'intensity_measure_types_and_levels': [
'`hazard_curves_from_gmfs` requires '
'`intensity_measure_types_and_levels`'],
}
self.hc.intensity_measure_types_and_levels = None
form = validation.EventBasedHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_invalid_imts(self):
expected_errors = {
'intensity_measure_types': [
'SA(-0.1): SA period values must be >= 0',
('SA<2.5>: SA must be specified with a period value, in the '
'form `SA(N)`, where N is a value >= 0'),
'SA(2x): SA period value should be a float >= 0',
'PGZ: Invalid intensity measure type',
],
}
self.hc.intensity_measure_types = INVALID_IML_IMT.keys()
self.hc.intensity_measure_types_and_levels = None
self.hc.hazard_curves_from_gmfs = False
form = validation.EventBasedHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_hazard_calculation_is_not_valid_region_only(self):
expected_errors = {
'region_grid_spacing': ['Region grid spacing must be > 0'],
'region': [
'Invalid region geomerty: Self-intersection[0 0]',
'Region geometry can only be a single linear ring',
'Longitude values must in the range [-180, 180]',
'Latitude values must be in the range [-90, 90]'],
}
self.hc.region_grid_spacing = 0
self.hc.region = (
'POLYGON((-180.001 90.001, 180.001 -90.001, -179.001 -89.001, '
'179.001 89.001, -180.001 90.001), (1 1, 2 2, 3 3, 4 4, 1 1))'
)
form = validation.ClassicalHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_hazard_curves_from_gmf_invalid_iml_imt(self):
# Test a configuration where the user has requested to post-process
# GMFs into hazard curves.
# In this case, the configuration has the required
# `intensity_measure_types_and_levels`, but the IMTs are not a subset
# of `intensity_measure_types`.
expected_errors = {
'intensity_measure_types_and_levels': [
'Unknown IMT(s) [SA(0)] in `intensity_measure_types`'],
}
iml_imt = VALID_IML_IMT.keys()
iml_imt.pop()
self.hc.intensity_measure_types = iml_imt
self.hc.intensity_measure_types_and_levels = VALID_IML_IMT
form = validation.EventBasedHazardForm(
instance=self.hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
def test_hazard_calculation_is_not_valid(self):
# test with an invalid job profile
# several parameters are given invalid values
expected_errors = {
'area_source_discretization': [
'Area source discretization must be > 0',
],
'calculation_mode': [
'Calculation mode must be "classical"',
],
'investigation_time': ['Investigation time must be > 0'],
'maximum_distance': ['Maximum distance must be > 0'],
'number_of_logic_tree_samples': [
'Number of logic tree samples must be >= 0',
],
'poes': [
'`poes` values must be in the range [0, 1]',
],
'quantile_hazard_curves': [
'Quantile hazard curve values must in the range [0, 1]'
],
'random_seed': [
'Random seed must be a value from -2147483648 to 2147483647 '
'(inclusive)',
],
'rupture_mesh_spacing': ['Rupture mesh spacing must be > 0'],
'truncation_level': ['Truncation level must be >= 0'],
'width_of_mfd_bin': ['Width of MFD bin must be > 0'],
'intensity_measure_types_and_levels': [
'SA(-0.1): SA period values must be >= 0',
('SA<2.5>: SA must be specified with a period value, in the '
'form `SA(N)`, where N is a value >= 0'),
'IA: IMLs must be > 0',
'PGD: IML lists must have at least 1 value',
'SA(2x): SA period value should be a float >= 0',
'PGA: IMLs must be > 0',
'PGZ: Invalid intensity measure type',
'SA(0.025): IML lists must have at least 1 value',
'MMI: IMLs must be specified as a list of floats',
],
'region': ['Cannot specify `region` and `sites`. Choose one.'],
'reference_vs30_value': ['Reference VS30 value must be > 0'],
'reference_vs30_type': [
'Reference VS30 type must be either "measured" or "inferred"',
],
'reference_depth_to_1pt0km_per_sec': [
'Reference depth to 1.0 km/sec must be > 0',
],
'reference_depth_to_2pt5km_per_sec': [
'Reference depth to 2.5 km/sec must be > 0',
],
}
hc = models.HazardCalculation.create(
description='',
region=(
'POLYGON((-122.0 38.113, -122.114 38.113, -122.57 38.111, '
'-122.0 38.113))'
),
region_grid_spacing=0,
sites='-122.0 38.113 , -122.114,38.113',
calculation_mode='Classical',
random_seed=2147483648,
number_of_logic_tree_samples=-1,
rupture_mesh_spacing=0,
width_of_mfd_bin=0,
area_source_discretization=0,
reference_vs30_type=None,
reference_vs30_value=0,
reference_depth_to_2pt5km_per_sec=0,
reference_depth_to_1pt0km_per_sec=0,
investigation_time=0,
intensity_measure_types_and_levels=INVALID_IML_IMT,
truncation_level=-0.1,
maximum_distance=0,
quantile_hazard_curves=[0.0, -0.1, 1.1],
poes=[1.00001, -0.5, 0.0],
)
form = validation.ClassicalHazardForm(
instance=hc, files=None
)
self.assertFalse(form.is_valid())
equal, err = helpers.deep_eq(expected_errors, dict(form.errors))
self.assertTrue(equal, err)
