def get_fitting_region(order, pixel):
"""Expand tile by quarter of a pixel for fitting
:param order: the HEALPix resolution level
:param pixel: given HEALPix pixel that needs to be fit
:return: HEALPix pixels that need to be fit
"""
#define old and new order
old_nside = 2**order
new_nside = 2**(order + 2)
#get co-ord of main pixel
theta, phi = pixelfunc.pix2ang(old_nside, pixel, nest=True)
#define offsets such that main pixel is split into four sub pixels
scale = pixelfunc.max_pixrad(old_nside)
offset_theta = np.array([-0.125, 0.0, 0.125, 0.0]) * scale
offset_phi = np.array([0.0, -0.125, 0.0, 0.125]) * scale
#convert co-ords to pixels at higher order
pix_fit = pixelfunc.ang2pix(new_nside,
theta + offset_theta,
phi + offset_phi,
nest=True)
#get neighbouring pixels and remove duplicates
moc_tile = MOC()
pixels = np.unique(
pixelfunc.get_all_neighbours(new_nside, pix_fit, nest=True))
moc_tile.add(
order + 2,
np.unique(pixelfunc.get_all_neighbours(new_nside, pixels, nest=True)))
return moc_tile
def _make_random_moc(self, order):
m = MOC()
for order_i in range(0, order + 1):
m.add(order_i, sample(range(0, 12 * 4**order_i), 4**order_i))
return m
def test_ascii_large(self):
orig = MOC()
orig.add(29, [
3458700000000000000,
3458700000000000007,
3458700000000000008,
3458700000000000009,
])
out = StringIO()
write_moc_ascii(orig, file=out)
text = out.getvalue()
self.assertEqual(
text, '29/3458700000000000000,'
'3458700000000000007-3458700000000000009')
copy = MOC()
in_ = StringIO(text)
read_moc_ascii(copy, file=in_)
self.assertEqual(copy.order, 29)
self.assertEqual(copy.cells, 4)
self.assertEqual(
copy[29],
frozenset([
3458700000000000000, 3458700000000000007, 3458700000000000008,
3458700000000000009
]))
def test_json_large(self):
orig = MOC()
orig.add(29, [
3458700000000000000,
3458700000000000007,
3458700000000000008,
3458700000000000009,
])
out = BytesIO()
write_moc_json(orig, file=out)
json = out.getvalue()
self.assertEqual(
json, b'{"29":[3458700000000000000,3458700000000000007,'
b'3458700000000000008,3458700000000000009]}')
copy = MOC()
in_ = BytesIO(json)
read_moc_json(copy, file=in_)
self.assertEqual(copy.order, 29)
self.assertEqual(copy.cells, 4)
self.assertEqual(
copy[29],
frozenset([
3458700000000000000, 3458700000000000007, 3458700000000000008,
3458700000000000009
]))
def get_fitting_region(order,pixel):
"""Expand tile by quarter of a pixel for fitting
:param order: the HEALPix resolution level
:param pixel: given HEALPix pixel that needs to be fit
:return: HEALPix pixels that need to be fit
"""
#define old and new order
old_nside=2**order
new_nside=2**(order+2)
#get co-ord of main pixel
theta,phi=pixelfunc.pix2ang(old_nside, pixel, nest=True)
#define offsets such that main pixel is split into four sub pixels
scale=pixelfunc.max_pixrad(old_nside)
offset_theta=np.array([-0.125,0.0,0.125,0.0])*scale
offset_phi=np.array([0.0,-0.125,0.0,0.125])*scale
#convert co-ords to pixels at higher order
pix_fit=pixelfunc.ang2pix(new_nside, theta+offset_theta, phi+offset_phi, nest=True)
#get neighbouring pixels and remove duplicates
moc_tile=MOC()
pixels=np.unique(pixelfunc.get_all_neighbours(new_nside, pix_fit,nest=True))
moc_tile.add(order+2,np.unique(pixelfunc.get_all_neighbours(new_nside, pixels,nest=True)))
return moc_tile
def test_copy(self):
# TODO: check metadata copying
p = MOC(1, (2, 3))
p.add(4, (5, 6))
q = p.copy()
self.assertEqual(q.cells, 4)
self.assertEqual(sorted(q[1]), [2, 3])
self.assertEqual(sorted(q[4]), [5, 6])
def create_MOC_from_cat(ra,dec):
"""Generate MOC from catalogue
:param ra: Right ascension of sources
:param dec: Declination of sources
:return: MOC :rtype: pymoc.MOC
"""
pixels=get_HEALPix_pixels(11,ra,dec)
cat_moc=MOC()
cat_moc.add(11,pixels)
return cat_moc
def test_copy(self):
# TODO: check metadata copying
p = MOC(1, (2, 3))
p.add(4, (5, 6))
q = p.copy()
self.assertEqual(q.cells, 4)
self.assertEqual(sorted(q[1]), [2, 3])
self.assertEqual(sorted(q[4]), [5, 6])
def create_MOC_from_cat(ra, dec):
"""Generate MOC from catalogue
:param ra: Right ascension of sources
:param dec: Declination of sources
:return: MOC :rtype: pymoc.MOC
"""
pixels = get_HEALPix_pixels(11, ra, dec)
cat_moc = MOC()
cat_moc.add(11, pixels)
return cat_moc
def test_clear(self):
p = MOC()
p.add(4, (5, 6))
p.add(0, (11, ))
p.add(1, (42, 43, 44))
self.assertEqual(p.cells, 6)
self.assertEqual(p.normalized, False)
p.clear()
self.assertEqual(p.cells, 0)
self.assertEqual(p.normalized, True)
def test_fits_large_32(self):
orig = MOC()
orig.add(13, [805306367])
hdu = write_moc_fits_hdu(orig)
self.assertIn('J', hdu.header['TFORM1'])
copy = MOC()
read_moc_fits_hdu(copy, hdu)
self.assertEqual(copy.order, 13)
self.assertEqual(copy[13], frozenset([805306367]))
def test_iadd(self):
p = MOC(4, (11, 12))
p.add(5, (100, ))
q = MOC(4, (13, ))
q.add(5, (101, ))
p += q
self.assertEqual(p.cells, 5)
self.assertEqual(sorted(p[4]), [11, 12, 13])
self.assertEqual(sorted(p[5]), [100, 101])
def test_fits_large_64(self):
orig = MOC()
orig.add(29, [3458700000000000000])
hdu = write_moc_fits_hdu(orig)
self.assertIn('K', hdu.header['TFORM1'])
copy = MOC()
read_moc_fits_hdu(copy, hdu)
self.assertEqual(copy.order, 29)
self.assertEqual(copy[29], frozenset([3458700000000000000]))
def test_iadd(self):
p = MOC(4, (11, 12))
p.add(5, (100,))
q = MOC(4, (13,))
q.add(5, (101,))
p += q
self.assertEqual(p.cells, 5)
self.assertEqual(sorted(p[4]), [11, 12, 13])
self.assertEqual(sorted(p[5]), [100, 101])
def test_fits_64(self):
orig = MOC()
orig.add(14, [0])
hdu = write_moc_fits_hdu(orig)
self.assertIn('K', hdu.header['TFORM1'])
copy = MOC()
read_moc_fits_hdu(copy, hdu)
self.assertEqual(copy.order, 14)
self.assertEqual(copy[14], frozenset([0]))
def sources_in_tile(pixel,order,ra,dec):
"""Check which sources are in HEALPix pixel
:param pixel: HEALPix pixel
:param order: order of HEALPix pixel
:param ra: Right Ascension
:param dec: Declination
:return: boolean array expressing whether in MOC or not :rtype:boolean array
"""
moc_pix=MOC()
moc_pix.add(order,pixel)
kept_sources=check_in_moc(ra,dec,moc_pix)
return kept_sources
def test_fits(self):
orig = MOC()
orig.add(10, [5, 6, 7, 8])
orig.add(11, [1000, 1001, 2000])
hdu = write_moc_fits_hdu(orig)
copy = MOC()
read_moc_fits_hdu(copy, hdu)
self.assertEqual(copy.order, 11)
self.assertEqual(copy[10], frozenset([5, 6, 7, 8]))
self.assertEqual(copy[11], frozenset([1000, 1001, 2000]))
def sources_in_tile(pixel, order, ra, dec):
"""Check which sources are in HEALPix pixel
:param pixel: HEALPix pixel
:param order: order of HEALPix pixel
:param ra: Right Ascension
:param dec: Declination
:return: boolean array expressing whether in MOC or not :rtype:boolean array
"""
moc_pix = MOC()
moc_pix.add(order, pixel)
kept_sources = check_in_moc(ra, dec, moc_pix)
return kept_sources
def create_MOC_from_map(good,wcs):
"""Generate MOC from map
:param good: boolean array associated with map
:param wcs: wcs information
:return: MOC :rtype: pymoc.MOC
"""
x_pix,y_pix=np.meshgrid(np.arange(0,wcs._naxis1),np.arange(0,wcs._naxis2))
ra,dec= wcs.wcs_pix2world(x_pix,y_pix,0)
pixels=get_HEALPix_pixels(15,ra[good],dec[good])
map_moc=MOC()
map_moc.add(15,pixels)
return map_moc
def test_included(self):
m = MOC(10, set([0, 1, 2, 3, 4]))
m.add(8, set([0]))
self.assertEqual(m.order, 10)
self.assertEqual(m[8], frozenset([0]))
self.assertEqual(m[9], frozenset())
self.assertEqual(m[10], frozenset([0, 1, 2, 3, 4]))
m.normalize()
self.assertEqual(m.order, 8)
self.assertEqual(m[8], frozenset([0]))
self.assertEqual(m[9], frozenset())
self.assertEqual(m[10], frozenset())
def test_add(self):
p = MOC(4, (11, 12))
p.add(5, (100,))
q = MOC(4, (13,))
q.add(5, (101,))
s = p + q
# Check the original MOCs were not altered.
self.assertEqual(p.cells, 3)
self.assertEqual(q.cells, 2)
# Check the sum is the union of p and q.
self.assertEqual(s.cells, 5)
self.assertEqual(sorted(s[4]), [11, 12, 13])
self.assertEqual(sorted(s[5]), [100, 101])
def test_add(self):
p = MOC(4, (11, 12))
p.add(5, (100, ))
q = MOC(4, (13, ))
q.add(5, (101, ))
s = p + q
# Check the original MOCs were not altered.
self.assertEqual(p.cells, 3)
self.assertEqual(q.cells, 2)
# Check the sum is the union of p and q.
self.assertEqual(s.cells, 5)
self.assertEqual(sorted(s[4]), [11, 12, 13])
self.assertEqual(sorted(s[5]), [100, 101])
def test_contains(self):
m = MOC()
m.add(0, (10, 11))
m.add(1, (36, 37))
m.add(2, (128, 129))
m.add(3, (448, 499))
self.assertEqual(m.contains(0, 10), True)
self.assertEqual(m.contains(0, 11), True)
self.assertEqual(m.contains(0, 0, True), False)
self.assertEqual(m.contains(0, 0, False), False)
self.assertEqual(m.contains(1, 40), True)
self.assertEqual(m.contains(2, 160), True)
self.assertEqual(m.contains(0, 7, True), True)
self.assertEqual(m.contains(0, 7, False), False)
def test_contains(self):
m = MOC()
m.add(0, (10, 11))
m.add(1, (36, 37))
m.add(2, (128, 129))
m.add(3, (448, 499))
self.assertEqual(m.contains(0, 10), True)
self.assertEqual(m.contains(0, 11), True)
self.assertEqual(m.contains(0, 0, True), False)
self.assertEqual(m.contains(0, 0, False), False)
self.assertEqual(m.contains(1, 40), True)
self.assertEqual(m.contains(2, 160), True)
self.assertEqual(m.contains(0, 7, True), True)
self.assertEqual(m.contains(0, 7, False), False)
def test_catalog(self):
catalog = SkyCoord([150.0, 300.0], [-45.0, 45.0],
frame='icrs', unit='deg')
moc = catalog_to_moc(catalog, 0.5, 20)
self.assertIsInstance(moc, MOC)
self.assertEqual(moc.type, 'CATALOG')
expected = MOC()
expected.add(19, [
994284930659, 994284930660, 994284930662, 2579127859609,
2579127859611, 2579127859612])
expected.add(20, [
3977139722630, 3977139722631, 3977139722644, 3977139722646,
3977139722652, 3977139722661, 10316511438426, 10316511438435,
10316511438441, 10316511438443, 10316511438456, 10316511438457])
self.assertEqual(moc, expected)
def _get_moc_from_cell(self, moc_id, _conn=None):
"""
Retrieve a MOC object from the moc_cell database table.
This routine should not generally be used to retrieve a MOC: instead
use get_moc_fits, or search the moc using search_moc_cell. This
method is intended to be used only to optimize update operations
(and for use by the test suite).
"""
moc_object = MOC()
with self._transaction(_conn=_conn) as conn:
for (order, cell) in conn.execute(select([
moc_cell.c.order, moc_cell.c.cell,
]).where(moc_cell.c.moc_id == moc_id)):
moc_object.add(order, (cell,))
return moc_object
def _get_moc_from_cell(self, moc_id, _conn=None):
"""
Retrieve a MOC object from the moc_cell database table.
This routine should not generally be used to retrieve a MOC: instead
use get_moc_fits, or search the moc using search_moc_cell. This
method is intended to be used only to optimize update operations
(and for use by the test suite).
"""
moc_object = MOC()
with self._transaction(_conn=_conn) as conn:
for (order, cell) in conn.execute(
select([
moc_cell.c.order,
moc_cell.c.cell,
]).where(moc_cell.c.moc_id == moc_id)):
moc_object.add(order, (cell, ))
return moc_object
def test_properties(self):
m = MOC(4, (11, 12))
self.assertEqual(m.normalized, False)
self.assertEqual(m.order, 4)
self.assertEqual(m.cells, 2)
self.assertEqual(len(m), 1)
m.add(5, (198, 199))
self.assertEqual(m.normalized, False)
self.assertEqual(m.order, 5)
self.assertEqual(m.cells, 4)
self.assertEqual(len(m), 2)
m.normalize()
self.assertEqual(m.normalized, True)
m.add(6, (1, 2))
self.assertEqual(m.normalized, False)
def test_catalog(self):
catalog = SkyCoord([150.0, 300.0], [-45.0, 45.0],
frame='icrs',
unit='deg')
moc = catalog_to_moc(catalog, 0.5, 20)
self.assertIsInstance(moc, MOC)
self.assertEqual(moc.type, 'CATALOG')
expected = MOC()
expected.add(19, [
994284930659, 994284930660, 994284930662, 2579127859609,
2579127859611, 2579127859612
])
expected.add(20, [
3977139722630, 3977139722631, 3977139722644, 3977139722646,
3977139722652, 3977139722661, 10316511438426, 10316511438435,
10316511438441, 10316511438443, 10316511438456, 10316511438457
])
self.assertEqual(moc, expected)
def test_ascii_large(self):
orig = MOC()
orig.add(29, [
3458700000000000000, 3458700000000000007,
3458700000000000008, 3458700000000000009,
])
out = StringIO()
write_moc_ascii(orig, file=out)
text = out.getvalue()
self.assertEqual(
text, '29/3458700000000000000,'
'3458700000000000007-3458700000000000009')
copy = MOC()
in_ = StringIO(text)
read_moc_ascii(copy, file=in_)
self.assertEqual(copy.order, 29)
self.assertEqual(copy.cells, 4)
self.assertEqual(copy[29], frozenset([
3458700000000000000, 3458700000000000007,
3458700000000000008, 3458700000000000009]))
def test_json_large(self):
orig = MOC()
orig.add(29, [
3458700000000000000, 3458700000000000007,
3458700000000000008, 3458700000000000009,
])
out = BytesIO()
write_moc_json(orig, file=out)
json = out.getvalue()
self.assertEqual(
json, b'{"29":[3458700000000000000,3458700000000000007,'
b'3458700000000000008,3458700000000000009]}')
copy = MOC()
in_ = BytesIO(json)
read_moc_json(copy, file=in_)
self.assertEqual(copy.order, 29)
self.assertEqual(copy.cells, 4)
self.assertEqual(copy[29], frozenset([
3458700000000000000, 3458700000000000007,
3458700000000000008, 3458700000000000009]))
def test_clear(self):
p = MOC()
p.add(4, (5, 6))
p.add(0, (11,))
p.add(1, (42, 43, 44))
self.assertEqual(p.cells, 6)
self.assertEqual(p.normalized, False)
p.clear()
self.assertEqual(p.cells, 0)
self.assertEqual(p.normalized, True)
def test_sub(self):
p = MOC()
p.add(1, (3, 4, 5))
q = MOC()
q.add(0, (0, ))
q.add(1, (5, ))
q.add(2, (19, ))
d = p - q
self.assertEqual(d, MOC(2, (16, 17, 18)))
def test_sub(self):
p = MOC()
p.add(1, (3, 4, 5))
q = MOC()
q.add(0, (0,))
q.add(1, (5,))
q.add(2, (19,))
d = p - q
self.assertEqual(d, MOC(2, (16, 17, 18)))
def test_moc_update(self):
facility_id = self.db.ensure_facility('moc testing facility')
moc = MOC(order=5, cells=(1, 2, 3))
moc_id = self.db.add_moc(facility_id, 'test', 'test', FormatType.PLAIN,
True, moc)
self.assertIsInstance(moc_id, int)
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0),
{5: 'insert'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(7, (1001, 1002, 1003))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'unchanged',
7: 'insert'
})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(5, (11, 12, 13))
moc.remove(7, (1001, 1002, 1003))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'individual',
7: 'delete'
})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(5, (21, 22, 23))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0),
{5: 'individual'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(5, (31, 32, 33))
moc.remove(5, (1, 2, 3, 11, 12, 13))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0),
{5: 'bulk'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
# Check the MOC really ended up as expected.
self.assertEqual(list(moc), [(5, frozenset((21, 22, 23, 31, 32, 33)))])
def test_moc_update(self):
facility_id = self.db.ensure_facility('moc testing facility')
moc = MOC(order=5, cells=(1, 2, 3))
moc_id = self.db.add_moc(facility_id, 'test', 'test', FormatType.PLAIN,
True, moc)
self.assertIsInstance(moc_id, int)
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'insert'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(7, (1001, 1002, 1003))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'unchanged',
7: 'insert'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(5, (11, 12, 13))
moc.remove(7, (1001, 1002, 1003))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'individual',
7: 'delete'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(5, (21, 22, 23))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'individual'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
moc.add(5, (31, 32, 33))
moc.remove(5, (1, 2, 3, 11, 12, 13))
self.assertEqual(self.db.update_moc_cell(moc_id, moc, block_pause=0), {
5: 'bulk'})
self.assertEqual(self.db._get_moc_from_cell(moc_id), moc)
# Check the MOC really ended up as expected.
self.assertEqual(list(moc), [(5, frozenset((21, 22, 23, 31, 32, 33)))])
def test_intersection(self):
p = MOC(4, (10, 11, 12))
q = MOC(4, (9, 11, 13))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(4, (11, )))
p = MOC(0, (0, ))
p.add(1, (4, 5, 6))
q = MOC(0, (1, ))
q.add(1, (1, 2, 3))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(1, (1, 2, 3, 4, 5, 6)))
p = MOC(0, (1, ))
q = MOC(2, (15, 19))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(2, (19, )))
p.add(0, (2, ))
q.add(0, (2, ))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(0, (2, )) + MOC(2, (19, )))
# Test of intersection with 2 levels difference.
# (This test is based on GitHub issue #2.)
p = MOC(4, (1024, ))
q = MOC(6, (16385, ))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(6, (16385, )))
i = q.intersection(p)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(6, (16385, )))
# Test of intersection with values at multiple levels.
p = MOC(1, (1, ))
q = MOC()
q.add(2, (4, 8))
q.add(3, (20, 192))
q.add(4, (96, 256))
expect = MOC()
expect.add(2, (4, ))
expect.add(3, (20, ))
expect.add(4, (96, ))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, expect)
i = q.intersection(p)
self.assertFalse(i.normalized)
self.assertEqual(i, expect)
def test_intersection(self):
p = MOC(4, (10, 11, 12))
q = MOC(4, (9, 11, 13))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(4, (11,)))
p = MOC(0, (0,))
p.add(1, (4, 5, 6))
q = MOC(0, (1,))
q.add(1, (1, 2, 3))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(1, (1, 2, 3, 4, 5, 6)))
p = MOC(0, (1,))
q = MOC(2, (15, 19))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(2, (19,)))
p.add(0, (2,))
q.add(0, (2,))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(0, (2,)) + MOC(2, (19,)))
# Test of intersection with 2 levels difference.
# (This test is based on GitHub issue #2.)
p = MOC(4, (1024,))
q = MOC(6, (16385,))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(6, (16385,)))
i = q.intersection(p)
self.assertFalse(i.normalized)
self.assertEqual(i, MOC(6, (16385,)))
# Test of intersection with values at multiple levels.
p = MOC(1, (1,))
q = MOC()
q.add(2, (4, 8))
q.add(3, (20, 192))
q.add(4, (96, 256))
expect = MOC()
expect.add(2, (4,))
expect.add(3, (20,))
expect.add(4, (96,))
i = p.intersection(q)
self.assertFalse(i.normalized)
self.assertEqual(i, expect)
i = q.intersection(p)
self.assertFalse(i.normalized)
self.assertEqual(i, expect)
