Beispiel #1
0
 def test_mesh_and_point_not_on_surface(self):
     self._test(Mesh.from_points_list(
         [Point(0, 0, 1), Point(0, 1, 2),
          Point(0, 2, 3)]),
                Mesh.from_points_list(
                    [Point(0, 1.5, 3), Point(0, 1.5, 0.9)]),
                expected_distance_indices=[2, 1])
 def select_square_centred_on_point(self, point, distance, **kwargs):
     '''Select earthquakes from within a square centered on a point
     :param point:
         Centre point as instance of nhlib.geo.point.Point class
     :param distance:
         Distance (km)
     :returns:
         Selected catalogue (as dictionary) and number of selected events
     '''
     point_surface = Point(point.longitude, point.latitude, 0.)
     north_point = point_surface.point_at(distance, 0., 0.)
     east_point = point_surface.point_at(distance, 0., 90.)
     south_point = point_surface.point_at(distance, 0., 180.)
     west_point = point_surface.point_at(distance, 0., 270.)
     is_long = np.logical_and(
         catalogue['longitude'] >= west_point.longitude,
         catalogue['longitude'] < east_point.longitude)
     is_surface = np.logical_and(
         is_long,
         catalogue['latitude'] >= south_point.latitude,
         catalogue['latitude'] < north_point.latitude)
     
     upper_depth, lower_depth = _check_depth_limits(kwargs)
     is_valid = np.logical_and(
         is_surface,
         catalogue['depth'] >= upper_depth,
         catalogue['depth'] < lower_depth)
     number_selected = np.sum(is_valid)
     is_valid = np.logical_not(is_valid)
     return purge_catalogue(catalogue, is_valid.astype(int)), \
         number_selected
Beispiel #3
0
    def test(self):
        s1 = Site(location=Point(10, 20, 30),
                  vs30=1.2,
                  vs30measured=True,
                  z1pt0=3.4,
                  z2pt5=5.6)
        s2 = Site(location=Point(-1.2, -3.4, -5.6),
                  vs30=55.4,
                  vs30measured=False,
                  z1pt0=66.7,
                  z2pt5=88.9)
        cll = SiteCollection([s1, s2])
        self.assertTrue((cll.vs30 == [1.2, 55.4]).all())
        self.assertTrue((cll.vs30measured == [True, False]).all())
        self.assertTrue((cll.z1pt0 == [3.4, 66.7]).all())
        self.assertTrue((cll.z2pt5 == [5.6, 88.9]).all())
        self.assertTrue((cll.mesh.lons == [10, -1.2]).all())
        self.assertTrue((cll.mesh.lats == [20, -3.4]).all())
        self.assertIs(cll.mesh.depths, None)
        for arr in (cll.vs30, cll.z1pt0, cll.z2pt5):
            self.assertIsInstance(arr, numpy.ndarray)
            self.assertEqual(arr.flags.writeable, False)
            self.assertEqual(arr.dtype, float)
        self.assertIsInstance(cll.vs30measured, numpy.ndarray)
        self.assertEqual(cll.vs30measured.flags.writeable, False)
        self.assertEqual(cll.vs30measured.dtype, bool)

        self.assertEqual(len(cll), 2)
Beispiel #4
0
    def test_get_strike_1(self):
        p1 = Point(0.0, 0.0)
        p2 = Point(0.0635916966572, 0.0635916574897)

        surface = SimpleFaultSurface.from_fault_data(Line([p1, p2]), 1.0, 6.0,
                                                     89.9, 1.0)

        self.assertAlmostEquals(45.0, surface.get_strike(), delta=1e-4)
Beispiel #5
0
 def test_point_on_the_border(self):
     corners = [[(0.1, -0.1, 1), (-0.1, -0.1, 1)],
                [(0.1, 0.1, 2), (-0.1, 0.1, 2)]]
     surface = DummySurface(corners)
     sites = Mesh.from_points_list([Point(-0.1, 0.04), Point(0.1, 0.03)])
     dists = surface.get_joyner_boore_distance(sites)
     expected_dists = [0] * 2
     self.assertTrue(numpy.allclose(dists, expected_dists, atol=1e-4))
