Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

#!/usr/bin/env python 

# -*- coding: utf-8 -*- 

""" 

The Rotate test suite. 

""" 

 

from obspy.signal import rotate_NE_RT, rotate_RT_NE, rotate_ZNE_LQT, \ 

    rotate_LQT_ZNE 

import numpy as np 

import os 

import unittest 

 

 

class RotateTestCase(unittest.TestCase): 

    """ 

    Test cases for Rotate. 

    """ 

    def setUp(self): 

        # directory where the test files are located 

        self.path = os.path.join(os.path.dirname(__file__), 'data') 

 

    def test_rotate_NE_RTVsPitsa(self): 

        """ 

        Test horizontal component rotation against PITSA. 

        """ 

        # load test files 

        data_n = np.loadtxt(os.path.join(self.path, 'rjob_20051006_n.gz')) 

        data_e = np.loadtxt(os.path.join(self.path, 'rjob_20051006_e.gz')) 

        #test different angles, one from each sector 

        for angle in [30, 115, 185, 305]: 

            # rotate traces 

            datcorr_r, datcorr_t = rotate_NE_RT(data_n, data_e, angle) 

            # load pitsa files 

            data_pitsa_r = np.loadtxt(os.path.join(self.path, 

                'rjob_20051006_r_%sdeg.gz' % angle)) 

            data_pitsa_t = np.loadtxt(os.path.join(self.path, 

                'rjob_20051006_t_%sdeg.gz' % angle)) 

            # Assert. 

            self.assertTrue(np.allclose(datcorr_r, data_pitsa_r, rtol=1E-3, 

                atol=1E-5)) 

            self.assertTrue(np.allclose(datcorr_t, data_pitsa_t, rtol=1E-3, 

                atol=1E-5)) 

 

    def test_rotate_ZNE_LQTVsPitsa(self): 

        """ 

        Test LQT component rotation against PITSA. Test back-rotation. 

        """ 

        # load test files 

        data_z = np.loadtxt(os.path.join(self.path, 'rjob_20051006.gz')) 

        data_n = np.loadtxt(os.path.join(self.path, 'rjob_20051006_n.gz')) 

        data_e = np.loadtxt(os.path.join(self.path, 'rjob_20051006_e.gz')) 

        # test different backazimuth/incidence combinations 

        for ba, inci in ((60, 130), (210, 60)): 

            # rotate traces 

            data_l, data_q, data_t = \ 

                rotate_ZNE_LQT(data_z, data_n, data_e, ba, inci) 

            # rotate traces back to ZNE 

            data_back_z, data_back_n, data_back_e = \ 

                rotate_LQT_ZNE(data_l, data_q, data_t, ba, inci) 

            # load pitsa files 

            data_pitsa_l = np.loadtxt(os.path.join(self.path, 

                'rjob_20051006_l_%sba_%sinc.gz' % (ba, inci))) 

            data_pitsa_q = np.loadtxt(os.path.join(self.path, 

                'rjob_20051006_q_%sba_%sinc.gz' % (ba, inci))) 

            data_pitsa_t = np.loadtxt(os.path.join(self.path, 

                'rjob_20051006_t_%sba_%sinc.gz' % (ba, inci))) 

            # Assert the output. Has to be to rather low accuracy due to 

            # rounding error prone rotation and single precision value. 

            self.assertTrue(np.allclose(data_l, data_pitsa_l, rtol=1E-3, 

                atol=1E-5)) 

            self.assertTrue(np.allclose(data_q, data_pitsa_q, rtol=1E-3, 

                atol=1E-5)) 

            self.assertTrue(np.allclose(data_t, data_pitsa_t, rtol=1E-3, 

                atol=1E-5)) 

            self.assertTrue(np.allclose(data_z, data_back_z, rtol=1E-3, 

                atol=1E-5)) 

            self.assertTrue(np.allclose(data_n, data_back_n, rtol=1E-3, 

                atol=1E-5)) 

            self.assertTrue(np.allclose(data_e, data_back_e, rtol=1E-3, 

                atol=1E-5)) 

 

    def test_rotate_NE_RT_NE(self): 

        """ 

        Rotating there and back with the same back-azimuth should not change 

        the data. 

        """ 

        # load the data 

        data_n = np.loadtxt(os.path.join(self.path, 'rjob_20051006_n.gz')) 

        data_e = np.loadtxt(os.path.join(self.path, 'rjob_20051006_e.gz')) 

        # Use double precision to get more accuracy for testing. 

        data_n = np.require(data_n, "float64") 

        data_e = np.require(data_e, "float64") 

        ba = 33.3 

        new_n, new_e = rotate_NE_RT(data_n, data_e, ba) 

        new_n, new_e = rotate_RT_NE(new_n, new_e, ba) 

        self.assertTrue(np.allclose(data_n, new_n, rtol=1E-7, atol=1E-12)) 

        self.assertTrue(np.allclose(data_e, new_e, rtol=1E-7, atol=1E-12)) 

 

 

def suite(): 

    return unittest.makeSuite(RotateTestCase, 'test') 

 

 

if __name__ == '__main__': 

    unittest.main(defaultTest='suite')