def test_get_cdelt_pa2():
cdelt = (-1.5, 3)
pa = -25.
header = create_fitsheader((10, 10), cdelt=cdelt, pa=pa)
cdelt_, pa_ = get_cdelt_pa(header)
assert_eq(cdelt, cdelt_)
assert_eq(pa, pa_)
def func(a, mask):
actual = masking(a, mask)
expected = a.copy()
expected[mask] = 0
assert_eq(actual, expected)
masking(a, mask, a)
assert_eq(a, expected)
def test_sum_operator():
for s in SHAPES[1:]:
for a in [None] + list(range(len(s))):
op = SumOperator(axis=a)
d = op.todense(shapein=s)
t = op.T.todense(shapeout=s)
assert_eq(d, t.T)
def func(x1, x2, cdtype):
result = multiply_conjugate(x1, x2)
expected = x1 * x2.conjugate()
assert_eq(result, expected)
result[...] = 0
multiply_conjugate(x1, x2, result)
assert_eq(result, expected)
def f(cls, func, axis, m):
keywords_array = {'unit': 'u'}
if cls is Tod:
keywords_array['mask'] = m
array = cls(data, **keywords_array)
keywords_func = {'axis': axis} if func is not np.round else {}
result = func(array, **keywords_func)
if cls is Tod:
ref = func(np.ma.MaskedArray(array.magnitude, mask=m),
**keywords_func)
if not isinstance(ref, np.ndarray):
ref = np.ma.MaskedArray(ref)
else:
ref = func(array.magnitude, **keywords_func)
assert_equal(result.view(np.ndarray), ref)
if np.isscalar(result):
return
if func is np.var:
assert result._unit == {'u': 2}
else:
assert result._unit == {'u': 1}
if cls is Map:
assert_is_none(result.coverage)
assert_is_none(result.error)
elif cls is Tod:
if result.mask is None:
assert not ref.mask
else:
assert_eq(result.mask, ref.mask)
def func(shape, dtype):
d = MPIDistributionGlobalOperator(shape)
x_global = np.ones(shape, dtype)
s = split(shape[0], size, rank)
x_local = d(x_global)
assert_eq(x_local, x_global[s])
assert_eq(d.T(x_local), x_global)
def test_sum_operator():
for s in SHAPES[1:]:
for a in [None] + list(range(len(s))):
op = SumOperator(axis=a)
d = op.todense(shapein=s)
t = op.T.todense(shapeout=s)
assert_eq(d, t.T)
def f(cls, func, axis, m):
keywords_array = {'unit': 'u'}
if cls is Tod:
keywords_array['mask'] = m
array = cls(data, **keywords_array)
keywords_func = {'axis': axis} if func is not np.round else {}
result = func(array, **keywords_func)
if cls is Tod:
ref = func(np.ma.MaskedArray(array.magnitude, mask=m),
**keywords_func)
if not isinstance(ref, np.ndarray):
ref = np.ma.MaskedArray(ref)
else:
ref = func(array.magnitude, **keywords_func)
assert_equal(result.view(np.ndarray), ref)
if np.isscalar(result):
return
if func is np.var:
assert result._unit == {'u': 2}
else:
assert result._unit == {'u': 1}
if cls is Map:
assert_is_none(result.coverage)
assert_is_none(result.error)
elif cls is Tod:
if result.mask is None:
assert not ref.mask
else:
assert_eq(result.mask, ref.mask)
def func(shape, dtype):
d = MPIDistributionGlobalOperator(shape)
x_global = np.ones(shape, dtype)
s = split(shape[0], size, rank)
x_local = d(x_global)
assert_eq(x_local, x_global[s])
assert_eq(d.T(x_local), x_global)
def test_endian():
bendian = _read_filters(path + 'invntt_be', bigendian=True)
lendian = _read_filters(path + 'invntt_le')
assert len(bendian) == 6
assert bendian[0]['data'].size == 101
assert_same(bendian[0]['data'][0], 5597147.4155586753)
assert_eq(lendian, bendian)
def func(shape, axis):
dX = DifferenceOperator(axis=axis, shapein=shape)
a = np.arange(product(shape)).reshape(shape)
assert_eq(dX(a), np.diff(a, axis=axis))
dX_dense = dX.todense()
dXT_dense = dX.T.todense()
assert_eq(dX_dense.T, dXT_dense)
def func(n, m):
slices = split(n, m)
assert_eq(len(slices), m)
x = np.zeros(n, int)
for s in slices:
x[s] += 1
assert_same(x, 1, broadcasting=True)
assert_eq([split(n, m, i) for i in range(m)], slices)
def func(shape, axis):
dX = DifferenceOperator(axis=axis, shapein=shape)
a = np.arange(product(shape)).reshape(shape)
assert_eq(dX(a), np.diff(a, axis=axis))
dX_dense = dX.todense()
dXT_dense = dX.T.todense()
assert_eq(dX_dense.T, dXT_dense)
def func(n, m):
slices = split(n, m)
assert_eq(len(slices), m)
x = np.zeros(n, int)
for s in slices:
x[s] += 1
assert_same(x, 1, broadcasting=True)
assert_eq([split(n, m, i) for i in range(m)], slices)
def func(c, o, r):
op = MultiplicationOperator([c, o])
assert_eq(op(v), c.data*o(v))
assert_is_type(op, r[0])
if type(op) is CompositionOperator:
op = op.operands[0]
r = r[1]
assert_is_type(op, r[0])
assert_eq, op.data, r[1]
def func(opout, opin, idin):
if opin is not None and idin is not None and opin != idin:
return
p = Op(shapeout=opout, shapein=opin) * IdentityOperator(shapein=idin)
if idin is None:
idin = opin
assert_is_instance(p, Op)
assert_eq(p.shapein, idin)
assert_eq(p.shapeout, opout)
def func(k1, k2):
c1 = ConvolutionOperator(k1, shape)
c2 = ConvolutionOperator(k2, shape)
c = c1 * c2
if k1.dtype.kind == 'f' and k2.dtype.kind == 'f':
assert_is_instance(c, _FFTWRealConvolutionOperator)
else:
assert_is_instance(c, CompositionOperator)
assert_eq(len(c.operands), 3)
assert np.allclose(c(image.real), ref)
def test_wcsoperator_kapteyn():
from pysimulators.wcsutils import WCSKapteynToWorldOperator
path = os.path.join(os.path.dirname(__file__), 'data/header_gnomonic.fits')
header = pyfits.open(path)[0].header
toworld_kapteyn = WCSKapteynToWorldOperator(header)
crpix = (header['CRPIX1'], header['CRPIX2'])
crval = (header['CRVAL1'], header['CRVAL2'])
assert_eq(toworld_kapteyn(crpix), crval)
assert_eq(toworld_kapteyn.I(crval), crpix)
def test_diagonal_numexpr2():
d1 = DiagonalNumexprOperator([1, 2, 3], '(data+1)*3',
broadcast='rightward')
d2 = DiagonalNumexprOperator([3, 2, 1], '(data+2)*2')
d = d1 * d2
assert_is_instance(d, DiagonalOperator)
assert_eq(d.broadcast, 'disabled')
assert_eq(d.data, [60, 72, 72])
c = BlockColumnOperator(3*[IdentityOutplaceOperator()], new_axisout=0)
v = [1, 2]
assert_inplace_outplace(d1*c, v, d1(c(v)))
def test_diagonal_numexpr2():
d1 = DiagonalNumexprOperator([1, 2, 3],
'(data+1)*3',
broadcast='rightward')
d2 = DiagonalNumexprOperator([3, 2, 1], '(data+2)*2')
d = d1 * d2
assert_is_instance(d, DiagonalOperator)
assert_eq(d.broadcast, 'disabled')
assert_eq(d.data, [60, 72, 72])
c = BlockColumnOperator(3 * [IdentityOutplaceOperator()], new_axisout=0)
v = [1, 2]
assert_inplace_outplace(d1 * c, v, d1(c(v)))
def func(broadcast, values):
if broadcast == 'rightward':
expected = (values.T * (diag.T + 1) * 3).T
else:
expected = values * (diag + 1) * 3
op = DiagonalNumexprOperator(diag, expr, broadcast=broadcast)
if broadcast in ('leftward', 'rightward'):
assert op.broadcast == broadcast
assert_is_none(op.shapein)
else:
assert op.broadcast == 'disabled'
assert_eq(op.shapein, diag.shape)
assert_eq(op.shapeout, diag.shape)
assert_inplace_outplace(op, values, expected)
def func(broadcast, values):
if broadcast == 'rightward':
expected = (values.T*(diag.T+1)*3).T
else:
expected = values*(diag+1)*3
op = DiagonalNumexprOperator(diag, expr, broadcast=broadcast)
if broadcast in ('leftward', 'rightward'):
assert op.broadcast == broadcast
assert_is_none(op.shapein)
else:
assert op.broadcast == 'disabled'
assert_eq(op.shapein, diag.shape)
assert_eq(op.shapeout, diag.shape)
assert_inplace_outplace(op, values, expected)
def test1():
# creation of the sky map
msize = 50
mymap = gaussian(2*(msize*2+1,), 10, unit='Jy/pixel')
cd = np.array([[-1., 0.],[0., 1.]]) / 3600.
header = create_fitsheader(fromdata=mymap, crval=[53.,27.], cd=cd)
mymap.header = header
# creation of the simulation
scan = PacsObservation.create_scan((header['CRVAL1'], header['CRVAL2']),
instrument_angle=0., length=60, nlegs=1, angle=20.)
simul = PacsSimulation(scan, 'red', policy_bad_detector='keep',
policy_other='keep')
# build the acquisition model
model = CompressionAverageOperator(simul.slice.compression_factor) * \
simul.get_projection_operator(header=header, npixels_per_sample=49)
# get the noiseless tod
tod = model(mymap)
filename = 'simul-'+str(uuid1())+'.fits'
try:
simul.save(filename, tod)
simul2 = PacsObservation(filename, policy_bad_detector='keep',
policy_other='keep')
status2 = simul2.status
tod2 = simul2.get_tod()
finally:
try:
os.remove(filename)
except:
pass
for field in simul.status.dtype.names:
if field == 'BAND': continue
assert_eq(simul.status[field], status2[field])
assert_eq(tod, tod2)
fields = [x for x in simul.slice.dtype.names if x not in ('filename','unit')]
for field in fields:
if getattr(simul.slice[0], field) != getattr(simul2.slice[0], field):
msg = "Field '" + field + "'"
if field == 'scan_step':
print(msg + ' not implemented.')
else:
assert False
def test_block_column2():
p = np.matrix([[1, 0], [0, 2], [1, 0]])
o = asoperator(np.matrix(p))
e = BlockColumnOperator([o, 2*o], axisout=0)
assert_eq(e.todense(), np.vstack([p, 2*p]))
assert_eq(e.T.todense(), e.todense().T)
e = BlockColumnOperator([o, 2*o], new_axisout=0)
assert_eq(e.todense(), np.vstack([p, 2*p]))
assert_eq(e.T.todense(), e.todense().T)
def test_block_row2():
p = np.matrix([[1, 0], [0, 2], [1, 0]])
o = asoperator(np.matrix(p))
r = BlockRowOperator([o, 2 * o], axisin=0)
assert_eq(r.todense(), np.hstack([p, 2 * p]))
assert_eq(r.T.todense(), r.todense().T)
r = BlockRowOperator([o, 2 * o], new_axisin=0)
assert_eq(r.todense(), np.hstack([p, 2 * p]))
assert_eq(r.T.todense(), r.todense().T)
def test_block_column2():
p = np.matrix([[1, 0], [0, 2], [1, 0]])
o = asoperator(np.matrix(p))
e = BlockColumnOperator([o, 2 * o], axisout=0)
assert_eq(e.todense(), np.vstack([p, 2 * p]))
assert_eq(e.T.todense(), e.todense().T)
e = BlockColumnOperator([o, 2 * o], new_axisout=0)
assert_eq(e.todense(), np.vstack([p, 2 * p]))
assert_eq(e.T.todense(), e.todense().T)
def test_block_row2():
p = np.matrix([[1, 0], [0, 2], [1, 0]])
o = asoperator(np.matrix(p))
r = BlockRowOperator([o, 2*o], axisin=0)
assert_eq(r.todense(), np.hstack([p, 2*p]))
assert_eq(r.T.todense(), r.todense().T)
r = BlockRowOperator([o, 2*o], new_axisin=0)
assert_eq(r.todense(), np.hstack([p, 2*p]))
assert_eq(r.T.todense(), r.todense().T)
def func_rightward(a, key):
b = a[key]
if np.isscalar(b):
assert b.dtype == np.float64
return
if key is Ellipsis:
assert_eq(b.derived_units['r[rightward]'],
a.derived_units['r[rightward]'])
if key in ((1, 2, 3), (1, 2, 3, 4), (1, 2, 3, _)):
assert 'r' in b.derived_units
assert b.derived_units['r'] == Quantity(23)
else:
assert 'r' not in b.derived_units
if not isinstance(key, tuple):
key = (key,)
assert_eq(b.derived_units['r[rightward]'],
a.derived_units['r[rightward]'][key[:3]])
def func(n, s, m):
if s is not Ellipsis:
tmp = np.ones(n, bool)
tmp[s] = False
s = tmp
layout = PackedTable(n, selection=s, val=np.arange(n)*2.)
slices = layout.split(m)
assert_eq(len(slices), m)
o = np.zeros(layout.shape, int)
v = np.full(layout.shape, np.nan)
for s in slices:
o[s._index] += 1
v[s._index] = s.val
o[o == 0] = -1
assert_same(o, layout.unpack(1))
assert_same(v, layout.all.val)
assert_same(np.concatenate([_.val for _ in slices]), layout.val)
def func(c1, t1, c2, t2):
op2 = ConstantOperator(c2, broadcast=t2)
op = op1 + op2
if set((op1.broadcast, op2.broadcast)) != \
set(('rightward', 'leftward')):
assert_is_instance(op, ConstantOperator)
v = np.zeros((2, 3))
op(np.nan, v)
z = np.zeros((2, 3))
if t1 == 'rightward':
z.T[...] += c1.T
else:
z[...] += c1
if t2 == 'rightward':
z.T[...] += c2.T
else:
z[...] += c2
assert_eq(v, z)
def test_settingerr():
ref1 = np.seterr()
ref2 = {"divide": "ignore", "invalid": "ignore", "over": "ignore", "under": "ignore"}
ref3 = {"divide": "raise", "invalid": "ignore", "over": "warn", "under": "ignore"}
with settingerr(all="ignore"):
assert_eq(np.seterr(), ref2)
with settingerr(divide="raise", over="warn"):
assert_eq(np.seterr(), ref3)
assert_eq(np.seterr(), ref2)
assert_eq(np.seterr(), ref1)
def test_settingerr():
ref1 = np.seterr()
ref2 = {'divide': 'ignore', 'invalid': 'ignore', 'over': 'ignore',
'under': 'ignore'}
ref3 = {'divide': 'raise', 'invalid': 'ignore', 'over': 'warn',
'under': 'ignore'}
with settingerr(all='ignore'):
assert_eq(np.seterr(), ref2)
with settingerr(divide='raise', over='warn'):
assert_eq(np.seterr(), ref3)
assert_eq(np.seterr(), ref2)
assert_eq(np.seterr(), ref1)
def func_leftward(a, key):
b = a[key]
if np.isscalar(b):
assert b.dtype == np.float64
return
if key is Ellipsis:
assert_eq(b.derived_units['r[leftward]'],
a.derived_units['r[leftward]'])
if key in ((1, 2, 3, 4), (_, 1, 2, 3)):
assert 'r' in b.derived_units
if key == (1, 2, 3, 4):
assert b.derived_units['r'] == Quantity(59)
else:
assert b.derived_units['r'] == Quantity(33)
else:
assert 'r' not in b.derived_units
if not isinstance(key, tuple):
key = (key,)
key += (4-len(key)) * (slice(None),)
assert_eq(b.derived_units['r[leftward]'],
a.derived_units['r[leftward]'][key[-3:]])
def func(s, v):
layout = PackedTable((6, 6), key=v)
assert 'key' in layout._special_attributes
assert isscalarlike(layout.key)
assert_eq(layout.key, v)
assert_eq(layout.key.shape, ())
assert_same(layout.all.key, v, broadcasting=True)
assert_same(layout.all.key.shape, layout.shape)
s(layout, 'key', v)
assert isscalarlike(layout.key)
assert_eq(layout.key, v)
assert_eq(layout.key.shape, ())
assert_same(layout.all.key, v, broadcasting=True)
assert_same(layout.all.key.shape, layout.shape)
def test1():
q = Quantity(1, 'km')
assert_eq(q.SI, Quantity(1000, 'm'))
q = Quantity(1, 'm')
assert_eq(q, q.tounit('m'))
q2 = q.copy()
q.inunit('m')
assert_eq(q, q2)
def func(op_, id_):
op = op_(id_)
assert_is_type(op, type(op_))
attr = {}
assert_is(op.classout, op_.classout)
attr.update(id_.attrout)
attr.update(op_.attrout)
assert_eq(op.attrout, attr)
assert_eq(op.flags.linear, op_.flags.linear)
assert_eq(op.flags.contiguous_input, op_.flags.contiguous_input)
def test_izip_broadcast2():
a = [1]
b = (np.sin,)
c = np.arange(3).reshape((1, 3))
aa = []; bb = []; cc = []
for a_, b_, c_ in izip_broadcast(a, b, c):
aa.append(a_)
bb.append(b_)
cc.append(c_)
assert_eq(aa, a)
assert_eq(tuple(bb), b)
assert_eq(cc, c)
def func(v):
a = A()
a.a, a.b, a.c = v
if any(_ > 2 for _ in v):
try:
sc(a)
except StopIteration as e:
if a.a > 2:
assert_eq(str(e), str(sc1))
elif a.b > 2:
assert_eq(str(e), str(sc2))
else:
assert_eq(str(e), str(sc3))
def func(v):
a = A()
a.a, a.b, a.c = v
if any(_ > 2 for _ in v):
try:
sc(a)
except StopIteration as e:
if a.a > 2:
assert_eq(str(e), str(sc1))
elif a.b > 2:
assert_eq(str(e), str(sc2))
else:
assert_eq(str(e), str(sc3))
def test_izip_broadcast2():
a = [1]
b = (np.sin,)
c = np.arange(3).reshape((1, 3))
aa = []
bb = []
cc = []
for a_, b_, c_ in izip_broadcast(a, b, c):
aa.append(a_)
bb.append(b_)
cc.append(c_)
assert_eq(aa, a)
assert_eq(tuple(bb), b)
assert_eq(cc, c)
def test_fibonacci():
class Fibonacci(IterativeAlgorithm):
def __init__(self, **keywords):
IterativeAlgorithm.__init__(self, x_old=0, x=1, **keywords)
def iteration(self):
np.add(self.x_old, self.x, self.x_new)
def finalize(self):
return int(self.x)
fib = Fibonacci(normal_stop_condition=MaxIterationStopCondition(10))
assert_eq(fib.run(), 55)
fib.initialize()
assert_eq(list(fib), [1, 2, 3, 5, 8, 13, 21, 34, 55])
assert_eq(fib.restart(), 55)
def func(n):
assert_eq(d.todense(shapein=n), d.todense(shapein=n, inplace=True))
assert_eq(d.T.todense(shapein=n), d.T.todense(shapein=n, inplace=True))
def func(dtype, expected):
if expected is None:
assert_raises(TypeError, float_dtype, dtype)
else:
actual = float_dtype(dtype)
assert_eq(actual, expected)
def func(shape, dtype):
x_global = np.ones(shape, dtype)
d = MPIDistributionIdentityOperator()
assert_eq(d(x_global), x_global)
x_local = x_global * (rank + 1)
assert_eq(d.T(x_local), np.ones(shape) * size * (size + 1) // 2)
def test_multiple_pointings():
ra = (23, 24)
dec = (50, 51)
instrument_angle=(10, 11)
scan_angle = (0, -90)
scan_length = (10, 20)
scan_nlegs = (2, 3)
scan_step = (147, 149)
scan_speed = (20, 60)
compression_factor = (4, 4)
acc = PacsSimulation.ACCELERATION
pointings = [PacsObservation.create_scan((r,d),sl,sst,None,ssp,acc,sn,sa,ia,
cf,False) for r,d,ia,sa,sl,sn,sst,ssp,cf in zip(ra,dec,
instrument_angle,scan_angle,scan_length,scan_nlegs,scan_step,
scan_speed,compression_factor)]
simul = PacsSimulation(pointings, 'blue')
s = simul.slice
assert len(s) == 2
assert_eq(s.ra, ra)
assert_eq(s.dec, dec)
assert_eq(s.instrument_angle, instrument_angle)
assert_eq(s.scan_angle, scan_angle)
assert_eq(s.scan_length, scan_length)
assert_eq(s.scan_nlegs, scan_nlegs)
assert_eq(s.scan_step, scan_step)
assert_eq(s.scan_speed, scan_speed)
assert_eq(s.compression_factor, compression_factor)
def func(o, e):
layout = PackedTable((2, 3), ordering=o)
assert_eq(layout._index, e)
def test_strenum():
assert_eq(strenum(['blue', 'red', 'yellow'], 'or'),
"'blue', 'red' or 'yellow'")
def test_mask_policy1():
good_policy = ['kEep', 'removE', 'MASK']
mask_policy = MaskPolicy(flags, good_policy)
assert_eq(np.array(mask_policy), (0, 2, 1))
assert mask_policy.bad == 'keep' and mask_policy.u1 == 'remove' and \
mask_policy.u2 == 'mask'
def func(n, nonumber, s, expected):
assert_eq(strplural(n, 'cat', nonumber=nonumber, s=s), expected)
