def testContinuousDownsample(self):
y = num.random.random(1000)
for (dt1, dt2) in [(0.1, 1.0), (0.2, 1.0), (0.5, 1.0), (0.2, 0.4),
(0.4, 1.2)]:
for tadd in (0.0, 0.01, 0.2, 0.5, 0.7, 0.75):
a = trace.Trace(tmin=sometime + tadd, deltat=dt1, ydata=y)
bs = [
trace.Trace(location='b',
tmin=sometime + i * dt1 * 100 + tadd,
deltat=dt1,
ydata=y[i * 100:(i + 1) * 100])
for i in range(10)
]
a.downsample_to(dt2, demean=False, snap=True)
c2s = []
downsampler = trace.co_downsample_to(trace.co_list_append(c2s),
dt2)
for b in bs:
c = downsampler.send(b)
c2s.append(c)
downsampler.close()
assert (round(c2s[0].tmin / dt2) * dt2 - c2s[0].tmin) \
/ dt1 < 0.5001
def testMisfitOfSameTracesZero(self):
y = num.random.random(10000)
y -= max(y) * 0.5
t1 = trace.Trace(tmin=0, ydata=y, deltat=0.01)
t2 = trace.Trace(tmin=0, ydata=y, deltat=0.01)
# ttraces = [t2]
fresponse = trace.FrequencyResponse()
taper = trace.CosFader(xfade=2.)
norms = [1, 2]
domains = ['time_domain', 'frequency_domain', 'envelope', 'absolute']
setups = [
trace.MisfitSetup(norm=n,
taper=taper,
domain=domain,
filter=fresponse) for domain in domains
for n in norms
]
for setup in setups:
m, n, tr, tc = t1.misfit(candidate=t2, setup=setup, debug=True)
if isinstance(tr, trace.Trace):
self.assertEqual(tr.tmin, tc.tmin)
self.assertTrue(all(tr.get_ydata() == tc.get_ydata()))
else:
self.assertTrue(all(tc == tr))
self.assertEqual(m, 0., 'misfit\'s m of equal traces is != 0')
def testCorrelate(self):
for la, lb, mode, res in [([0, 1, .5, 0, 0], [0, 0, 0, 1,
0], 'same', 0.3),
([0, 1, .5, 0, 0, 0], [0, 1,
0], 'valid', 0.1),
([0, 1, .5], [0, 0, 0, 1, 0,
0], 'full', 0.3)]:
for ia in range(5):
for ib in range(5):
ya = floats(la + [0] * ia)
yb = floats(lb + [0] * ib)
a = trace.Trace(tmin=10., deltat=0.1, ydata=ya)
b = trace.Trace(tmin=10.1, deltat=0.1, ydata=yb)
c = trace.correlate(a, b, mode=mode)
if not numeq(c.max(), [res, 1.], 0.0001):
print
print mode
print len(ya), ya
print len(yb), yb
print c.ydata, c.max()
def testFFTCorrelate(self):
for na in range(1, 20):
for nb in range(1, 20):
a1 = num.random.random(na)
a2 = num.random.random(nb)
t1 = trace.Trace(station='t1', ydata=a1)
t2 = trace.Trace(station='t2', ydata=a2)
for mode in 'full', 'same', 'valid':
c1 = trace.correlate(t1, t2, mode=mode)
c2 = trace.correlate(t1, t2, mode=mode, use_fft=True)
c1.set_station('c1')
c2.set_station('c2')
assert c1.get_ydata().size == c2.get_ydata().size
d = num.abs(c1.get_ydata() - c2.get_ydata())
if not num.all(d < 1e-5):
assert mode == 'same'
assert abs(abs(c1.tmin - c2.tmin) - 1.0) < 1e-5
assert abs(abs(c1.tmax - c2.tmax) - 1.0) < 1e-5
tmin = max(c1.tmin, c2.tmin)
tmax = min(c1.tmax, c2.tmax)
c1.chop(tmin, tmax, include_last=True)
c2.chop(tmin, tmax, include_last=True)
d = num.abs(c1.get_ydata() - c2.get_ydata())
assert (num.all(d < 1e-5))
else:
assert num.all(d < 1e-5)
def testCropping(self):
n = 20
tmin = sometime
t = trace.Trace(tmin=tmin,
deltat=0.05,
ydata=num.ones(n, dtype=num.float))
tmax = t.tmax
t.ydata[:3] = 0.0
t.ydata[-3:] = 0.0
t.crop_zeros()
assert abs(t.tmin - (tmin + 0.05 * 3)) < 0.05 * 0.01
assert abs(t.tmax - (tmax - 0.05 * 3)) < 0.05 * 0.01
t = trace.Trace(tmin=tmin,
deltat=0.05,
ydata=num.zeros(n, dtype=num.float))
ok = False
try:
t.crop_zeros()
except trace.NoData:
ok = True
assert ok
t = trace.Trace(tmin=tmin,
deltat=0.05,
ydata=num.ones(n, dtype=num.float))
t.crop_zeros()
assert t.ydata.size == 20
def testProjection(self):
s2 = math.sqrt(2.)
ndata = num.array([s2,s2], dtype=num.float)
edata = num.array([s2,0.], dtype=num.float)
ddata = num.array([1.,-1.], dtype=num.float)
dt = 1.0
n = trace.Trace(deltat=dt, ydata=ndata, tmin=100, channel='N')
e = trace.Trace(deltat=dt, ydata=edata, tmin=100, channel='E')
d = trace.Trace(deltat=dt, ydata=ddata, tmin=100, channel='D')
azi = 45.
cazi = math.cos(azi*d2r)
sazi = math.sin(azi*d2r)
rot45 = num.array([[cazi, sazi, 0],[-sazi,cazi, 0], [0,0,-1]], dtype=num.float)
C = lambda x: model.Channel(x)
rotated = trace.project([n,e,d], rot45, [C('N'),C('E'),C('D')], [C('R'),C('T'),C('U')])
for tr in rotated:
if tr.channel == 'R':
r = tr
if tr.channel == 'T':
t = tr
if tr.channel == 'U':
u = tr
assert( num.all(r.get_ydata() - num.array([ 2., 1. ]) < 1.0e-6 ) )
assert( num.all(t.get_ydata() - num.array([ 0., -1 ]) < 1.0e-6 ) )
assert( num.all(u.get_ydata() - num.array([ -1., 1. ]) < 1.0e-6 ) )
deps = trace.project_dependencies(rot45, [C('N'),C('E'),C('D')], [C('R'),C('T'),C('U')])
assert( set(['N','E']) == set(deps['R']) and set(['N', 'E']) == set(deps['T']) and
set(['D']) == set(deps['U']) )
# should work though no horizontals given
projected = trace.project([d], rot45, [C('N'),C('E'),C('D')], [C('R'),C('T'),C('U')])
if tr.channel == 'U': u = tr
assert( num.all(u.get_ydata() - num.array([ -1., 1. ]) < 1.0e-6 ) )
def test_trace_equal(self):
ydata = num.arange(10)
tr1 = trace.Trace(ydata=ydata)
tr2 = trace.Trace(ydata=ydata)
tr_set = set([tr1, tr2])
assert len(tr_set), 2
def testEqualizeSamplingRates(self):
y = num.random.random(1000)
t1 = trace.Trace(tmin=0, ydata=y, deltat=0.01)
t2 = trace.Trace(tmin=0, ydata=y, deltat=0.5)
t1_new, t2_new = trace.equalize_sampling_rates(t1, t2)
self.assertEqual(
t1_new.deltat, t2_new.deltat,
'Equalization of sampling rates failed: dt1=%s, dt2=%s' %
(t1.deltat, t2.deltat))
def testAdd2(self):
for toff in num.random.random(100):
t1 = trace.Trace(tmin=sometime,
deltat=0.05,
ydata=num.ones(5, dtype=num.float))
t2 = trace.Trace(tmin=sometime - toff * 0.1,
deltat=0.05,
ydata=num.ones(5, dtype=num.float))
t1.add(t2, interpolate=False)
def testCorrelateNormalization(self):
ya = floats([1, 2, 1])
yb = floats([0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 2, 1])
a = trace.Trace(tmin=sometime, deltat=0.1, ydata=ya)
b = trace.Trace(tmin=sometime, deltat=0.1, ydata=yb)
c_ab = trace.correlate(a, b)
c_ab2 = trace.correlate(a, b, normalization='gliding')
c_ba = trace.correlate(b, a)
c_ba2 = trace.correlate(b, a, normalization='gliding')
assert numeq(c_ab.ydata, c_ba.ydata[::-1], 0.001)
assert numeq(c_ab2.ydata, c_ba2.ydata[::-1], 0.001)
def testLQTRotation(self):
ba = 225.
inci = 90. - num.arctan(1. / num.sqrt(2.)) * 180. / num.pi
in_channels = list('ZEN')
zdata = num.ones(2)
edata = num.ones(2)
ndata = num.ones(2)
z = trace.Trace(deltat=1., ydata=zdata, tmin=1., channel='Z')
e = trace.Trace(deltat=1., ydata=edata, tmin=1., channel='E')
n = trace.Trace(deltat=1., ydata=ndata, tmin=1., channel='N')
l, q, t = trace.rotate_to_lqt([z, n, e], ba, inci, in_channels)
assert (num.all(l.get_ydata() - num.sqrt(3.) < 1.0e-12))
assert (num.all(t.get_ydata() < 1.0e-12))
assert (num.all(q.get_ydata() < 1.0e-12))
def testAdd(self):
n = 20
tmin = sometime
deltat = 0.05
for distortion in [ -0.2, 0.2 ]:
for ioffs, result in [ ( 1, [0.,1.,1.,1.,0.]),
( -1, [1.,1.,0.,0.,0.]),
( 3, [0.,0.,0.,1.,1.]),
( 10, [0.,0.,0.,0.,0.]),
( -10, [0.,0.,0.,0.,0.]) ]:
a = trace.Trace(tmin=tmin, deltat=deltat, ydata=num.zeros(5,dtype=num.float))
b = trace.Trace(tmin=tmin+(ioffs+distortion)*deltat, deltat=deltat, ydata=num.ones(3,dtype=num.float))
a.add(b, interpolate=False)
assert numeq(a.ydata, result, 0.001)
def testFiltering(self):
tmin = sometime
b = time.time()
for i in range(100):
n = 10000
t = trace.Trace(tmin=tmin, deltat=0.05, ydata=num.ones(n,dtype=num.float))
t.lowpass(4, 5.)
t.highpass(4, 0.1)
d1 = time.time() - b
b = time.time()
for i in range(100):
n = 10000
t = trace.Trace(tmin=tmin, deltat=0.05, ydata=num.ones(n,dtype=num.float))
t.bandpass_fft(0.1, 5.)
d2 = time.time() - b
def iload(filename, load_data=True):
from pyrocko import mseed_ext
have_zero_rate_traces = False
try:
traces = []
for tr in mseed_ext.get_traces(filename, load_data):
network, station, location, channel = tr[1:5]
tmin = float(tr[5]) / float(mseed_ext.HPTMODULUS)
tmax = float(tr[6]) / float(mseed_ext.HPTMODULUS)
try:
deltat = reuse(1.0 / float(tr[7]))
except ZeroDivisionError as e:
have_zero_rate_traces = True
continue
ydata = tr[8]
traces.append(
trace.Trace(network, station, location, channel, tmin, tmax,
deltat, ydata))
for tr in traces:
yield tr
except (OSError, mseed_ext.MSeedError) as e:
raise FileLoadError(str(e) + ' (file: %s)' % filename)
if have_zero_rate_traces:
logger.warning('Ignoring traces with sampling rate of zero in file %s '
'(maybe LOG traces)' % filename)
def testExtend(self):
tmin = sometime
t = trace.Trace(tmin=tmin, ydata=num.ones(10, dtype=num.float))
tmax = t.tmax
t.extend(tmin - 10.2, tmax + 10.7)
assert int(round(tmin - t.tmin)) == 10
assert int(round(t.tmax - tmax)) == 11
assert num.all(t.ydata[:10] == num.zeros(10, dtype=num.float))
assert num.all(t.ydata[-11:] == num.zeros(11, dtype=num.float))
assert num.all(t.ydata[10:-11] == num.ones(10, dtype=num.float))
t = trace.Trace(tmin=tmin, ydata=num.arange(10, dtype=num.float) + 1.)
t.extend(tmin - 10.2, tmax + 10.7, fillmethod='repeat')
assert num.all(t.ydata[:10] == num.ones(10, dtype=num.float))
assert num.all(t.ydata[-11:] == num.zeros(11, dtype=num.float) + 10.)
assert num.all(t.ydata[10:-11] == num.arange(10, dtype=num.float) + 1.)
def testRotation(self):
s2 = math.sqrt(2.)
ndata = num.array([s2, s2], dtype=num.float)
edata = num.array([s2, 0.], dtype=num.float)
dt = 1.0
n = trace.Trace(deltat=dt, ydata=ndata, tmin=100, channel='N')
e = trace.Trace(deltat=dt, ydata=edata, tmin=100, channel='E')
rotated = trace.rotate([n, e], 45., ['N', 'E'], ['R', 'T'])
for tr in rotated:
if tr.channel == 'R':
r = tr
if tr.channel == 'T':
t = tr
assert numeq(r.get_ydata(), [2., 1.], 1.0e-6)
assert numeq(t.get_ydata(), [0., -1], 1.0e-6)
def get_traces(self):
station, network = self.get_station(), self.get_network()
traces = []
for icomp, comp in enumerate(self.components):
channel = comp
for (whichset, sgram) in zip(
('references', 'synthetics'),
(self.ref_seismograms[icomp], self.syn_seismograms[icomp])):
if sgram and len(sgram[0]) > 1:
starttime = sgram[0][0]
endtime = sgram[0][-1]
deltat = (endtime - starttime) / (len(sgram[0]) - 1)
data = sgram[1]
location = whichset
tr = trace.Trace(network,
station,
location,
channel,
tmin=starttime,
tmax=endtime,
deltat=deltat,
ydata=data)
traces.append(tr)
return traces
def to_trace(self):
assert self.iftype == SacFile.header_name2num['itime']
assert self.leven == True
tmin = self.get_ref_time() + self.b
tmax = tmin + self.delta*(self.npts-1)
data =None
if self.data:
data = self.data[0]
meta = {}
exclude = ('b', 'e', 'knetwk', 'kstnm', 'khole', 'kcmpnm', 'delta', 'nzyear', 'nzjday', 'nzhour', 'nzmin', 'nzsec', 'nzmsec')
for k in SacFile.header_keys:
if k in exclude: continue
v = self.__dict__[k]
if v is not None:
meta[reuse(k)] = v
return trace.Trace(nonetoempty(self.knetwk)[:2],
nonetoempty(self.kstnm)[:5],
nonetoempty(self.khole)[:2],
nonetoempty(self.kcmpnm)[:3],
tmin,
tmax,
self.delta,
data,
meta=meta)
def testIntegrationDifferentiation(self):
tlen = 100.
dt = 0.1
n = int(tlen / dt)
f = 0.5
tfade = tlen / 10.
xdata = num.arange(n) * dt
ydata = num.sin(xdata * 2. * num.pi * f)
a = trace.Trace(channel='A', deltat=dt, ydata=ydata)
b = a.transfer(tfade, (0.0, 0.1, 2., 3.),
transfer_function=trace.IntegrationResponse())
b.set_codes(channel='B')
c = a.transfer(tfade, (0.0, 0.1, 2., 3.),
transfer_function=trace.DifferentiationResponse())
c.set_codes(channel='C')
eps = 0.001
xdata = b.get_xdata()
ydata = b.get_ydata()
ydata_shouldbe = -num.cos(xdata * 2 * num.pi * f) / (2. * num.pi * f)
assert num.amax(num.abs(ydata-ydata_shouldbe)) < eps, \
'integration failed'
xdata = c.get_xdata()
ydata = c.get_ydata()
ydata_shouldbe = num.cos(xdata * 2 * num.pi * f) * (2. * num.pi * f)
assert num.amax(num.abs(ydata-ydata_shouldbe)) < eps, \
'differentiation failed'
def iter_pyrocko_traces(self, load_data=True):
for idata, d in enumerate(self.data):
fn = os.path.join(d['dir'], d['dfile'])
logger.debug('converting %s', d['dfile'])
try:
if load_data:
ydata = self.read_wf_file(os.path.join(self.superdir,
fn), d['nsamp'],
storage_types[d['datatype']],
d['foff'])
else:
ydata = None
except IOError as e:
if e.errno == 2:
logger.debug(e)
continue
else:
raise e
dt = 1. / d['samprate']
yield trace.Trace(station=d['sta'],
channel=d['chan'],
deltat=dt,
tmin=d['time'],
tmax=d['time'] + d['nsamp'] / d['samprate'],
ydata=ydata)
def testProjectionsZOnly(self):
km = 1000.
ev = model.Event(lat=-10, lon=150., depth=0.0)
for azi in num.linspace(0., 360., 37):
lat, lon = orthodrome.ne_to_latlon(ev.lat, ev.lon,
10. * km * math.cos(azi),
10. * km * math.sin(azi))
sta = model.Station(lat=lat, lon=lon)
sta.set_event_relative_data(ev)
sta.set_channels_by_name('BHZ', 'BHN', 'BHE')
traces = [
trace.Trace(channel='BHZ', ydata=num.array([1.0])),
]
projected = []
for m, in_channels, out_channels in sta.guess_projections_to_enu():
projected.extend(
trace.project(traces, m, in_channels, out_channels))
def g(traces, cha):
for tr in traces:
if tr.channel == cha:
return tr
z = g(projected, 'U')
assert (near(z.ydata[0], 1.0, 0.001))
def testWriteRead(self):
now = time.time()
n = 10
deltat = 0.1
networks = [ rn(2) for i in range(5) ]
traces1 = [ trace.Trace(rc(networks), rn(4), rn(2), rn(3), tmin=now+i*deltat*n*2, deltat=deltat, ydata=num.arange(n, dtype=num.int32), mtime=now)
for i in range(3) ]
tempdir = tempfile.mkdtemp()
for format in ('mseed', 'sac', 'yaff'):
fns = io.save(traces1, pjoin(tempdir, '%(network)s_%(station)s_%(location)s_%(channel)s'), format=format)
for fn in fns:
assert io.detect_format(fn) == format
traces2 = []
for fn in fns:
traces2.extend(io.load(fn, format='detect'))
for tr in traces1:
assert tr in traces2, 'failed for format %s' % format
for fn in fns:
os.remove(fn)
shutil.rmtree(tempdir)
def iload(filename, load_data=True, subformat='l4'):
try:
npad = 4
if subformat is not None:
try:
endianness = {'l': '<', 'b': '>'}[subformat[0]]
if len(subformat) > 1:
npad = int(subformat[1:])
except:
raise SeisanFileError('Bad subformat specification: "%s"' %
subformat)
else:
endianness = '<'
f = open(filename, 'r')
try:
read_file_header(f, npad=npad)
except util.UnpackError, e:
raise SeisanFileError('Error loading header from file %s: %s' %
(filename, str(e)))
try:
itrace = 0
while True:
try:
(net, sta, loc, cha, tmin, tflag, deltat, nsamples,
sample_bytes, lat, lon, elevation,
gain) = read_channel_header(f, npad=npad)
data = read_channel_data(f,
endianness,
sample_bytes,
nsamples,
gain,
load_data,
npad=npad)
tmax = None
if data is None:
tmax = tmin + (nsamples - 1) * deltat
t = trace.Trace(net,
sta,
loc,
cha,
tmin=tmin,
tmax=tmax,
deltat=deltat,
ydata=data)
yield t
except util.UnpackError, e:
raise SeisanFileError(
'Error loading trace %i from file %s: %s' %
(itrace, filename, str(e)))
itrace += 1
except EOF:
pass
def process(self):
try:
line = self.slink.stdout.readline()
if not line:
return False
toks = line.split(', ')
if len(toks) != 1:
nslc = tuple(toks[0].split('_'))
if len(nslc) == 3: nslc = nslc[0], nslc[1], '', nslc[2]
nsamples = int(toks[1].split()[0])
rate = float(toks[2].split()[0])
st,sms = toks[3].split()[0].split('.')
us = int(sms)
tstamp = calendar.timegm(time.strptime(st,'%Y,%j,%H:%M:%S'))+us*0.000001
if nsamples != 0:
self.header = nslc, nsamples, rate, tstamp
else:
if self.header:
self.vals.extend([ float(x) for x in line.split() ])
if len(self.vals) == self.header[1]:
nslc, nsamples, rate, tstamp = self.header
deltat = 1.0/rate
net, sta, loc, cha = nslc
tr = trace.Trace(network=net, station=sta, location=loc, channel=cha, tmin=tstamp, deltat=deltat, ydata=num.array(self.vals))
self.got_trace(tr)
self.vals = []
self.header = None
return True
except:
return False
def to_trace(self, data):
tmin = self.begintime - suds_tzero
deltat = 1.0 / self.rate
if data is None:
tmax = tmin + (self.length - 1) * deltat
arr = None
else:
tmax = None
if self.datatype == 'l':
arr = num.fromstring(data, dtype=num.int32)
elif self.datatype == 'i':
arr = num.fromstring(data, dtype=num.int16)
elif self.datatype == 'f':
arr = num.fromstring(data, dtype=num.float32)
elif self.datatype == 'd':
arr = num.fromstring(data, dtype=num.float64)
else:
raise SudsError(
'data type "%s" not implemented yet' % self.datatype)
if self.length != arr.size:
raise SudsError('found and reported number of samples differ')
return trace.Trace(
self.dt_name.network.rstrip('\0 '),
self.dt_name.st_name.rstrip('\0 '),
'',
self.dt_name.component.rstrip('\0 '),
ydata=arr,
deltat=deltat,
tmin=tmin,
tmax=tmax)
def to_trace(self):
return trace.Trace(
'', self.kstnm, '', '',
self.ref_time,
self.ref_time+self.delta*(self.npts-1),
self.delta,
self.data)
def testMisfitBox(self):
ydata = num.zeros(9)
ydata[3:6] = 1.0
deltat = 0.5
tr = trace.Trace(ydata=ydata, deltat=0.5, tmin=0.0)
tshiftmin = -(tr.tmax - tr.tmin) * 2
tshiftmax = (tr.tmax - tr.tmin) * 2
tshifts = num.linspace(
tshiftmin, tshiftmax,
int(round((tshiftmax - tshiftmin) / deltat)) + 1)
candidates = []
for tshift in tshifts:
trc = tr.copy()
trc.shift(tshift)
candidates.append(trc)
trace.MisfitSetup(norm=2,
taper=trace.CosTaper(tr.tmin, tr.tmin, tr.tmax,
tr.tmax),
domain='time_domain')
def iload(filename, load_data=True):
with open(filename, 'r') as f:
read_xw01(f)
try:
while True:
h = read_wid1(f)
(tmin, nsamples, sta, chid, cha, sample_rate, _, data_format,
diff_flag, gain) = h[:10]
deltat = 1.0 / sample_rate
if load_data:
ydata, checksum = read_dat1_chk1(f, data_format, diff_flag,
nsamples)
tmax = None
else:
skip_dat1_chk1(f, data_format, diff_flag, nsamples)
ydata = None
tmax = tmin + (nsamples - 1) * deltat
yield trace.Trace('',
sta,
'',
cha,
tmin=tmin,
tmax=tmax,
deltat=deltat,
ydata=ydata)
except EOF:
pass
def work_block(self, firstx, lastx, nx, z):
# dummy implementation, should be overloaded in subclass
if nx > 1:
dx = (lastx - firstx) / (nx - 1)
else:
dx = 1.0
traces = []
for ix in xrange(nx):
x = firstx + ix * dx
for i in xrange(poel_components):
ig = i + 1
data = num.random.random(100)
tmin = 0.
deltat = self.gfdb_config['dt']
rawtrace = trace.Trace('',
'%i' % ix,
'',
'%i' % ig,
tmin=tmin,
deltat=deltat,
ydata=data)
tr = GFTrace(x, z, ig, rawtrace)
traces.append(tr)
return traces
def get_traces(self):
fn = self.config.get_output_filename(self.tempdir)
data = num.loadtxt(fn, skiprows=1, dtype=num.float)
nsamples, ntraces = data.shape
deltat = (data[-1, 0] - data[0, 0]) / (nsamples - 1)
toffset = data[0, 0]
tred = self.config.time_reduction
rec = self.config.receiver
tmin = rec.tstart + toffset + deltat + tred
traces = []
for itrace, comp in enumerate(self.config.components):
# qseis2d gives velocity-integrate to displacement
# integration removes one sample, add it again in front
displ = cumtrapz(num.concatenate((num.zeros(1), data[:,
itrace + 1])),
dx=deltat)
tr = trace.Trace('',
'%04i' % itrace,
'',
comp,
tmin=tmin,
deltat=deltat,
ydata=displ,
meta=dict(distance=rec.distance, azimuth=0.0))
traces.append(tr)
return traces
