def test(self):
evenly_discretized = EvenlyDiscretizedMFD(
min_mag=0.2, bin_width=0.3, occurrence_rates=[2.1, 2.4, 5.3]
)
self.assertEqual(evenly_discretized.get_annual_occurrence_rates(),
[(0.2, 2.1), (0.5, 2.4), (0.8, 5.3)])
self.assertEqual(evenly_discretized.get_min_mag(), 0.2)
def setUp(self):
super(PointSourceSourceFilterTestCase, self).setUp()
self.sitecol = SiteCollection(self.SITES)
self.source1 = make_point_source(
mfd=EvenlyDiscretizedMFD(min_mag=5,
bin_width=1,
occurrence_rates=[1]),
rupture_aspect_ratio=1.9,
upper_seismogenic_depth=0,
lower_seismogenic_depth=18.5,
magnitude_scaling_relationship=PeerMSR(),
nodal_plane_distribution=PMF([
(0.5, NodalPlane(strike=1, dip=2, rake=3)),
(0.5, NodalPlane(strike=1, dip=20, rake=3)),
]),
location=Point(2.0, 0.0),
)
self.source2 = make_point_source(
mfd=EvenlyDiscretizedMFD(min_mag=6.5,
bin_width=1,
occurrence_rates=[1]),
rupture_aspect_ratio=0.5,
upper_seismogenic_depth=0,
lower_seismogenic_depth=18.5,
magnitude_scaling_relationship=PeerMSR(),
nodal_plane_distribution=PMF([
(0.5, NodalPlane(strike=1, dip=10, rake=3)),
(0.5, NodalPlane(strike=1, dip=20, rake=3)),
]),
location=Point(2.0, 0.0),
)
def test(self):
evenly_discretized = EvenlyDiscretizedMFD(
min_mag=0.2, bin_width=0.3, occurrence_rates=[2.1, 2.4, 5.3]
)
self.assertEqual(evenly_discretized.get_annual_occurrence_rates(),
[(0.2, 2.1), (0.5, 2.4), (0.8, 5.3)])
self.assertEqual(evenly_discretized.get_min_max_mag(), (0.2, 0.8))
def test_modify_mfd(self):
mfd = EvenlyDiscretizedMFD(min_mag=4.0, bin_width=0.1,
occurrence_rates=[1, 2, 3])
mfd.modify(
"set_mfd",
{"min_mag": 4.5, "bin_width": 0.2, "occurrence_rates": [4, 5, 6]})
self.assertAlmostEqual(mfd.min_mag, 4.5)
self.assertAlmostEqual(mfd.bin_width, 0.2)
self.assertListEqual(mfd.occurrence_rates, [4, 5, 6])
def test_modify_mfd(self):
mfd = EvenlyDiscretizedMFD(min_mag=4.0, bin_width=0.1,
occurrence_rates=[1, 2, 3])
mfd.modify(
"set_mfd",
{"min_mag": 4.5, "bin_width": 0.2, "occurrence_rates": [4, 5, 6]})
self.assertAlmostEqual(mfd.min_mag, 4.5)
self.assertAlmostEqual(mfd.bin_width, 0.2)
self.assertListEqual(mfd.occurrence_rates, [4, 5, 6])
def setUp(self):
self.mfd = EvenlyDiscretizedMFD(4.4, 0.1, [0.5, 0.4, 0.3, 0.2])
self.mfd1 = EvenlyDiscretizedMFD(4.4, 0.1, [0.5, 0.4])
self.mfd2 = EvenlyDiscretizedMFD(4.05, 0.1, [0.5, 0.4])
# This is the MFD for source HUAS082 in the SHARE (2013) model
# with just area sources
rates = [0.000890073609248, 0.000561598480883, 0.000354344686162,
0.000223576382212, 0.000141067160409, 8.90073609248e-05,
5.61598480883e-05, 3.54344686162e-05, 2.23576382212e-05,
1.41067160409e-05, 8.90073609248e-06, 2.8088205502e-06,
3.54240181229e-07, 2.23510444056e-07]
self.mfd3 = EvenlyDiscretizedMFD(4.7, 0.2, rates)
def _setup_fault_source():
"""
Builds a fault source using the PEER Bending Fault case.
"""
point_order_dipping_east = [
Point(-64.78365, -0.45236),
Point(-64.80164, -0.45236),
Point(-64.90498, -0.36564),
Point(-65.0000, -0.16188),
Point(-65.0000, 0.0000)
]
trace_dip_east = Line(point_order_dipping_east)
fault_surface1 = SimpleFaultSurface.from_fault_data(
trace_dip_east, 0.0, 12.0, 60., 1.0)
# Activity Rates
# cm per km2
area = 60. * 12.0 / np.sin(np.radians(60.))
cm2perkm2 = (100. * 1000.)**2.
mo1 = 3.0E11 * 0.2 * (area * cm2perkm2)
mo_m6p75 = 10.0**(16.05 + 1.5 * 6.75)
rate1 = mo1 / mo_m6p75
mfd1 = EvenlyDiscretizedMFD(6.75, 0.01, [rate1])
tom = PoissonTOM(1.0)
aspect = 2.0
rake = 90.0
src = SimpleFaultSource("PEER_FLT_EAST", "PEER Bending Fault Dipping East",
"Active Shallow Crust", mfd1, 1.0, PeerMSR(), 2.0,
tom, 0.0, 12.0, trace_dip_east, 60.0, rake)
src.num_ruptures = src.count_ruptures()
return src
def get_background_sources(self, src_filter):
"""
Turn the background model of a given branch into a set of point sources
:param src_filter:
SourceFilter instance
"""
background_sids = self.get_background_sids(src_filter)
with h5py.File(self.source_file, "r") as hdf5:
grid_loc = "/".join(["Grid", self.idx_set["grid_key"]])
mags = hdf5[grid_loc + "/Magnitude"].value
mmax = hdf5[grid_loc + "/MMax"][background_sids]
rates = hdf5[grid_loc + "/RateArray"][background_sids, :]
locations = hdf5["Grid/Locations"][background_sids, :]
sources = []
for i, bg_idx in enumerate(background_sids):
src_id = "_".join([self.idx_set["grid_key"], str(bg_idx)])
src_name = "|".join([self.idx_set["total_key"], str(bg_idx)])
# Get MFD
mag_idx = numpy.logical_and(mags >= self.min_mag,
mags < mmax[i])
src_mags = mags[mag_idx]
src_rates = rates[i, :]
src_mfd = EvenlyDiscretizedMFD(src_mags[0],
src_mags[1] - src_mags[0],
src_rates[mag_idx].tolist())
ps = PointSource(src_id, src_name, self.tectonic_region_type,
src_mfd, self.mesh_spacing, self.msr,
self.aspect, self.tom, self.usd, self.lsd,
Point(locations[i, 0],
locations[i, 1]), self.npd, self.hdd)
ps.src_group_id = self.src_group_id
sources.append(ps)
return sources
def get_background_sources(self):
"""
Turn the background model of a given branch into a set of point sources
"""
background_sids = self.get_background_sids()
with h5py.File(self.source_file, "r") as hdf5:
grid_loc = "/".join(["Grid", self.ukey["grid_key"]])
# for instance Grid/FM0_0_MEANFS_MEANMSR_MeanRates
mags = hdf5[grid_loc + "/Magnitude"][()]
mmax = hdf5[grid_loc + "/MMax"][background_sids]
rates = hdf5[grid_loc + "/RateArray"][background_sids, :]
locations = hdf5["Grid/Locations"][background_sids, :]
sources = []
for i, bg_idx in enumerate(background_sids):
src_id = "_".join([self.ukey["grid_key"], str(bg_idx)])
src_name = "|".join([self.ukey["total_key"], str(bg_idx)])
mag_idx = (self.min_mag <= mags) & (mags < mmax[i])
src_mags = mags[mag_idx]
src_mfd = EvenlyDiscretizedMFD(src_mags[0],
src_mags[1] - src_mags[0],
rates[i, mag_idx].tolist())
ps = PointSource(src_id, src_name, self.tectonic_region_type,
src_mfd, self.mesh_spacing, self.msr,
self.aspect, self.tom, self.usd, self.lsd,
Point(locations[i, 0],
locations[i, 1]), self.npd, self.hdd)
ps.checksum = zlib.adler32(pickle.dumps(vars(ps), protocol=4))
ps._wkt = ps.wkt()
ps.id = self.id
ps.et_id = self.et_id
ps.num_ruptures = ps.count_ruptures()
ps.nsites = 1 # anything <> 0 goes
sources.append(ps)
return sources
def test_Pago_VeianoMontaguto(self):
# regression test
fault_trace = Line([
Point(15.2368, 41.1594),
Point(15.1848, 41.1644),
Point(15.1327, 41.1694),
Point(15.0807, 41.1745),
Point(15.0286, 41.1795),
Point(14.9765, 41.1846),
Point(14.9245, 41.1896),
Point(14.8724, 41.1946),
Point(14.8204, 41.1997)
])
mfd = EvenlyDiscretizedMFD(min_mag=6.9,
bin_width=0.2,
occurrence_rates=[1.0])
dip = 70.0
upper_seismogenic_depth = 11.0
lower_seismogenic_depth = 25.0
rake = -130
scalerel = WC1994()
rupture_mesh_spacing = 5
rupture_aspect_ratio = 1
tom = PoissonTOM(10)
fault = SimpleFaultSource(
'ITCS057', 'Pago Veiano-Montaguto', TRT.ACTIVE_SHALLOW_CRUST, mfd,
rupture_mesh_spacing, scalerel, rupture_aspect_ratio, tom,
upper_seismogenic_depth, lower_seismogenic_depth, fault_trace, dip,
rake)
self.assertEqual(len(list(fault.iter_ruptures())), 1)
def build_fault_model(area, slip, mmax, config={}, mu=30.0, coupling=1.0):
"""
"""
if not config:
# Simple Dirac function
geological_moment = coupling * (mu * 1.0E9) * (area * 1.0E6) * (slip *
1.0E-3)
mmax_moment = moment_function(mmax)
rate = geological_moment / mmax_moment
mf_dist = EvenlyDiscretizedMFD(mmax, 0.1, [rate])
return get_incremental_cumulative(mf_dist)
d_m = config["MFD_spacing"]
config["Model_Weight"] = 1.0
if config["model"] == "Characteristic":
# Try characteristic
for key in ["MFD_spacing", "Lower_Bound", "Upper_Bound", "Sigma"]:
# Verify everything is present
assert key in config and config[key] is not None
rec_model = Characteristic()
rec_model.setUp(config)
rec_model.mmax = mmax
elif config["model"] == "Hybrid":
# Try Hybrid
for key in ["Minimum_Magnitude", "b_value"]:
# Verify everything is present
assert key in config and config[key] is not None
rec_model = YoungsCoppersmithCharacteristic()
rec_model.setUp(config)
rec_model.mmax = mmax
elif config["model"] == "Exponential":
# Try exponential
for key in ["Minimum_Magnitude", "b_value"]:
# Verify everything is present
assert key in config and config[key] is not None
rec_model = YoungsCoppersmithExponential()
rec_model.setUp(config)
rec_model.mmax = mmax
rec_model.mmin += (config["MFD_spacing"] / 2.)
else:
raise ValueError("Model %s not recognised" % config["model"])
mmin, bin_width, rate = rec_model.get_mfd(slip, area, mu)
mf_dist = EvenlyDiscretizedMFD(mmin, bin_width, rate.tolist())
return get_incremental_cumulative(mf_dist)
def setUp(self):
self.basic_trace = Line([Point(30.0, 30.0), Point(30.0, 32.0)])
self.mfd = EvenlyDiscretizedMFD(7.0, 0.1, [1.0])
self.aspect = 1.0
self.dip = 45.0
self.fault = self._make_source(self.mfd, self.aspect, self.basic_trace,
self.dip)
self.fault.lower_seismogenic_depth = 10.0
def test_modify_mfd_constraints(self):
mfd = EvenlyDiscretizedMFD(min_mag=4.0, bin_width=0.1,
occurrence_rates=[1, 2, 3])
exc = self.assert_mfd_error(
mfd.modify,
"set_mfd",
{"min_mag": 4.0, "bin_width": 0.1, "occurrence_rates": [-1, 2, 3]})
self.assertEqual(str(exc), 'all occurrence rates must not be negative')
def setUp(self):
top_edge_1 = Line([Point(30.0, 30.0, 1.0), Point(31.0, 30.0, 1.0)])
bottom_edge_1 = Line([Point(29.7, 29.9, 30.0),
Point(31.3, 29.9, 32.0)])
self.edges = [top_edge_1, bottom_edge_1]
self.mfd = EvenlyDiscretizedMFD(7.0, 0.1, [1.0])
self.aspect = 1.0
self.spacing = 5.0
self.rake = 90.
def setUp(self):
self.source_class = FakeSource
mfd = EvenlyDiscretizedMFD(min_mag=3, bin_width=1,
occurrence_rates=[5, 6, 7])
self.source = FakeSource('source_id', 'name', const.TRT.VOLCANIC,
mfd=mfd, rupture_mesh_spacing=2,
magnitude_scaling_relationship=PeerMSR(),
rupture_aspect_ratio=1,
temporal_occurrence_model=PoissonTOM(50.))
self.sitecol = SiteCollection(self.SITES)
def test_occurrence_rate_rescaling(self):
mfd = EvenlyDiscretizedMFD(min_mag=4, bin_width=1,
occurrence_rates=[3])
polygon = Polygon([Point(0, 0), Point(0, -0.2248),
Point(-0.2248, -0.2248), Point(-0.2248, 0)])
source = self.make_area_source(polygon, discretization=10, mfd=mfd)
self.assertIs(source.mfd, mfd)
ruptures = list(source.iter_ruptures())
self.assertEqual(len(ruptures), 8)
for rupture in ruptures:
self.assertNotEqual(rupture.occurrence_rate, 3)
self.assertEqual(rupture.occurrence_rate, 3.0 / 8.0)
def setUp(self):
class FakeSource(SeismicSource):
iter_ruptures = None
get_rupture_enclosing_polygon = None
self.source_class = FakeSource
mfd = EvenlyDiscretizedMFD(min_mag=3,
bin_width=1,
occurrence_rates=[5, 6, 7])
self.source = FakeSource('source_id',
'name',
const.TRT.VOLCANIC,
mfd=mfd,
rupture_mesh_spacing=2,
magnitude_scaling_relationship=PeerMSR(),
rupture_aspect_ratio=1)
self.sitecol = SiteCollection(self.SITES)
def setUp(self):
mfd = TruncatedGRMFD(min_mag=4.0,
max_mag=6.0,
bin_width=0.1,
a_val=2.0,
b_val=1.0)
msr = WC1994()
tom = PoissonTOM(1.0)
loc = Point(longitude=0.0,
latitude=0.0)
npd = PMF([(1.0, NodalPlane(0.0, 90.0, 0.0))])
hpd = PMF([(0.7, 10.), (0.3, 20.0)])
self.src1 = PointSource(source_id='1',
name='1',
tectonic_region_type='Test',
mfd=mfd,
rupture_mesh_spacing=1,
magnitude_scaling_relationship=msr,
rupture_aspect_ratio=1.,
temporal_occurrence_model=tom,
upper_seismogenic_depth=0,
lower_seismogenic_depth=100.,
location=loc,
nodal_plane_distribution=npd,
hypocenter_distribution=hpd)
mfd = EvenlyDiscretizedMFD(min_mag=4.0,
bin_width=0.1,
occurrence_rates=[3., 2., 1.])
self.src2 = PointSource(source_id='1',
name='1',
tectonic_region_type='Test',
mfd=mfd,
rupture_mesh_spacing=1,
magnitude_scaling_relationship=msr,
rupture_aspect_ratio=1.,
temporal_occurrence_model=tom,
upper_seismogenic_depth=0,
lower_seismogenic_depth=100.,
location=loc,
nodal_plane_distribution=npd,
hypocenter_distribution=hpd)
def test_rupture_close_to_south_pole(self):
# data taken from real example and causing "surface's angles are not
# right" error
mfd = EvenlyDiscretizedMFD(
min_mag=5., bin_width=0.1, occurrence_rates=[2.180e-07]
)
nodal_plane_dist = PMF([(1., NodalPlane(135., 20., 90.))])
src = PointSource(source_id='1', name='pnt', tectonic_region_type='asc',
mfd=mfd, rupture_mesh_spacing=1,
magnitude_scaling_relationship=WC1994(),
rupture_aspect_ratio=1.,
temporal_occurrence_model=PoissonTOM(50.),
upper_seismogenic_depth=0, lower_seismogenic_depth=26,
location=Point(-165.125, -83.600),
nodal_plane_distribution=nodal_plane_dist,
hypocenter_distribution=PMF([(1., 9.)]))
ruptures = list(src.iter_ruptures())
self.assertEqual(len(ruptures), 1)
def get_evenlyDiscretizedMFD_from_truncatedGRMFD(mfd, bin_width=None):
"""
This function converts a double truncated Gutenberg Richter distribution
into an almost equivalent discrete representation.
:parameter:
A instance of :class:`~openquake.hazardlib.mfd.TruncatedGRMFD`
:return:
An instance of :class:`~openquake.hazardlib.mfd.EvenlyDiscretizedMFD`
"""
assert isinstance(mfd, TruncatedGRMFD)
agr = mfd.a_val
bgr = mfd.b_val
bin_width = mfd.bin_width
left = np.arange(mfd.min_mag, mfd.max_mag, bin_width)
rates = 10.**(agr-bgr*left)-10.**(agr-bgr*(left+bin_width))
return EvenlyDiscretizedMFD(mfd.min_mag+bin_width/2.,
bin_width,
list(rates))
def setUp(self):
class FakeSource(ParametricSeismicSource):
MODIFICATIONS = set(())
iter_ruptures = None
count_ruptures = None
get_rupture_enclosing_polygon = None
self.source_class = FakeSource
mfd = EvenlyDiscretizedMFD(min_mag=3,
bin_width=1,
occurrence_rates=[5, 6, 7])
self.source = FakeSource('source_id',
'name',
const.TRT.VOLCANIC,
mfd=mfd,
rupture_mesh_spacing=2,
magnitude_scaling_relationship=PeerMSR(),
rupture_aspect_ratio=1,
temporal_occurrence_model=PoissonTOM(50.))
self.sitecol = SiteCollection(self.SITES)
def get_background_sources(self, sample_factor=None):
"""
Turn the background model of a given branch into a set of point sources
:param sample_factor:
Used to reduce the sources if OQ_SAMPLE_SOURCES is set
"""
background_sids = self.get_background_sids()
if sample_factor is not None: # hack for use in the mosaic
background_sids = random_filter(
background_sids, sample_factor, seed=42)
with h5py.File(self.source_file, "r") as hdf5:
grid_loc = "/".join(["Grid", self.idx_set["grid_key"]])
# for instance Grid/FM0_0_MEANFS_MEANMSR_MeanRates
mags = hdf5[grid_loc + "/Magnitude"][()]
mmax = hdf5[grid_loc + "/MMax"][background_sids]
rates = hdf5[grid_loc + "/RateArray"][background_sids, :]
locations = hdf5["Grid/Locations"][background_sids, :]
sources = []
for i, bg_idx in enumerate(background_sids):
src_id = "_".join([self.idx_set["grid_key"], str(bg_idx)])
src_name = "|".join([self.idx_set["total_key"], str(bg_idx)])
mag_idx = (self.min_mag <= mags) & (mags < mmax[i])
src_mags = mags[mag_idx]
src_mfd = EvenlyDiscretizedMFD(
src_mags[0],
src_mags[1] - src_mags[0],
rates[i, mag_idx].tolist())
ps = PointSource(
src_id, src_name, self.tectonic_region_type, src_mfd,
self.mesh_spacing, self.msr, self.aspect, self.tom,
self.usd, self.lsd,
Point(locations[i, 0], locations[i, 1]),
self.npd, self.hdd)
ps.checksum = zlib.adler32(pickle.dumps(vars(ps), protocol=4))
ps._wkt = ps.wkt()
ps.id = self.id
ps.grp_id = self.grp_id
ps.num_ruptures = ps.count_ruptures()
sources.append(ps)
return sources
def setUp(self):
self.mfd1 = EEvenlyDiscretizedMFD(4.5, 0.1, [0.5, 0.4, 0.3, 0.2])
self.mfd2 = EEvenlyDiscretizedMFD(4.4, 0.1, [0.5, 0.4, 0.3, 0.2])
self.mfd3 = EvenlyDiscretizedMFD(4.4, 0.05, [0.5, 0.4, 0.3, 0.2])
self.mfd4 = EvenlyDiscretizedMFD(4.4, 0.1, [0.5, 0.4, 0.3, 0.2,
0.1, 0.05, 0.025, 0.01])
self.mfd5 = EvenlyDiscretizedMFD(4.6, 0.1, [0.5, 0.4, 0.3, 0.2,
0.1, 0.05, 0.025, 0.01])
self.base = EEvenlyDiscretizedMFD(6.0, 0.1, [1e-20])
self.huas082 = EvenlyDiscretizedMFD(4.7, 0.2, [
0.000890073609248, 0.000561598480883, 0.000354344686162,
0.000223576382212, 0.000141067160409, 8.90073609248e-05,
5.61598480883e-05, 3.54344686162e-05, 2.23576382212e-05,
1.41067160409e-05, 8.90073609248e-06, 2.8088205502e-06,
3.54240181229e-07, 2.23510444056e-07])
self.mfd6 = EvenlyDiscretizedMFD(4.7, 0.01, [0.5])
self.mfd7 = EvenlyDiscretizedMFD(5.5, 0.01, [0.5])
def setUp(self):
super(SeismicSourceGetAnnOccRatesTestCase, self).setUp()
self.source.mfd = EvenlyDiscretizedMFD(min_mag=3,
bin_width=1,
occurrence_rates=[5, 0, 7, 0])
def test_zero_rate(self):
evenly_discretized = EvenlyDiscretizedMFD(min_mag=1,
bin_width=2,
occurrence_rates=[4, 0, 5])
self.assertEqual(evenly_discretized.get_annual_occurrence_rates(),
[(1, 4), (3, 0), (5, 5)])
def test_zero_min_mag(self):
mfd = EvenlyDiscretizedMFD(min_mag=0,
bin_width=1,
occurrence_rates=[1])
self.assertEqual(mfd.get_annual_occurrence_rates(), [(0, 1)])
self.assertEqual(mfd.get_min_max_mag(), (0, 0))
def test_7_many_ruptures(self):
source_id = name = 'test7-source'
trt = TRT.VOLCANIC
mag1 = 4.5
mag2 = 5.5
mag1_rate = 9e-3
mag2_rate = 9e-4
hypocenter1 = 9.0
hypocenter2 = 10.0
hypocenter1_weight = Decimal('0.8')
hypocenter2_weight = Decimal('0.2')
nodalplane1 = NodalPlane(strike=45, dip=90, rake=0)
nodalplane2 = NodalPlane(strike=0, dip=45, rake=10)
nodalplane1_weight = Decimal('0.3')
nodalplane2_weight = Decimal('0.7')
upper_seismogenic_depth = 2
lower_seismogenic_depth = 16
rupture_aspect_ratio = 2
rupture_mesh_spacing = 0.5
location = Point(0, 0)
magnitude_scaling_relationship = PeerMSR()
tom = PoissonTOM(time_span=50)
mfd = EvenlyDiscretizedMFD(min_mag=mag1,
bin_width=(mag2 - mag1),
occurrence_rates=[mag1_rate, mag2_rate])
nodal_plane_distribution = PMF([(nodalplane1_weight, nodalplane1),
(nodalplane2_weight, nodalplane2)])
hypocenter_distribution = PMF([(hypocenter1_weight, hypocenter1),
(hypocenter2_weight, hypocenter2)])
point_source = PointSource(
source_id, name, trt, mfd, rupture_mesh_spacing,
magnitude_scaling_relationship, rupture_aspect_ratio, tom,
upper_seismogenic_depth, lower_seismogenic_depth, location,
nodal_plane_distribution, hypocenter_distribution)
actual_ruptures = list(point_source.iter_ruptures())
self.assertEqual(len(actual_ruptures), point_source.count_ruptures())
expected_ruptures = {
(mag1, nodalplane1.rake, hypocenter1): (
# probabilistic rupture's occurrence rate
9e-3 * 0.3 * 0.8,
# rupture surface corners
planar_surface_test_data.TEST_7_RUPTURE_1_CORNERS),
(mag2, nodalplane1.rake, hypocenter1):
(9e-4 * 0.3 * 0.8,
planar_surface_test_data.TEST_7_RUPTURE_2_CORNERS),
(mag1, nodalplane2.rake, hypocenter1):
(9e-3 * 0.7 * 0.8,
planar_surface_test_data.TEST_7_RUPTURE_3_CORNERS),
(mag2, nodalplane2.rake, hypocenter1):
(9e-4 * 0.7 * 0.8,
planar_surface_test_data.TEST_7_RUPTURE_4_CORNERS),
(mag1, nodalplane1.rake, hypocenter2):
(9e-3 * 0.3 * 0.2,
planar_surface_test_data.TEST_7_RUPTURE_5_CORNERS),
(mag2, nodalplane1.rake, hypocenter2):
(9e-4 * 0.3 * 0.2,
planar_surface_test_data.TEST_7_RUPTURE_6_CORNERS),
(mag1, nodalplane2.rake, hypocenter2):
(9e-3 * 0.7 * 0.2,
planar_surface_test_data.TEST_7_RUPTURE_7_CORNERS),
(mag2, nodalplane2.rake, hypocenter2):
(9e-4 * 0.7 * 0.2,
planar_surface_test_data.TEST_7_RUPTURE_8_CORNERS)
}
for actual_rupture in actual_ruptures:
expected_occurrence_rate, expected_corners = expected_ruptures[(
actual_rupture.mag, actual_rupture.rake,
actual_rupture.hypocenter.depth)]
self.assertTrue(
isinstance(actual_rupture, ParametricProbabilisticRupture))
self.assertEqual(actual_rupture.occurrence_rate,
expected_occurrence_rate)
self.assertIs(actual_rupture.temporal_occurrence_model, tom)
self.assertEqual(actual_rupture.tectonic_region_type, trt)
surface = actual_rupture.surface
tl, tr, br, bl = expected_corners
self.assertEqual(tl, surface.top_left)
self.assertEqual(tr, surface.top_right)
self.assertEqual(bl, surface.bottom_left)
self.assertEqual(br, surface.bottom_right)
def mfd_upsample(bin_width, mfd):
"""
This is upsampling an MFD i.e. creating a new MFD with a larger
bin width.
:param bin_width:
:param mfd:
"""
#
# computing the min and max values of magnitude
ommin = mfd.min_mag
ommax = mfd.min_mag + len(mfd.occurrence_rates) * mfd.bin_width
#
# rounding the lower and upper magnitude limits to the new
# bin width
min_mag = np.floor(ommin / bin_width) * bin_width
max_mag = np.ceil(ommax / bin_width) * bin_width
#
# prepare the new array for occurrences
nocc = np.zeros((int((max_mag-min_mag)/bin_width+1), 4))
# set the new array
for idx, mag in enumerate(np.arange(min_mag, max_mag, bin_width)):
nocc[idx, 0] = mag
nocc[idx, 1] = mag-bin_width/2
nocc[idx, 2] = mag+bin_width/2
#
# create he arrays with magnitudes and occurrences
"""
mago = []
occo = []
for mag, occ in mfd.get_annual_occurrence_rates():
mago.append(mag)
occo.append(occo)
mago = np.array(mago)
occo = np.array(occo)
"""
#
# assigning occurrences
dlt = bin_width * 1e-5
for mag, occ in mfd.get_annual_occurrence_rates():
print(mag, occ)
#
# find indexes of lower bin limits lower than mag
idx = np.nonzero(mag+dlt-mfd.bin_width/2 > nocc[:, 1])[0]
idxa = None
idxb = None
# idxa is the index of the lower limit
if len(idx):
idxa = np.amax(idx)
else:
raise ValueError('Error in computing lower mag limit')
# find indexes of the bin centers with magnitude larger than mag
# idx = np.nonzero((mag+mfd.bin_width/2) > nocc[:, 2])[0]
idx = np.nonzero(mag-dlt+mfd.bin_width/2 < nocc[:, 2])[0]
if len(idx):
# idxb = np.amax(idx)
idxb = np.amin(idx)
#
#
print(idxa, idxb)
if idxb is not None and idxa == idxb:
nocc[idxa, 3] += occ
else:
# ratio of occurrences in the lower bin
ra = (nocc[idxa, 2] - (mag-mfd.bin_width/2)) / mfd.bin_width
nocc[idxa, 3] += occ*ra
if (1.0-ra) > 1e-10:
nocc[idxa+1, 3] += occ*(1-ra)
print(nocc)
#
# check that the the MFDs have the same total occurrence rate
smmn = sum(nocc[:, 3])
smmo = sum(mfd.occurrence_rates)
print(smmn, smmo)
#
# check that the total number of occurrences in the original and
# resampled MFDs are the same
assert abs(smmn-smmo) < 1e-5
idxs = set(np.arange(0, len(nocc[:, 3])))
iii = len(nocc[:, 3])-1
while nocc[iii, 3] < 1e-10:
idxs = idxs - set([iii])
iii -= 1
return EvenlyDiscretizedMFD(nocc[0, 0], bin_width,
list(nocc[list(idxs), 3]))
def mfd_downsample(bin_width, mfd):
"""
:parameter float bin_width:
:parameter mfd:
"""
ommin = mfd.min_mag
ommax = mfd.min_mag + len(mfd.occurrence_rates) * mfd.bin_width
if log:
print('ommax ', ommax)
print('bin_width ', mfd.bin_width)
# check that the new min_mag is a multiple of the bin width
min_mag = np.floor(ommin / bin_width) * bin_width
# lower min mag to make sure we cover the entire magnitude range
while min_mag-bin_width/2 > mfd.min_mag-mfd.bin_width/2:
min_mag -= bin_width
# preparing the list wchi will collect data
dummy = []
mgg = min_mag + bin_width / 2
while mgg < (ommax + 0.51 * mfd.bin_width):
if log:
print(mgg, ommax + mfd.bin_width/2)
dummy.append(mgg)
mgg += bin_width
# prepare the new array for occurrences
nocc = np.zeros((len(dummy), 4))
if log:
print('CHECK', len(nocc), len(dummy))
print(dummy)
#
boun = np.zeros((len(mfd.occurrence_rates), 4))
for idx, (mag, occ) in enumerate(mfd.get_annual_occurrence_rates()):
boun[idx, 0] = mag
boun[idx, 1] = mag-mfd.bin_width/2
boun[idx, 2] = mag+mfd.bin_width/2
boun[idx, 3] = occ
# init
for idx in range(0, len(nocc)):
mag = min_mag+bin_width*idx
nocc[idx, 0] = mag
nocc[idx, 1] = mag-bin_width/2
nocc[idx, 2] = mag+bin_width/2
rat = bin_width/mfd.bin_width
tol = 1e-10
for iii, mag in enumerate(list(nocc[:, 0])):
idx = np.nonzero(nocc[iii, 1] > (boun[:, 1]-tol))[0]
idxa = None
if len(idx):
idxa = np.amax(idx)
idx = np.nonzero(nocc[iii, 2] > boun[:, 2]-tol)[0]
idxb = None
if len(idx):
idxb = np.amax(idx)
if idxa is None and idxb is None and nocc[iii, 2] > boun[0, 1]:
nocc[0, 3] = ((nocc[iii, 2] - boun[0, 1]) / mfd.bin_width *
boun[0, 3])
elif idxa is None and idxb is None:
pass
elif idxa == 0 and idxb is None:
# This is the first bin when the lower limit of the two FMDs is
# not the same
nocc[iii, 3] += rat * boun[idxa, 3]
elif nocc[iii, 1] > boun[-1, 2]:
# Empty bin
pass
elif idxa > idxb:
# Bin entirely included in a bin of the original MFD
nocc[iii, 3] += rat * boun[idxa, 3]
else:
dff = (boun[idxa, 2] - nocc[iii, 1])
ra = dff / mfd.bin_width
nocc[iii, 3] += ra * boun[idxb, 3]
if len(boun) > 1 and nocc[iii, 1] < boun[-2, 2]:
dff = (nocc[iii, 2] - boun[idxa, 2])
ra = dff / mfd.bin_width
nocc[iii, 3] += ra * boun[idxa+1, 3]
idx0 = np.nonzero(nocc[:, 3] < 1e-20)
idx1 = np.nonzero(nocc[:, 3] > 1e-20)
if np.any(idx0 == 0):
raise ValueError('Rates in the first bin are equal to 0')
elif len(idx0):
nocc = nocc[idx1[0], :]
else:
pass
smmn = sum(nocc[:, 3])
smmo = sum(mfd.occurrence_rates)
if log:
print(nocc)
print('SUMS:', smmn, smmo)
assert abs(smmn-smmo) < 1e-5
return EvenlyDiscretizedMFD(nocc[0, 0], bin_width, list(nocc[:, 3]))
def setUp(self):
super().setUp()
self.source.mfd = EvenlyDiscretizedMFD(min_mag=3, bin_width=1,
occurrence_rates=[5, 0, 7, 0])
def setUp(self):
"""
Builds a simple dipping/bending fault source with a characteristic
source model. Compares the curves for four sites, two on the hanging
wall and two on the footwall.
The source model is taken from the PEER Tests
"""
point_order_dipping_east = [
Point(-64.78365, -0.45236),
Point(-64.80164, -0.45236),
Point(-64.90498, -0.36564),
Point(-65.0000, -0.16188),
Point(-65.0000, 0.0000)
]
trace_dip_east = Line(point_order_dipping_east)
site_1 = Site(Point(-64.98651, -0.15738), 760.0, True, 48.0, 0.607)
site_2 = Site(Point(-64.77466, -0.45686), 760.0, True, 48.0, 0.607)
site_3 = Site(Point(-64.92747, -0.38363), 760.0, True, 48.0, 0.607)
site_4 = Site(Point(-65.05396, -0.17088), 760.0, True, 48.0, 0.607)
self.sites = SiteCollection([site_1, site_2, site_3, site_4])
self.imtls = {
"PGA": [
0.001, 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45,
0.5, 0.55, 0.6, 0.7, 0.8, 0.9, 1.0
]
}
fault_surface1 = SimpleFaultSurface.from_fault_data(
trace_dip_east, 0.0, 12.0, 60., 0.5)
mfd1 = EvenlyDiscretizedMFD(6.75, 0.01, [0.01])
tom = PoissonTOM(1.0)
self.sources = [
CharacteristicFaultSource(
"PEER_CHAR_FLT_EAST",
"Peer Bending Fault Dipping East - Characteristic",
"Active Shallow Crust", mfd1, tom, fault_surface1, 90.0)
]
# We will check all the GMPEs
self.gsim_set = {
"ASK": [
AbrahamsonEtAl2014NSHMPMean(),
(0.185, AbrahamsonEtAl2014NSHMPLower()),
(0.63, AbrahamsonEtAl2014()),
(0.185, AbrahamsonEtAl2014NSHMPUpper())
],
"BSSA": [
BooreEtAl2014NSHMPMean(), (0.185, BooreEtAl2014NSHMPLower()),
(0.63, BooreEtAl2014()), (0.185, BooreEtAl2014NSHMPUpper())
],
"CB": [
CampbellBozorgnia2014NSHMPMean(),
(0.185, CampbellBozorgnia2014NSHMPLower()),
(0.63, CampbellBozorgnia2014()),
(0.185, CampbellBozorgnia2014NSHMPUpper())
],
"CY": [
ChiouYoungs2014NSHMPMean(),
(0.185, ChiouYoungs2014NSHMPLower()),
(0.63, ChiouYoungs2014()), (0.185, ChiouYoungs2014NSHMPUpper())
],
"ID": [
Idriss2014NSHMPMean(), (0.185, Idriss2014NSHMPLower()),
(0.63, Idriss2014()), (0.185, Idriss2014NSHMPUpper())
]
}
# fault_length = 25.0 * 1e3 # m
# fault_width = 12.0 * 1e3 # m
#
# The total seismic moment rate can be computed as:
#
# seismic_moment_rate = rigidity * fault_length * fault_width * slip_rate
#
# From which we can derived the incremental a value:
#
# a_incremental = log10(seismic_moment_rate) - (1.5 + b_value) * magnitude - 9.05
#
# and finally the rate:
#
# rate = 10 ** (a_incremental + b_value * magnitude)
SET1_CASE2_MFD = EvenlyDiscretizedMFD(min_mag=6.0,
bin_width=0.01,
occurrence_rates=[0.0160425168864])
SET1_CASE1TO9_RAKE = 0
# page A-3
SET1_CASE1TO9_FAULT_TRACE = Line(
[Point(-122.0, 38.0), Point(-122.0, 38.22480)])
# page A-17
SET1_CASE1TO9_UPPER_SEISMOGENIC_DEPTH = 0.0
SET1_CASE1TO9_LOWER_SEISMOGENIC_DEPTH = 12.0
SET1_CASE1TO9_DIP = 90
# page A-3
SET1_CASE1TO9_SITE1 = Site(location=Point(-122.000, 38.113),
vs30=800.0,
def test_zero_rate(self):
evenly_discretized = EvenlyDiscretizedMFD(
min_mag=1, bin_width=2, occurrence_rates=[4, 0, 5]
)
self.assertEqual(evenly_discretized.get_annual_occurrence_rates(),
[(1, 4), (3, 0), (5, 5)])
def test_zero_min_mag(self):
mfd = EvenlyDiscretizedMFD(min_mag=0, bin_width=1,
occurrence_rates=[1])
self.assertEqual(mfd.get_annual_occurrence_rates(), [(0, 1)])
self.assertEqual(mfd.get_min_max_mag(), (0, 0))