Beispiel #6
0
 def test_from_points_list_no_depth(self):
     points = [Point(0, 1), Point(2, 3), Point(5, 7)]
     mesh = Mesh.from_points_list(points)
     self.assertTrue((mesh.lons == [0, 2, 5]).all())
     self.assertTrue((mesh.lats == [1, 3, 7]).all())
     self.assertEqual(mesh.lons.dtype, numpy.float)
     self.assertEqual(mesh.lats.dtype, numpy.float)
     self.assertIs(mesh.depths, None)
Beispiel #7
0
 def test4_site_along_strike(self):
     surface = self._test1to7surface()
     sites = Mesh.from_points_list(
         [Point(0.2, 0), Point(67.6, 0),
          Point(90.33, 0)])
     dists = surface.get_rx_distance(sites)
     expected_dists = [0] * 3
     self.assertTrue(numpy.allclose(dists, expected_dists))
Beispiel #8
0
    def test_get_dip_2(self):
        p1 = Point(0.0, 0.0)
        p2 = Point(0.0635916966572, 0.0635916574897)

        surface = SimpleFaultSurface.from_fault_data(Line([p1, p2]), 1.0, 6.0,
                                                     30.0, 1.0)

        self.assertAlmostEquals(30.0, surface.get_dip(), 1)
Beispiel #9
0
 def test5_site_opposite_to_strike_direction(self):
     surface = self._test1to7surface()
     sites = Mesh.from_points_list(
         [Point(-0.2, 0), Point(-67.6, 0),
          Point(-90.33, 0)])
     dists = surface.get_rx_distance(sites)
     expected_dists = [0] * 3
     self.assertTrue(numpy.allclose(dists, expected_dists))
Beispiel #10
0
 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))
Beispiel #11
0
    def test_get_dip_1(self):
        p1 = Point(0.0, 0.0)
        p2 = Point(0.0635916966572, 0.0635916574897)
        p3 = Point(0.0860747816618, 0.102533437776)

        surface = SimpleFaultSurface.from_fault_data(Line([p1, p2, p3]), 1.0,
                                                     6.0, 90.0, 1.0)

        self.assertAlmostEquals(90.0, surface.get_dip(), delta=1e-6)
Beispiel #12
0
 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)
Beispiel #13
0
    def test_get_mesh_5(self):
        p1 = Point(179.9, 0.0)
        p2 = Point(180.0, 0.0)
        p3 = Point(-179.9, 0.0)

        fault = SimpleFaultSurface.from_fault_data(Line([p1, p2, p3]), 1.0,
                                                   6.0, 90.0, 1.0)

        self.assert_mesh_is(fault, test_data.TEST_5_MESH)
Beispiel #14
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)
Beispiel #15
0
    def test_get_mesh_4(self):
        p1 = Point(0.0, 0.0, 0.0)
        p2 = Point(0.0, 0.0359728811759, 0.0)
        p3 = Point(0.0190775080917, 0.0550503815182, 0.0)
        p4 = Point(0.03974514139, 0.0723925718856, 0.0)

        fault = SimpleFaultSurface.from_fault_data(Line([p1, p2, p3, p4]), 0.0,
                                                   4.0, 90.0, 1.0)

        self.assert_mesh_is(fault, test_data.TEST_4_MESH)
Beispiel #16
0
 def test_point_inside(self):
     corners = [[(-0.1, -0.1, 1), (0.1, -0.1, 1)],
                [(-0.1, 0.1, 2), (0.1, 0.1, 2)]]
     surface = DummySurface(corners)
     sites = Mesh.from_points_list(
         [Point(0, 0), Point(0, 0, 20),
          Point(0.01, 0.03)])
     dists = surface.get_joyner_boore_distance(sites)
     expected_dists = [0] * 3
     self.assertTrue(numpy.allclose(dists, expected_dists))
Beispiel #17
0
    def test_get_mesh_2(self):
        p1 = Point(0.0, 0.0, 0.0)
        p2 = Point(0.0, 0.0359728811759, 0.0)
        p3 = Point(0.0190775080917, 0.0550503815182, 0.0)
        p4 = Point(0.03974514139, 0.0723925718856, 0.0)

        fault = SimpleFaultSurface.from_fault_data(Line([p1, p2, p3,
                                                         p4]), 2.12132034356,
                                                   4.2426406871192848, 45.0,
                                                   1.0)

        self.assert_mesh_is(fault, test_data.TEST_2_MESH)
