def test_simple(self):
lons = numpy.array([numpy.arange(-1, 1.2, 0.2)] * 11)
lats = lons.transpose() + 1
depths = lats + 10
mesh = RectangularMesh(lons, lats, depths)
check = lambda lon, lat, depth, expected_distance, **kwargs: \
self.assertAlmostEqual(
mesh.get_joyner_boore_distance(
Mesh.from_points_list([Point(lon, lat, depth)])
)[0],
expected_distance, **kwargs
)
check(lon=0, lat=0.5, depth=0, expected_distance=0)
check(lon=1, lat=1, depth=0, expected_distance=0)
check(lon=0.6,
lat=-1,
depth=0,
expected_distance=Point(0.6, -1).distance(Point(0.6, 0)),
delta=0.1)
check(lon=-0.8,
lat=2.1,
depth=10,
expected_distance=Point(-0.8, 2.1).distance(Point(-0.8, 2)),
delta=0.02)
check(lon=0.75,
lat=2.3,
depth=3,
expected_distance=Point(0.75, 2.3).distance(Point(0.75, 2)),
delta=0.04)
def test_even_rows_even_columns_with_depths(self):
lons = numpy.array([[10, 20], [12, 22]])
lats = numpy.array([[10, -10], [8, -9]])
depths = numpy.array([[2, 3], [4, 5]])
mesh = RectangularMesh(lons, lats, depths=depths)
self.assertEqual(mesh.get_middle_point(),
Point(15.996712, -0.250993, 3.5))
def test_rectangular(self):
lons = numpy.array(range(100)).reshape((10, 10))
lats = numpy.negative(lons)
mesh = RectangularMesh(lons, lats, depths=None)
bounding_mesh = mesh._get_bounding_mesh()
expected_lons = numpy.array([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
19, 29, 39, 49, 59, 69, 79, 89,
99, 98, 97, 96, 95, 94, 93, 92, 91,
90, 80, 70, 60, 50, 40, 30, 20, 10
])
expected_lats = numpy.negative(expected_lons)
self.assertTrue((bounding_mesh.lons == expected_lons).all())
self.assertTrue((bounding_mesh.lats == expected_lats).all())
self.assertIsNone(bounding_mesh.depths)
depths = lons + 10
mesh = RectangularMesh(lons, lats, depths)
expected_depths = expected_lons + 10
bounding_mesh = mesh._get_bounding_mesh()
self.assertIsNotNone(bounding_mesh.depths)
self.assertTrue((bounding_mesh.depths
== expected_depths.flatten()).all())
bounding_mesh = mesh._get_bounding_mesh(with_depths=False)
self.assertIsNone(bounding_mesh.depths)
def test_simple(self):
lons = numpy.array([numpy.arange(-1, 1.2, 0.2)] * 11)
lats = lons.transpose() + 1
depths = lats + 10
mesh = RectangularMesh(lons, lats, depths)
check = lambda lon, lat, depth, expected_distance, **kwargs: \
self.assertAlmostEqual(
mesh.get_joyner_boore_distance(
Mesh.from_points_list([Point(lon, lat, depth)])
)[0],
expected_distance, **kwargs
)
check(lon=0, lat=0.5, depth=0, expected_distance=0)
check(lon=1, lat=1, depth=0, expected_distance=0)
check(lon=0.6, lat=-1, depth=0,
expected_distance=Point(0.6, -1).distance(Point(0.6, 0)),
delta=0.1)
check(lon=-0.8, lat=2.1, depth=10,
expected_distance=Point(-0.8, 2.1).distance(Point(-0.8, 2)),
delta=0.02)
check(lon=0.75, lat=2.3, depth=3,
expected_distance=Point(0.75, 2.3).distance(Point(0.75, 2)),
delta=0.04)
def test_even_rows_even_columns_with_depths(self):
lons = numpy.array([[10, 20], [12, 22]])
lats = numpy.array([[10, -10], [8, -9]])
depths = numpy.array([[2, 3], [4, 5]])
mesh = RectangularMesh(lons, lats, depths=depths)
self.assertEqual(mesh.get_middle_point(),
Point(15.996712, -0.250993, 3.5))
def test_mesh_of_two_points(self):
lons = numpy.array([[0, 0.5, 1]], float)
lats = numpy.array([[0, 0, 0]], float)
depths = numpy.array([[1, 0, 1]], float)
mesh = RectangularMesh(lons, lats, depths)
target_mesh = Mesh.from_points_list([Point(0.5, 1), Point(0.5, 0)])
dists = mesh.get_joyner_boore_distance(target_mesh)
expected_dists = [Point(0.5, 1).distance(Point(0.5, 0)), 0]
numpy.testing.assert_almost_equal(dists, expected_dists)
def test_mesh_of_one_point(self):
lons = numpy.array([[1]])
lats = numpy.array([[0]])
depths = numpy.array([[1]])
mesh = RectangularMesh(lons, lats, depths)
target_mesh = Mesh.from_points_list([Point(1, 0), Point(0.5, 0)])
dists = mesh.get_joyner_boore_distance(target_mesh)
expected_dists = [0, Point(0.5, 0).distance(Point(1, 0))]
self.assertTrue(numpy.allclose(dists, expected_dists, atol=0.2))
def test_mesh_of_two_points(self):
lons = numpy.array([[0, 0.5, 1]], float)
lats = numpy.array([[0, 0, 0]], float)
depths = numpy.array([[1, 0, 1]], float)
mesh = RectangularMesh(lons, lats, depths)
target_mesh = Mesh.from_points_list([Point(0.5, 1), Point(0.5, 0)])
dists = mesh.get_joyner_boore_distance(target_mesh)
expected_dists = [Point(0.5, 1).distance(Point(0.5, 0)), 0]
numpy.testing.assert_almost_equal(dists, expected_dists)
def _test(self, lons, lats, depths, expected_coords):
mesh = RectangularMesh(lons, lats, depths)
proj, polygon = mesh._get_proj_enclosing_polygon()
self.assertTrue(polygon.is_valid)
self.assertEqual(list(polygon.interiors), [])
coords = numpy.array(proj(*numpy.array(polygon.exterior).transpose(),
reverse=True)).transpose()
numpy.testing.assert_almost_equal(coords, expected_coords, decimal=4)
return polygon
def test_mesh_of_one_point(self):
lons = numpy.array([[1.]])
lats = numpy.array([[0.]])
depths = numpy.array([[1.]])
mesh = RectangularMesh(lons, lats, depths)
target_mesh = Mesh.from_points_list([Point(1, 0), Point(0.5, 0)])
dists = mesh.get_joyner_boore_distance(target_mesh)
expected_dists = [0, Point(0.5, 0).distance(Point(1, 0))]
self.assertTrue(numpy.allclose(dists, expected_dists, atol=0.2))
def _test(self, points, site, expected_distance):
lons, lats, depths = numpy.array(points).transpose()
lons = lons.transpose()
lats = lats.transpose()
depths = depths.transpose()
mesh = RectangularMesh(lons, lats, depths)
distance = mesh.get_joyner_boore_distance(
Mesh.from_points_list([Point(*site)]))[0]
self.assertAlmostEqual(distance, expected_distance, delta=0.02)
def _test(self, lons, lats, depths, expected_coords):
mesh = RectangularMesh(lons, lats, depths)
proj, polygon = mesh._get_proj_enclosing_polygon()
self.assertTrue(polygon.is_valid)
self.assertEqual(list(polygon.interiors), [])
coords = numpy.array(
proj(*numpy.array(polygon.exterior).transpose(),
reverse=True)).transpose()
numpy.testing.assert_almost_equal(coords, expected_coords, decimal=4)
return polygon
def _test(self, points, site, expected_distance):
lons, lats, depths = numpy.array(points).transpose()
lons = lons.transpose()
lats = lats.transpose()
depths = depths.transpose()
mesh = RectangularMesh(lons, lats, depths)
distance = mesh.get_joyner_boore_distance(
Mesh.from_points_list([Point(*site)])
)[0]
self.assertAlmostEqual(distance, expected_distance, delta=0.02)
def test_mesh_width(self):
lons = numpy.array([[0.1, 0.1, 0.1, 0.1],
[0.1, 0.1, 0.1, 0.1],
[0.1, 0.1, 0.1, 0.1]])
lats = numpy.array([[0.1, 0.10899322, 0.11798643, 0.12697965],
[0.1, 0.10899322, 0.11798643, 0.12697965],
[0.1, 0.10899322, 0.11798643, 0.12697965]])
depths = numpy.array([[2.0, 2.0, 2.0, 2.0],
[3.0, 3.0, 3.0, 3.0],
[4.0, 4.0, 4.0, 4.0]])
mesh = RectangularMesh(lons, lats, depths)
self.assertAlmostEqual(mesh.get_mean_width(), 2.0)
def test_vertical_mesh(self):
lons = numpy.array([[0, 1, 2], [0, 1, 2]])
lats = numpy.array([[0, 0, 0], [0, 0, 0]])
depths = numpy.array([[1, 1, 1], [2, 2, 2]])
mesh = RectangularMesh(lons, lats, depths)
target_mesh = Mesh.from_points_list([Point(0.5, 0), Point(0.5, 1),
Point(0.5, 5)])
dists = mesh.get_joyner_boore_distance(target_mesh)
expected_dists = [
0, Point(0.5, 1).distance(Point(0.5, 0)),
Point(0.5, 5).distance(Point(0.5, 0))
]
self.assertTrue(numpy.allclose(dists, expected_dists, atol=3))
def _test(self, points, centroids, lengths, widths, areas):
fake_coords = numpy.array([[0]])
self.points = numpy.array(points, dtype=float)
mesh = RectangularMesh(fake_coords, fake_coords, fake_coords)
cell_center, cell_length, cell_width, cell_area \
= mesh.get_cell_dimensions()
self.assertTrue(numpy.allclose(cell_length, lengths),
'%s != %s' % (cell_length, lengths))
self.assertTrue(numpy.allclose(cell_width, widths),
'%s != %s' % (cell_width, widths))
self.assertTrue(numpy.allclose(cell_area, areas),
'%s != %s' % (cell_area, areas))
self.assertTrue(numpy.allclose(cell_center, centroids),
'%s != %s' % (cell_center, centroids))
def _test(self, points, centroids, lengths, widths, areas):
fake_coords = numpy.array([[0]])
self.points = numpy.array(points, dtype=float)
mesh = RectangularMesh(fake_coords, fake_coords, fake_coords)
cell_center, cell_length, cell_width, cell_area \
= mesh.get_cell_dimensions()
self.assertTrue(numpy.allclose(cell_length, lengths),
'%s != %s' % (cell_length, lengths))
self.assertTrue(numpy.allclose(cell_width, widths),
'%s != %s' % (cell_width, widths))
self.assertTrue(numpy.allclose(cell_area, areas),
'%s != %s' % (cell_area, areas))
self.assertTrue(numpy.allclose(cell_center, centroids),
'%s != %s' % (cell_center, centroids))
def _create_mesh(self):
"""
See :meth:`nhlib.geo.surface.base.BaseSurface._create_mesh`.
"""
llons, llats, ldepths = geodetic.intervals_between(
self.top_left.longitude, self.top_left.latitude,
self.top_left.depth,
self.bottom_left.longitude, self.bottom_left.latitude,
self.bottom_left.depth,
self.mesh_spacing
)
rlons, rlats, rdepths = geodetic.intervals_between(
self.top_right.longitude, self.top_right.latitude,
self.top_right.depth,
self.bottom_right.longitude, self.bottom_right.latitude,
self.bottom_right.depth,
self.mesh_spacing
)
mlons, mlats, mdepths = [], [], []
for i in xrange(len(llons)):
lons, lats, depths = geodetic.intervals_between(
llons[i], llats[i], ldepths[i], rlons[i], rlats[i], rdepths[i],
self.mesh_spacing
)
mlons.append(lons)
mlats.append(lats)
mdepths.append(depths)
return RectangularMesh(numpy.array(mlons), numpy.array(mlats),
numpy.array(mdepths))
def test_single_column(self):
lons = numpy.array([[0], [1], [2], [3], [4], [5]])
lats = numpy.array([[-1], [-2], [-3], [-4], [-5], [-6]])
mesh = RectangularMesh(lons, lats, depths=None)
bounding_mesh = mesh._get_bounding_mesh()
self.assertTrue((bounding_mesh.lons == lons.flatten()).all())
self.assertTrue((bounding_mesh.lats == lats.flatten()).all())
self.assertIsNone(bounding_mesh.depths)
depths = numpy.array([[10], [11], [12], [13], [14], [15]])
mesh = RectangularMesh(lons, lats, depths)
bounding_mesh = mesh._get_bounding_mesh()
self.assertIsNotNone(bounding_mesh.depths)
self.assertTrue((bounding_mesh.depths == depths.flatten()).all())
bounding_mesh = mesh._get_bounding_mesh(with_depths=False)
self.assertIsNone(bounding_mesh.depths)
def test_single_row(self):
lons = numpy.array([[0, 1, 2, 3, 4, 5]])
lats = numpy.array([[-1, -2, -3, -4, -5, -6]])
mesh = RectangularMesh(lons, lats, depths=None)
bounding_mesh = mesh._get_bounding_mesh()
self.assertIsInstance(bounding_mesh, Mesh)
self.assertTrue((bounding_mesh.lons == lons[0]).all())
self.assertTrue((bounding_mesh.lats == lats[0]).all())
self.assertIsNone(bounding_mesh.depths)
depths = numpy.array([[10, 11, 12, 13, 14, 15]])
mesh = RectangularMesh(lons, lats, depths)
bounding_mesh = mesh._get_bounding_mesh()
self.assertIsNotNone(bounding_mesh.depths)
self.assertTrue((bounding_mesh.depths == depths[0]).all())
bounding_mesh = mesh._get_bounding_mesh(with_depths=False)
self.assertIsNone(bounding_mesh.depths)
def test_simple(self):
lons = numpy.array([[0, 0.0089946277931563321],
[0, 0.0089974527390248322]])
lats = numpy.array([[0, 0], [0, 0]], dtype=float)
depths = numpy.array([[1, 0.99992150706475513],
[3, 2.9999214824129012]])
mesh = RectangularMesh(lons, lats, depths)
points, along_azimuth, updip, diag = mesh.triangulate()
self.assertTrue(
numpy.allclose(points, [[(6370, 0, 0),
(6370, 1, 0)], [(6368, 0, 0),
(6368, 1, 0)]]))
self.assertTrue(
numpy.allclose(along_azimuth, [[(0, 1, 0)], [(0, 1, 0)]]))
self.assertTrue(numpy.allclose(updip, [
[(2, 0, 0)],
[(2, 0, 0)],
]))
self.assertTrue(numpy.allclose(diag, [[(2, 1, 0)]]))
def test_dip_over_90_degree(self):
top = [Point(0, -0.01), Point(0, 0.01)]
bottom = [Point(-0.01, -0.01, 1.11), Point(-0.01, 0.01, 1.11)]
mesh = RectangularMesh.from_points_list([top, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
# dip must be still in a range 0..90
self.assertAlmostEqual(dip, 45, delta=0.05)
# strike must be reversed
self.assertAlmostEqual(strike, 180, delta=0.05)
def test_dip_over_90_degree(self):
top = [Point(0, -0.01), Point(0, 0.01)]
bottom = [Point(-0.01, -0.01, 1.11), Point(-0.01, 0.01, 1.11)]
mesh = RectangularMesh.from_points_list([top, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
# dip must be still in a range 0..90
self.assertAlmostEqual(dip, 45, delta=0.05)
# strike must be reversed
self.assertAlmostEqual(strike, 180, delta=0.05)
def test_from_points_list(self):
lons = [[0, 1], [2, 3], [4, 5]]
lats = [[1, 2], [-1, -2], [10, 20]]
depths = [[11.1, 11.2], [11.3, 11.4], [11.5, 11.6]]
points = [[
Point(lons[i][j], lats[i][j], depths[i][j])
for j in xrange(len(lons[i]))
] for i in xrange(len(lons))]
mesh = RectangularMesh.from_points_list(points)
self.assertTrue((mesh.lons == lons).all())
self.assertTrue((mesh.lats == lats).all())
self.assertTrue((mesh.depths == depths).all())
points = [[
Point(lons[i][j], lats[i][j], depth=0)
for j in xrange(len(lons[i]))
] for i in xrange(len(lons))]
mesh = RectangularMesh.from_points_list(points)
self.assertTrue((mesh.lons == lons).all())
self.assertTrue((mesh.lats == lats).all())
self.assertIsNone(mesh.depths)
def test_simple(self):
lons = numpy.array([[0, 0.0089946277931563321],
[0, 0.0089974527390248322]])
lats = numpy.array([[0, 0], [0, 0]], dtype=float)
depths = numpy.array([[1, 0.99992150706475513],
[3, 2.9999214824129012]])
mesh = RectangularMesh(lons, lats, depths)
points, along_azimuth, updip, diag = mesh.triangulate()
self.assertTrue(numpy.allclose(points, [
[(6370, 0, 0), (6370, 1, 0)],
[(6368, 0, 0), (6368, 1, 0)]
]))
self.assertTrue(numpy.allclose(along_azimuth, [
[(0, 1, 0)], [(0, 1, 0)]
]))
self.assertTrue(numpy.allclose(updip, [
[(2, 0, 0)], [(2, 0, 0)],
]))
self.assertTrue(numpy.allclose(diag, [
[(2, 1, 0)]
]))
def from_fault_data(cls, fault_trace, upper_seismogenic_depth,
lower_seismogenic_depth, dip, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param fault_trace:
Geographical line representing the intersection between
the fault surface and the earth surface, an instance
of :class:`nhlib.Line`.
:param upper_seismo_depth:
Minimum depth ruptures can reach, in km (i.e. depth
to fault's top edge).
:param lower_seismo_depth:
Maximum depth ruptures can reach, in km (i.e. depth
to fault's bottom edge).
:param dip:
Dip angle (i.e. angle between fault surface
and earth surface), in degrees.
:param mesh_spacing:
Distance between two subsequent points in a mesh, in km.
:returns:
An instance of :class:`SimpleFaultSurface` created using that data.
Uses :meth:`check_fault_data` for checking parameters.
"""
cls.check_fault_data(fault_trace, upper_seismogenic_depth,
lower_seismogenic_depth, dip, mesh_spacing)
# Loops over points in the top edge, for each point
# on the top edge compute corresponding point on the bottom edge, then
# computes equally spaced points between top and bottom points.
vdist_top = upper_seismogenic_depth
vdist_bottom = lower_seismogenic_depth
hdist_top = vdist_top / math.tan(math.radians(dip))
hdist_bottom = vdist_bottom / math.tan(math.radians(dip))
strike = fault_trace[0].azimuth(fault_trace[-1])
azimuth = (strike + 90.0) % 360
mesh = []
for point in fault_trace.resample(mesh_spacing):
top = point.point_at(hdist_top, vdist_top, azimuth)
bottom = point.point_at(hdist_bottom, vdist_bottom, azimuth)
mesh.append(top.equally_spaced_points(bottom, mesh_spacing))
# number of rows corresponds to number of points along dip
# number of columns corresponds to number of points along strike
surface_points = numpy.array(mesh).transpose().tolist()
mesh = RectangularMesh.from_points_list(surface_points)
assert 1 not in mesh.shape
return cls(mesh)
def test_one_cell(self):
top = [Point(0, -0.01), Point(0, 0.01)]
bottom = [Point(0.01, -0.01, 1.11), Point(0.01, 0.01, 1.11)]
mesh = RectangularMesh.from_points_list([top, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 45, delta=0.05)
self.assertAlmostEqual(strike, 0, delta=0.05)
row1 = [Point(45, -0.1), Point(45.2, 0.1)]
row2 = [Point(45, -0.1, 1), Point(45.2, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 90)
self.assertAlmostEqual(strike, 45, delta=0.1)
row1 = [Point(90, -0.1), Point(90, 0.1)]
row2 = [Point(90, -0.1, 1), Point(90, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 90)
self.assertAlmostEqual(strike, 0, delta=0.1)
def test_one_cell(self):
top = [Point(0, -0.01), Point(0, 0.01)]
bottom = [Point(0.01, -0.01, 1.11), Point(0.01, 0.01, 1.11)]
mesh = RectangularMesh.from_points_list([top, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 45, delta=0.05)
self.assertAlmostEqual(strike, 0, delta=0.05)
row1 = [Point(45, -0.1), Point(45.2, 0.1)]
row2 = [Point(45, -0.1, 1), Point(45.2, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 90)
self.assertAlmostEqual(strike, 45, delta=0.1)
row1 = [Point(90, -0.1), Point(90, 0.1)]
row2 = [Point(90, -0.1, 1), Point(90, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 90)
self.assertAlmostEqual(strike, 0, delta=0.1)
def from_fault_data(cls, fault_trace, upper_seismogenic_depth,
lower_seismogenic_depth, dip, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param nhlib.geo.line.Line fault_trace:
Geographical line representing the intersection between
the fault surface and the earth surface.
:param upper_seismo_depth:
Minimum depth ruptures can reach, in km (i.e. depth
to fault's top edge).
:param lower_seismo_depth:
Maximum depth ruptures can reach, in km (i.e. depth
to fault's bottom edge).
:param dip:
Dip angle (i.e. angle between fault surface
and earth surface), in degrees.
:param mesh_spacing:
Distance between two subsequent points in a mesh, in km.
:returns:
An instance of :class:`SimpleFaultSurface` created using that data.
Uses :meth:`check_fault_data` for checking parameters.
"""
cls.check_fault_data(fault_trace, upper_seismogenic_depth,
lower_seismogenic_depth, dip, mesh_spacing)
# Loops over points in the top edge, for each point
# on the top edge compute corresponding point on the bottom edge, then
# computes equally spaced points between top and bottom points.
vdist_top = upper_seismogenic_depth
vdist_bottom = lower_seismogenic_depth
hdist_top = vdist_top / math.tan(math.radians(dip))
hdist_bottom = vdist_bottom / math.tan(math.radians(dip))
strike = fault_trace[0].azimuth(fault_trace[-1])
azimuth = (strike + 90.0) % 360
mesh = []
for point in fault_trace.resample(mesh_spacing):
top = point.point_at(hdist_top, vdist_top, azimuth)
bottom = point.point_at(hdist_bottom, vdist_bottom, azimuth)
mesh.append(top.equally_spaced_points(bottom, mesh_spacing))
# number of rows corresponds to number of points along dip
# number of columns corresponds to number of points along strike
surface_points = numpy.array(mesh).transpose().tolist()
mesh = RectangularMesh.from_points_list(surface_points)
assert 1 not in mesh.shape
return cls(mesh)
def test_one_cell_unequal_area(self):
# top-left triangle is vertical, has dip of 90 degrees, zero
# strike and area of 1 by 1 over 2. bottom-right one has dip
# of atan2(1, sqrt(2) / 2.0) which is 54.73561 degrees, strike
# of 45 degrees and area that is 1.73246136 times area of the
# first one's. weighted mean dip is 67.5 degrees and weighted
# mean strike is 28.84 degrees
top = [Point(0, -0.01), Point(0, 0.01)]
bottom = [Point(0, -0.01, 2.22), Point(0.02, 0.01, 2.22)]
mesh = RectangularMesh.from_points_list([top, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 67.5, delta=0.05)
self.assertAlmostEqual(strike, 28.84, delta=0.05)
def test_one_cell_unequal_area(self):
# top-left triangle is vertical, has dip of 90 degrees, zero
# strike and area of 1 by 1 over 2. bottom-right one has dip
# of atan2(1, sqrt(2) / 2.0) which is 54.73561 degrees, strike
# of 45 degrees and area that is 1.73246136 times area of the
# first one's. weighted mean dip is 67.5 degrees and weighted
# mean strike is 28.84 degrees
top = [Point(0, -0.01), Point(0, 0.01)]
bottom = [Point(0, -0.01, 2.22), Point(0.02, 0.01, 2.22)]
mesh = RectangularMesh.from_points_list([top, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 67.5, delta=0.05)
self.assertAlmostEqual(strike, 28.84, delta=0.05)
def test_from_points_list(self):
lons = [[0, 1], [2, 3], [4, 5]]
lats = [[1, 2], [-1, -2], [10, 20]]
depths = [[11.1, 11.2], [11.3, 11.4], [11.5, 11.6]]
points = [
[Point(lons[i][j], lats[i][j], depths[i][j])
for j in xrange(len(lons[i]))]
for i in xrange(len(lons))
]
mesh = RectangularMesh.from_points_list(points)
self.assertTrue((mesh.lons == lons).all())
self.assertTrue((mesh.lats == lats).all())
self.assertTrue((mesh.depths == depths).all())
points = [
[Point(lons[i][j], lats[i][j], depth=0)
for j in xrange(len(lons[i]))]
for i in xrange(len(lons))
]
mesh = RectangularMesh.from_points_list(points)
self.assertTrue((mesh.lons == lons).all())
self.assertTrue((mesh.lats == lats).all())
self.assertIsNone(mesh.depths)
def from_fault_data(cls, edges, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param edges:
A list of at least two horizontal edges of the surface
as instances of :class:`nhlib.geo.line.Line`. The list
should be in top-to-bottom order (the shallowest edge
first).
:param mesh_spacing:
Distance between two subsequent points in a mesh, in km.
:returns:
An instance of :class:`ComplexFaultSurface` created using
that data.
:raises ValueError:
If requested mesh spacing is too big for the surface geometry
(doesn't allow to put a single mesh cell along length and/or
width).
Uses :meth:`check_fault_data` for checking parameters.
"""
cls.check_fault_data(edges, mesh_spacing)
mean_length = numpy.mean([edge.get_length() for edge in edges])
num_hor_points = int(round(mean_length / mesh_spacing)) + 1
if num_hor_points <= 1:
raise ValueError(
'mesh spacing %.1f km is too big for mean length %.1f km' %
(mesh_spacing, mean_length))
edges = [
edge.resample_to_num_points(num_hor_points).points
for i, edge in enumerate(edges)
]
vert_edges = [Line(v_edge) for v_edge in zip(*edges)]
mean_width = numpy.mean([v_edge.get_length() for v_edge in vert_edges])
num_vert_points = int(round(mean_width / mesh_spacing)) + 1
if num_vert_points <= 1:
raise ValueError(
'mesh spacing %.1f km is too big for mean width %.1f km' %
(mesh_spacing, mean_width))
points = zip(*[
v_edge.resample_to_num_points(num_vert_points).points
for v_edge in vert_edges
])
mesh = RectangularMesh.from_points_list(points)
assert 1 not in mesh.shape
return cls(mesh)
def from_fault_data(cls, edges, mesh_spacing):
"""
Create and return a fault surface using fault source data.
:param edges:
A list of at least two horizontal edges of the surface
as instances of :class:`nhlib.geo.line.Line`. The list
should be in top-to-bottom order (the shallowest edge
first).
:param mesh_spacing:
Distance between two subsequent points in a mesh, in km.
:returns:
An instance of :class:`ComplexFaultSurface` created using
that data.
:raises ValueError:
If requested mesh spacing is too big for the surface geometry
(doesn't allow to put a single mesh cell along length and/or
width).
Uses :meth:`check_fault_data` for checking parameters.
"""
cls.check_fault_data(edges, mesh_spacing)
mean_length = numpy.mean([edge.get_length() for edge in edges])
num_hor_points = int(round(mean_length / mesh_spacing)) + 1
if num_hor_points <= 1:
raise ValueError(
'mesh spacing %.1f km is too big for mean length %.1f km' %
(mesh_spacing, mean_length)
)
edges = [edge.resample_to_num_points(num_hor_points).points
for i, edge in enumerate(edges)]
vert_edges = [Line(v_edge) for v_edge in zip(*edges)]
mean_width = numpy.mean([v_edge.get_length() for v_edge in vert_edges])
num_vert_points = int(round(mean_width / mesh_spacing)) + 1
if num_vert_points <= 1:
raise ValueError(
'mesh spacing %.1f km is too big for mean width %.1f km' %
(mesh_spacing, mean_width)
)
points = zip(*[v_edge.resample_to_num_points(num_vert_points).points
for v_edge in vert_edges])
mesh = RectangularMesh.from_points_list(points)
assert 1 not in mesh.shape
return cls(mesh)
def test_two_cells(self):
top = [Point(0, -0.01), Point(0, 0.01)]
middle = [Point(0.01, -0.01, 1.11), Point(0.01, 0.01, 1.11)]
bottom = [Point(0.01, -0.01, 2.22), Point(0.01, 0.01, 2.22)]
mesh = RectangularMesh.from_points_list([top, middle, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, math.degrees(math.atan2(2, 1)), delta=0.1)
self.assertAlmostEqual(strike, 0, delta=0.02)
bottom = [Point(0.01, -0.01, 3.33), Point(0.01, 0.01, 3.33)]
mesh = RectangularMesh.from_points_list([top, middle, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, math.degrees(math.atan2(3, 1)), delta=0.1)
self.assertAlmostEqual(strike, 0, delta=0.02)
row1 = [Point(90, -0.1), Point(90, 0), Point(90, 0.1)]
row2 = [Point(90, -0.1, 1), Point(90, 0, 1), Point(90, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 90)
assert_angles_equal(self, strike, 360, delta=1e-7)
row1 = [Point(-90.1, -0.1), Point(-90, 0), Point(-89.9, 0.1)]
row2 = [
Point(-90.0, -0.1, 1),
Point(-89.9, 0, 1),
Point(-89.8, 0.1, 1)
]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(strike, 45, delta=1e-4)
row1 = [Point(-90.1, -0.1), Point(-90, 0), Point(-89.9, 0.1)]
row2 = [
Point(-90.0, -0.1, 1),
Point(-89.9, 0, 1),
Point(-89.8, 0.1, 1)
]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(strike, 45, delta=1e-3)
row1 = [Point(-90.1, -0.1), Point(-90, 0), Point(-89.9, 0.1)]
row2 = [Point(-90.2, -0.1, 1), Point(-90.1, 0, 1), Point(-90, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(strike, 225, delta=1e-3)
def test_on_surface(self):
row1 = [Point(0, 0), Point(0, 1)]
row2 = [Point(1, 0), Point(1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 0, delta=0.5)
row1 = [Point(0, 0), Point(0, -1)]
row2 = [Point(1, 0), Point(1, -1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 180, delta=0.5)
row1 = [Point(0, 0), Point(1, 1)]
row2 = [Point(1, 0), Point(2, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 45, delta=0.01)
row1 = [Point(0, 0), Point(1, -1)]
row2 = [Point(1, 0), Point(2, -1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 135, delta=0.01)
row1 = [Point(0, 0), Point(-1, -1)]
row2 = [Point(-1, 0), Point(-2, -1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 225, delta=0.01)
row1 = [Point(0, 0), Point(-1, 1)]
row2 = [Point(-1, 0), Point(-2, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 315, delta=0.01)
def test_on_surface(self):
row1 = [Point(0, 0), Point(0, 1)]
row2 = [Point(1, 0), Point(1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 0, delta=0.5)
row1 = [Point(0, 0), Point(0, -1)]
row2 = [Point(1, 0), Point(1, -1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 180, delta=0.5)
row1 = [Point(0, 0), Point(1, 1)]
row2 = [Point(1, 0), Point(2, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 45, delta=0.01)
row1 = [Point(0, 0), Point(1, -1)]
row2 = [Point(1, 0), Point(2, -1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 135, delta=0.01)
row1 = [Point(0, 0), Point(-1, -1)]
row2 = [Point(-1, 0), Point(-2, -1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 225, delta=0.01)
row1 = [Point(0, 0), Point(-1, 1)]
row2 = [Point(-1, 0), Point(-2, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertEqual(dip, 0)
self.assertAlmostEqual(strike, 315, delta=0.01)
def test_two_cells(self):
top = [Point(0, -0.01), Point(0, 0.01)]
middle = [Point(0.01, -0.01, 1.11), Point(0.01, 0.01, 1.11)]
bottom = [Point(0.01, -0.01, 2.22), Point(0.01, 0.01, 2.22)]
mesh = RectangularMesh.from_points_list([top, middle, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, math.degrees(math.atan2(2, 1)), delta=0.1)
self.assertAlmostEqual(strike, 0, delta=0.02)
bottom = [Point(0.01, -0.01, 3.33), Point(0.01, 0.01, 3.33)]
mesh = RectangularMesh.from_points_list([top, middle, bottom])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, math.degrees(math.atan2(3, 1)), delta=0.1)
self.assertAlmostEqual(strike, 0, delta=0.02)
row1 = [Point(90, -0.1), Point(90, 0), Point(90, 0.1)]
row2 = [Point(90, -0.1, 1), Point(90, 0, 1), Point(90, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(dip, 90)
assert_angles_equal(self, strike, 360, delta=1e-7)
row1 = [Point(-90.1, -0.1), Point(-90, 0), Point(-89.9, 0.1)]
row2 = [Point(-90.0, -0.1, 1), Point(-89.9, 0, 1), Point(-89.8, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(strike, 45, delta=1e-4)
row1 = [Point(-90.1, -0.1), Point(-90, 0), Point(-89.9, 0.1)]
row2 = [Point(-90.0, -0.1, 1), Point(-89.9, 0, 1), Point(-89.8, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(strike, 45, delta=1e-3)
row1 = [Point(-90.1, -0.1), Point(-90, 0), Point(-89.9, 0.1)]
row2 = [Point(-90.2, -0.1, 1), Point(-90.1, 0, 1), Point(-90, 0.1, 1)]
mesh = RectangularMesh.from_points_list([row1, row2])
dip, strike = mesh.get_mean_inclination_and_azimuth()
self.assertAlmostEqual(strike, 225, delta=1e-3)
def test_wrong_shape(self):
with self.assertRaises(AssertionError):
RectangularMesh(numpy.array([0, 1, 2]), numpy.array([0, 0, 0]),
None)
RectangularMesh(numpy.array([0, -1]), numpy.array([2, 10]),
numpy.array([5, 44]))
def test_even_rows_odd_columns_with_depth(self):
lons = numpy.array([[20], [21]])
lats = numpy.array([[-1], [1]])
depths = numpy.array([[11.1], [11.3]])
mesh = RectangularMesh(lons, lats, depths=depths)
self.assertEqual(mesh.get_middle_point(), Point(20.5, 0, 11.2))
def test_even_rows_even_columns_no_depths(self):
lons = numpy.array([[10, 20], [10.002, 20.002]])
lats = numpy.array([[10, -10], [8, -8]])
mesh = RectangularMesh(lons, lats, depths=None)
self.assertEqual(mesh.get_middle_point(), Point(15.001, 0))
def test_even_rows_even_columns_no_depths(self):
lons = numpy.array([[10, 20], [10.002, 20.002]])
lats = numpy.array([[10, -10], [8, -8]])
mesh = RectangularMesh(lons, lats, depths=None)
self.assertEqual(mesh.get_middle_point(), Point(15.001, 0))
def test_even_rows_odd_columns_no_depths(self):
lons = numpy.array([[-1, 0, 1, 2, 3], [-1.5, 0.5, 1.5, 2.5, 3.5]])
lats = numpy.array([[-0.01] * 5, [-0.015] * 5])
mesh = RectangularMesh(lons, lats, depths=None)
self.assertEqual(mesh.get_middle_point(), Point(1.25, -0.0125, 0))
def _create_mesh(self):
points = [[Point(*coordinates) for coordinates in row] for row in self.coordinates_list]
return RectangularMesh.from_points_list(points)
def test_even_rows_odd_columns_with_depth(self):
lons = numpy.array([[20], [21]])
lats = numpy.array([[-1], [1]])
depths = numpy.array([[11.1], [11.3]])
mesh = RectangularMesh(lons, lats, depths=depths)
self.assertEqual(mesh.get_middle_point(), Point(20.5, 0, 11.2))
def test_even_rows_odd_columns_no_depths(self):
lons = numpy.array([[-1, 0, 1, 2, 3], [-1.5, 0.5, 1.5, 2.5, 3.5]])
lats = numpy.array([[-0.01] * 5, [-0.015] * 5])
mesh = RectangularMesh(lons, lats, depths=None)
self.assertEqual(mesh.get_middle_point(), Point(1.25, -0.0125, 0))
def test_odd_rows_even_columns_no_depths(self):
lons = numpy.array([[10, 20, 30, 40]])
lats = numpy.array([[30] * 4])
mesh = RectangularMesh(lons, lats, depths=None)
self.assertEqual(mesh.get_middle_point(), Point(25, 30.094679))
def test_odd_rows_even_columns_with_depths(self):
lons = numpy.array([[0, 20, 30, 90]])
lats = numpy.array([[30] * 4])
depths = numpy.array([[2, 7, 8, 10]])
mesh = RectangularMesh(lons, lats, depths=depths)
self.assertEqual(mesh.get_middle_point(), Point(25, 30.094679, 7.5))
def test_odd_rows_odd_columns_with_depths(self):
lons = numpy.array([numpy.arange(-1, 1.2, 0.2)] * 11)
lats = lons.transpose() * 10
depths = lats + 10
mesh = RectangularMesh(lons, lats, depths)
self.assertEqual(mesh.get_middle_point(), Point(0, 0, 10))
def test_odd_rows_even_columns_no_depths(self):
lons = numpy.array([[10, 20, 30, 40]])
lats = numpy.array([[30] * 4])
mesh = RectangularMesh(lons, lats, depths=None)
self.assertEqual(mesh.get_middle_point(), Point(25, 30.094679))
def test_preserving_the_type(self):
lons = lats = numpy.array(range(100)).reshape((10, 10))
mesh = RectangularMesh(lons, lats, depths=None)
submesh = mesh[1:2, 3:4]
self.assertIsInstance(submesh, RectangularMesh)
def test_odd_rows_even_columns_with_depths(self):
lons = numpy.array([[0, 20, 30, 90]])
lats = numpy.array([[30] * 4])
depths = numpy.array([[2, 7, 8, 10]])
mesh = RectangularMesh(lons, lats, depths=depths)
self.assertEqual(mesh.get_middle_point(), Point(25, 30.094679, 7.5))
def test_odd_rows_odd_columns_with_depths(self):
lons = numpy.array([numpy.arange(-1, 1.2, 0.2)] * 11)
lats = lons.transpose() * 10
depths = lats + 10
mesh = RectangularMesh(lons, lats, depths)
self.assertEqual(mesh.get_middle_point(), Point(0, 0, 10))
def _create_mesh(self):
points = [[Point(*coordinates) for coordinates in row]
for row in self.coordinates_list]
return RectangularMesh.from_points_list(points)
