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 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_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)