Beispiel #18
0
 def test_dip_90_three_points(self):
     polygon = SimpleFaultSurface.surface_projection_from_fault_data(
         Line([Point(1, -20),
               Point(1, -20.2),
               Point(2, -19.7)]),
         dip=90,
         upper_seismogenic_depth=30,
         lower_seismogenic_depth=50,
     )
     elons = [1, 1, 2]
     elats = [-20.2, -20., -19.7]
     numpy.testing.assert_allclose(polygon.lons, elons)
     numpy.testing.assert_allclose(polygon.lats, elats)
Beispiel #19
0
 def test_dip_90_self_intersection(self):
     polygon = SimpleFaultSurface.surface_projection_from_fault_data(
         Line([Point(1, -2),
               Point(2, -1.9),
               Point(3, -2.1),
               Point(4, -2)]),
         dip=90,
         upper_seismogenic_depth=10,
         lower_seismogenic_depth=20,
     )
     elons = [3., 1., 2., 4.]
     elats = [-2.1, -2., -1.9, -2.]
     numpy.testing.assert_allclose(polygon.lons, elons)
     numpy.testing.assert_allclose(polygon.lats, elats)
Beispiel #20
0
    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)
Beispiel #21
0
 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))
Beispiel #22
0
 def test_one_point(self):
     mesh = Mesh.from_points_list([Point(7, 7)])
     polygon = mesh.get_convex_hull()
     elons = [7.0000453, 7., 6.9999547, 7]
     elats = [7., 6.99995503, 7., 7.00004497]
     numpy.testing.assert_allclose(polygon.lons, elons)
     numpy.testing.assert_allclose(polygon.lats, elats)
Beispiel #23
0
 def test_dip_90_two_points(self):
     polygon = SimpleFaultSurface.surface_projection_from_fault_data(
         Line([Point(2, 2), Point(1, 1)]),
         dip=90,
         upper_seismogenic_depth=10,
         lower_seismogenic_depth=20,
     )
     elons = [
         1.00003181, 0.99996821, 0.99996819, 1.99996819, 2.00003182,
         2.00003181
     ]
     elats = [
         0.99996822, 0.99996819, 1.00003178, 2.0000318, 2.0000318, 1.9999682
     ]
     numpy.testing.assert_allclose(polygon.lons, elons)
     numpy.testing.assert_allclose(polygon.lats, elats)
Beispiel #24
0
 def test_fault_trace_points(self):
     """
     The fault trace must have at least two points.
     """
     fault_trace = Line([Point(0.0, 0.0)])
     self.assertRaises(ValueError, SimpleFaultSurface.check_fault_data,
                       fault_trace, 0.0, 1.0, 90.0, 1.0)
Beispiel #25
0
    def get_middle_point(self):
        """
        Return the middle point of the mesh.

        :returns:
            An instance of :class:`~nhlib.geo.point.Point`.

        The middle point is taken from the middle row and a middle column
        of the mesh if there are odd number of both. Otherwise the geometric
        mean point of two or four middle points.
        """
        num_rows, num_cols = self.lons.shape
        mid_row = num_rows // 2
        depth = 0
        if num_rows & 1 == 1:
            # there are odd number of rows
            mid_col = num_cols // 2
            if num_cols & 1 == 1:
                # odd number of columns, we can easily take
                # the middle point
                if self.depths is not None:
                    depth = self.depths[mid_row][mid_col]
                return Point(self.lons[mid_row][mid_col],
                             self.lats[mid_row][mid_col], depth)
            else:
                # even number of columns, need to take two middle
                # points on the middle row
                lon1, lon2 = self.lons[mid_row][mid_col - 1:mid_col + 1]
                lat1, lat2 = self.lats[mid_row][mid_col - 1:mid_col + 1]
                if self.depths is not None:
                    depth1 = self.depths[mid_row][mid_col - 1]
                    depth2 = self.depths[mid_row][mid_col]
        else:
            # there are even number of rows. take the row just above
            # and the one just below the middle and find middle point
            # of each
            submesh1 = self[mid_row - 1:mid_row]
            submesh2 = self[mid_row:mid_row + 1]
            p1, p2 = submesh1.get_middle_point(), submesh2.get_middle_point()
            lon1, lat1, depth1 = p1.longitude, p1.latitude, p1.depth
            lon2, lat2, depth2 = p2.longitude, p2.latitude, p2.depth

        # we need to find the middle between two points
        if self.depths is not None:
            depth = (depth1 + depth2) / 2.0
        lon, lat = geo_utils.get_middle_point(lon1, lat1, lon2, lat2)
        return Point(lon, lat, depth)
