def test_sum_statics(self):
nrecords = 8
store = gf.BaseStore(self.create(nrecords=nrecords))
for i in xrange(5):
n = random.randint(0, 5)
indices = num.random.randint(nrecords, size=n)
weights = num.random.random(n)
shifts = num.random.random(n)*nrecords
dyn = store.sum(
indices, shifts, weights,
itmin=None,
nsamples=None,
decimate=1,
implementation='c',
optimization='enable')
sta = store.sum_statics(
indices, weights,
implementation=None,
optimization='enable')
if len(dyn.data) > 0:
num.testing.assert_array_almost_equal(dyn.data[-1], sta.value,
5)
store.close()
def test_sum_statics(self):
nrecords = 20
store = gf.BaseStore(self.create(nrecords=nrecords))
for i in xrange(5):
n = random.randint(1, 10)
indices = num.random.randint(nrecords, size=n).astype(num.uint64)
weights = num.random.random(n).astype(num.float32)
shifts = (num.random.random(n) * nrecords / 4).astype(num.float32)
it = random.randint(0, 5)
dyn = store.sum(indices,
shifts,
weights,
itmin=it,
nsamples=1,
decimate=1,
implementation='c',
optimization='enable')
sta = store.sum_statics(indices,
shifts,
weights,
it,
1,
nthreads=1)
if len(dyn.data) > 0:
num.testing.assert_array_almost_equal(dyn.data[-1], sta[0], 5)
store.close()
def test_sum(self):
nrecords = 8
random.seed(0)
num.random.seed(0)
store = gf.BaseStore(self.create(nrecords=nrecords))
for deci in (1, 2, 3, 4):
for i in range(300):
n = random.randint(0, 5)
indices = num.random.randint(nrecords, size=n)
weights = num.random.random(n)
shifts = num.random.random(n) * nrecords
shifts[::2] = num.round(shifts[::2])
for itmin, nsamples in [(None, None),
(random.randint(0, nrecords),
random.randint(0, nrecords))]:
a = store.sum(indices,
shifts,
weights,
itmin=itmin,
nsamples=nsamples,
decimate=deci)
b = store.sum(indices,
shifts,
weights,
itmin=itmin,
nsamples=nsamples,
decimate=deci,
implementation='alternative')
c = store.sum(indices,
shifts,
weights,
itmin=itmin,
nsamples=nsamples,
decimate=deci,
implementation='reference')
self.assertEqual(a.itmin, c.itmin)
num.testing.assert_array_almost_equal(a.data, c.data, 2)
self.assertEqual(b.itmin, c.itmin)
num.testing.assert_array_almost_equal(b.data, c.data, 2)
store.close()
def test_get_spans(self):
nrecords = 8
random.seed(0)
num.random.seed(0)
store = gf.BaseStore(self.create(nrecords=nrecords))
for deci in (1, 2, 3, 4):
for i in range(nrecords):
tr = store.get(i, decimate=deci)
itmin, itmax = store.get_span(i, decimate=deci)
self.assertEqual(tr.itmin, itmin)
self.assertEqual(tr.data.size, itmax - itmin + 1)
store.close()
def create(self, deltat=1.0, nrecords=10):
d = mkdtemp(prefix='gfstore')
store = gf.BaseStore.create(d, deltat, nrecords, force=True)
store = gf.BaseStore(d, mode='w')
for i in range(nrecords):
data = num.asarray(num.random.random(random.randint(0, 7)),
dtype=gf.gf_dtype)
tr = gf.GFTrace(data=data, itmin=1 + i)
store.put(i, tr)
store.close()
self.tempdirs.append(d)
return d
def test_partial_get(self):
nrecords = 8
random.seed(0)
num.random.seed(0)
store = gf.BaseStore(self.create(nrecords=nrecords))
for deci in (1, 2, 3, 4):
for i in range(0, nrecords):
tra = store.get(i, decimate=deci, implementation='c')
trb = store.get(i, decimate=deci, implementation='python')
self.assertEqual(tra.itmin, trb.itmin)
self.assertEqual(tra.data.size, trb.data.size)
self.assertTrue(numeq(tra.data, trb.data, 0.001))
self.assertTrue(numeq(tra.begin_value, trb.begin_value, 0.001))
self.assertTrue(numeq(tra.end_value, trb.end_value, 0.001))
tr = tra
itmin_gf, nsamples_gf = tr.itmin, tr.data.size
for itmin in range(itmin_gf - nsamples_gf,
itmin_gf + nsamples_gf + 1):
for nsamples in range(0, nsamples_gf * 3):
for implementation in ['c', 'python']:
tr2 = store.get(i, itmin, nsamples, decimate=deci)
self.assertEqual(tr2.itmin, max(tr.itmin, itmin))
self.assertEqual(
tr2.itmin + tr2.data.size,
max(
min(tr.itmin + tr.data.size,
itmin + nsamples),
tr2.itmin + tr2.data.size))
ilo = max(tr.itmin, tr2.itmin)
ihi = min(tr.itmin + tr.data.size,
tr2.itmin + tr2.data.size)
a = tr.data[ilo - tr.itmin:ihi - tr.itmin]
b = tr2.data[ilo - tr2.itmin:ihi - tr2.itmin]
self.assertTrue(numeq(a, b, 0.001))
store.close()
def test_sum(self):
nrecords = 8
random.seed(0)
num.random.seed(0)
store = gf.BaseStore(self.create(nrecords=nrecords))
from pyrocko.gf import store_ext
store.open()
store_ext.store_mapping_init(
store.cstore, 'type_0',
arr([0]), arr([nrecords-1]), arr([1]),
num.array([nrecords], dtype=num.uint64),
1)
for deci in (1, 2, 3, 4):
for i in range(300):
n = random.randint(0, 5)
indices = num.random.randint(nrecords, size=n)
weights = num.random.random(n)
shifts = num.random.random(n)*nrecords
shifts[::2] = num.round(shifts[::2])
for itmin, nsamples in [(None, None),
(random.randint(0, nrecords),
random.randint(0, nrecords))]:
a = store.sum(
indices, shifts, weights,
itmin=itmin,
nsamples=nsamples,
decimate=deci)
b = store.sum(
indices, shifts, weights,
itmin=itmin,
nsamples=nsamples,
decimate=deci,
implementation='alternative')
c = store.sum(
indices, shifts, weights,
itmin=itmin,
nsamples=nsamples,
decimate=deci,
implementation='reference')
self.assertEqual(a.itmin, c.itmin)
num.testing.assert_array_almost_equal(
a.data, c.data, 2)
self.assertEqual(b.itmin, c.itmin)
num.testing.assert_array_almost_equal(
b.data, c.data, 2)
if deci != 1:
continue
nthreads = 1
source_coords = num.zeros((n, 5))
source_coords[:, 4] = indices
receiver_coords = num.zeros((1, 5))
source_terms = num.zeros((n, 1))
source_terms[:, 0] = weights
results = store_ext.store_calc_timeseries(
store.cstore,
source_coords,
source_terms,
shifts,
receiver_coords,
'dummy',
'nearest_neighbor',
num.array(
[itmin if itmin is not None else 0],
dtype=num.int32),
num.array(
[nsamples if nsamples is not None else -1],
dtype=num.int32),
nthreads)
d = gf.GFTrace(*results[0][:2])
self.assertEqual(a.itmin, d.itmin)
num.testing.assert_array_almost_equal(
a.data, d.data, 2)
store.close()
