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

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

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

""" 

GSE2/GSE1 bindings to ObsPy core module. 

""" 

 

from obspy import Trace, UTCDateTime, Stream 

from obspy.gse2 import libgse2, libgse1 

import numpy as np 

 

 

def isGSE2(filename): 

    """ 

    Checks whether a file is GSE2 or not. 

 

    :type filename: string 

    :param filename: GSE2 file to be checked. 

    :rtype: bool 

    :return: ``True`` if a GSE2 file. 

    """ 

    # Open file. 

    try: 

        f = open(filename) 

        libgse2.isGse2(f) 

        f.close() 

    except: 

        return False 

    return True 

 

 

convert_dict = { 

    'station': 'station', 

    'samp_rate': 'sampling_rate', 

    'n_samps': 'npts', 

    'channel': 'channel', 

    'calib': 'calib', 

} 

 

gse2_extra = [ 

    'instype', 

    'datatype', 

    'vang', 

    'hang', 

    'auxid', 

    'calper', 

] 

 

 

def readGSE2(filename, headonly=False, verify_chksum=True, 

             **kwargs):  # @UnusedVariable 

    """ 

    Reads a GSE2 file and returns a Stream object. 

 

    GSE2 files containing multiple WID2 entries/traces are supported. 

 

    .. warning:: 

        This function should NOT be called directly, it registers via the 

        ObsPy :func:`~obspy.core.stream.read` function, call this instead. 

 

    :type filename: string 

    :param filename: GSE2 file to be read. 

    :type headonly: boolean, optional 

    :param headonly: If True read only head of GSE2 file. 

    :type verify_chksum: boolean, optional 

    :param verify_chksum: If True verify Checksum and raise Exception if 

        it is not correct. 

    :rtype: :class:`~obspy.core.stream.Stream` 

    :returns: Stream object containing header and data. 

 

    .. rubric:: Example 

 

    >>> from obspy import read 

    >>> st = read("/path/to/loc_RJOB20050831023349.z") 

    """ 

    traces = [] 

    # read GSE2 file 

    f = open(filename, 'rb') 

    for _k in xrange(10000):  # avoid endless loop 

        pos = f.tell() 

        widi = f.readline()[0:4] 

        if widi == '':  # end of file 

            break 

        elif widi != 'WID2': 

            continue 

        else:  # valid gse2 part 

            f.seek(pos) 

            if headonly: 

                header = libgse2.readHead(f) 

            else: 

                header, data = libgse2.read(f, verify_chksum=verify_chksum) 

            # assign all header entries to a new dictionary compatible with an 

            # ObsPy Trace object. 

            new_header = {} 

            for i, j in convert_dict.iteritems(): 

                value = header[i] 

                if isinstance(value, str): 

                    value = value.strip() 

                new_header[j] = value 

            # assign gse specific header entries 

            new_header['gse2'] = {} 

            for i in gse2_extra: 

                new_header['gse2'][i] = header[i] 

            # Calculate start time. 

            new_header['starttime'] = UTCDateTime( 

                header['d_year'], header['d_mon'], header['d_day'], 

                header['t_hour'], header['t_min'], 0) + header['t_sec'] 

            if headonly: 

                traces.append(Trace(header=new_header)) 

            else: 

                traces.append(Trace(header=new_header, data=data)) 

    f.close() 

    return Stream(traces=traces) 

 

 

def writeGSE2(stream, filename, inplace=False, **kwargs):  # @UnusedVariable 

    """ 

    Write GSE2 file from a Stream object. 

 

    .. warning:: 

        This function should NOT be called directly, it registers via the 

        the :meth:`~obspy.core.stream.Stream.write` method of an 

        ObsPy :class:`~obspy.core.stream.Stream` object, call this instead. 

 

    :type stream: :class:`~obspy.core.stream.Stream` 

    :param stream: The ObsPy Stream object to write. 

    :type filename: string 

    :param filename: Name of file to write. 

    :type inplace: boolean, optional 

    :param inplace: If True, do compression not on a copy of the data but 

        on the data itself - note this will change the data values and make 

        them therefore unusable! 

 

    .. rubric:: Example 

 

    >>> from obspy import read 

    >>> st = read() 

    >>> st.write('filename.gse', format='GSE2') #doctest: +SKIP 

    """ 

    # 

    # Translate the common (renamed) entries 

    f = open(filename, 'wb') 

    for trace in stream: 

        header = {} 

        for _j, _k in convert_dict.iteritems(): 

            header[_j] = trace.stats[_k] 

        for _j in gse2_extra: 

            try: 

                header[_j] = trace.stats.gse2[_j] 

            except: 

                pass 

        # year, month, day, hour, min, sec 

        (header['d_year'], 

            header['d_mon'], 

            header['d_day'], 

            header['t_hour'], 

            header['t_min'], 

            header['t_sec']) = trace.stats.starttime.timetuple()[0:6] 

        header['t_sec'] += trace.stats.starttime.microsecond / 1.0e6 

        dtype = np.dtype('int32') 

        if trace.data.dtype.name == dtype.name: 

            trace.data = np.require(trace.data, dtype, ['C_CONTIGUOUS']) 

        else: 

            msg = "GSE2 data must be of type %s, but are of type %s" % \ 

                (dtype.name, trace.data.dtype) 

            raise Exception(msg) 

        libgse2.write(header, trace.data, f, inplace) 

    f.close() 

 

 

def isGSE1(filename): 

    """ 

    Checks whether a file is GSE1 or not. 

 

    :type filename: string 

    :param filename: GSE1 file to be checked. 

    :rtype: bool 

    :return: ``True`` if a GSE1 file. 

    """ 

    # Open file. 

    try: 

        f = open(filename) 

        data = f.readline() 

    except: 

        return False 

    f.close() 

    if data.startswith('WID1') or data.startswith('XW01'): 

        return True 

    return False 

 

 

def readGSE1(filename, headonly=False, verify_chksum=True, 

             **kwargs):  # @UnusedVariable 

    """ 

    Reads a GSE1 file and returns a Stream object. 

 

    GSE1 files containing multiple WID1 entries/traces are supported. 

 

    .. warning:: 

        This function should NOT be called directly, it registers via the 

        ObsPy :func:`~obspy.core.stream.read` function, call this instead. 

 

    :type filename: string 

    :type param: GSE2 file to be read. 

    :type headonly: boolean, optional 

    :param headonly: If True read only header of GSE1 file. 

    :type verify_chksum: boolean, optional 

    :param verify_chksum: If True verify Checksum and raise Exception if 

        it is not correct. 

    :rtype: :class:`~obspy.core.stream.Stream` 

    :returns: Stream object containing header and data. 

 

    .. rubric:: Example 

 

    >>> from obspy import read 

    >>> st = read("/path/to/y2000.gse") 

    """ 

    traces = [] 

    # read GSE1 file 

    fh = open(filename, 'rb') 

    while True: 

        try: 

            if headonly: 

                header = libgse1.readHeader(fh) 

                traces.append(Trace(header=header)) 

            else: 

                header, data = libgse1.read(fh, verify_chksum=verify_chksum) 

                traces.append(Trace(header=header, data=data)) 

        except EOFError: 

            break 

    fh.close() 

    return Stream(traces=traces)