Beispiel #26
0
    def __iter__(self):
        """
        Generate :class:`~nhlib.geo.point.Point` objects the mesh is composed
        of.

        Coordinates arrays are processed sequentially (as if they were
        flattened).
        """
        lons = self.lons.flat
        lats = self.lats.flat
        if self.depths is not None:
            depths = self.depths.flat
            for i in xrange(self.lons.size):
                yield Point(lons[i], lats[i], depths[i])
        else:
            for i in xrange(self.lons.size):
                yield Point(lons[i], lats[i])
Beispiel #27
0
 def test8_strike_of_45_degrees(self):
     corners = [[(0.05, 0.05, 8), (-0.05, -0.05, 8)],
                [(0.05, 0.05, 9), (-0.05, -0.05, 9)]]
     surface = DummySurface(corners)
     sites = Mesh.from_points_list([Point(0.05, 0)])
     self.assertAlmostEqual(surface.get_rx_distance(sites)[0],
                            3.9313415355436705,
                            places=4)
Beispiel #28
0
 def test_three_points(self):
     polygon = SimpleFaultSurface.surface_projection_from_fault_data(
         Line([Point(10, -20),
               Point(11, -20.2),
               Point(12, -19.7)]),
         dip=30,
         upper_seismogenic_depth=25.3,
         lower_seismogenic_depth=53.6,
     )
     elons = [
         11.13560807, 10.1354272, 10.06374285, 12.06361991, 12.13515987
     ]
     elats = [
         -21.02520738, -20.82520794, -20.3895235, -20.08952368, -20.52520878
     ]
     numpy.testing.assert_allclose(polygon.lons, elons)
     numpy.testing.assert_allclose(polygon.lats, elats)
Beispiel #29
0
def assert_mesh_is(testcase, surface, expected_mesh):
    mesh = surface.get_mesh()
    testcase.assertIs(mesh, surface.get_mesh())

    expected_mesh = list(itertools.chain(*expected_mesh))
    testcase.assertEqual(len(mesh), len(expected_mesh))
    testcase.assertIsInstance(mesh, Mesh)

    for i, point in enumerate(mesh):
        expected_point = Point(*expected_mesh[i])
        distance = expected_point.distance(point) * 1e3

        testcase.assertAlmostEqual(
            0, distance, delta=2, # allow discrepancy of 2 meters
            msg="point %d is off: %s != %s (distance is %.3fm)"
                % (i, point, expected_point, distance)
        )
Beispiel #30
0
    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)
Beispiel #31
0
def assert_mesh_is(testcase, surface, expected_mesh):
    mesh = surface.get_mesh()
    testcase.assertIs(mesh, surface.get_mesh())

    expected_mesh = list(itertools.chain(*expected_mesh))
    testcase.assertEqual(len(mesh), len(expected_mesh))
    testcase.assertIsInstance(mesh, Mesh)

    for i, point in enumerate(mesh):
        expected_point = Point(*expected_mesh[i])
        distance = expected_point.distance(point) * 1e3

        testcase.assertAlmostEqual(
            0,
            distance,
            delta=2,  # allow discrepancy of 2 meters
            msg="point %d is off: %s != %s (distance is %.3fm)" %
            (i, point, expected_point, distance))
Beispiel #32
0
 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)
Beispiel #33
0
    def select_circular_distance_from_point(self, point, distance, **kwargs):
        '''Select earthquakes within a distance from a Point
        :param point:
            Centre point as instance of nhlib.geo.point.Point class
        :param distance:
            Distance (km)
        :returns:
            Selected catalogue (as dictionary) and number of selected events
        '''
        if kwargs['distance_type'] is 'epicentral':
            locations = Mesh(catalogue['longitude'], catalogue['latitude'],
                np.zeros(len(catalogue['longitude']), dtype=float))
            point = Point(point.longitude, point.latitude, 0.0)
        else:
            locations = self.catalogue_mesh

        is_close = (point.closer_than(locations, distance))
        number_selected = np.sum(is_close)
        is_close = np.logical_not(is_close)
        return purge_catalogue(catalogue, is_close.astype(int)), \
            number_selected