def setup_roi_same_ncrs_in_bins(nside=62,
ncrs=4,
nbins=2,
alpha_max=0.25,
bin_type='area'):
bins = np.arange(nbins + 1).astype(np.float)
if bin_type == 'lin':
alpha_bins = alpha_max * bins / nbins
else:
alpha_bins = 2 * np.arcsin(
np.sqrt(bins / nbins) * np.sin(alpha_max / 2))
npix = hpt.nside2npix(nside)
roipix = 0
angles_pix_to_roi = hpt.angle(nside, roipix, np.arange(npix))
pixel = np.zeros(ncrs, dtype=int)
for a in range(nbins):
iso_map_bin = np.zeros(npix)
mask_bin = (angles_pix_to_roi >= alpha_bins[a]) * (angles_pix_to_roi <
alpha_bins[a + 1])
iso_map_bin[mask_bin] = 1
iso_map_bin /= np.sum(iso_map_bin)
ratio = int(ncrs / nbins)
pixel[ratio * a:ratio * (a + 1)] = np.random.choice(np.arange(npix),
ratio,
p=iso_map_bin)
return pixel
def test_fit_dipole(self):
nside = 32
npix = hpt.nside2npix(nside)
d = [0.3, 0.5, 0.2]
vec = np.transpose(hpt.pix2vec(nside, np.arange(npix)))
signal = np.dot(vec, d)
mono, dipole = hpt.fit_dipole(signal)
self.assertAlmostEqual(mono, 0.)
self.assertAlmostEqual(d[0], dipole[0])
self.assertAlmostEqual(d[1], dipole[1])
self.assertAlmostEqual(d[2], dipole[2])
def test_ring(self):
for lgNside in range(1, 5):
nside = 1 << lgNside
numPix = hpt.nside2npix(nside)
numRings = 4 * nside - 1 # Expected number of rings
for nest in (True, False):
pix = np.arange(numPix)
ring = hpt.pix2ring(nside, pix, nest=nest)
self.assertTrue(pix.shape == ring.shape)
self.assertTrue(len(set(ring)) == numRings)
if not nest:
first = ring[:numPix - 1]
second = ring[1:]
self.assertTrue(
np.logical_or(first == second,
first == second - 1).all())
def test_boundaries(self):
"""Test whether the boundary shapes look sane"""
for lgNside in range(1, 5):
nside = 1 << lgNside
for pix in range(hpt.nside2npix(nside)):
for res in range(1, 50, 7):
num = 4 * res # Expected number of points
for nest in (True, False):
points = hpt.boundaries(nside, pix, res, nest=nest)
self.assertTrue(points.shape == (3, num))
dist = np.linalg.norm(
points[:, :num - 1] -
points[:, 1:]) # distance between points
self.assertTrue((dist != 0).all())
dmin = np.min(dist)
dmax = np.max(dist)
self.assertTrue(dmax / dmin <= 2.0)
def plot_heatmap(crs, opath=None, **kwargs): # pragma: no cover
"""
Function to plot a scatter skymap of the cosmic rays
:param crs: CosmicRaysBase object
:param opath: Output path for the image, default is None
:type opath: str
:param kwargs:
- nside: Healpy resolution of the 'pixel' array in the cosmic ray class
- additional named keywords passed to matplotlib.pcolormesh
:return: figure of the heatmap, colorbar
"""
nside = crs['nside'] if 'nside' in crs.keys() else kwargs.pop('nside', 64)
pixel = crs['pixel']
count = np.bincount(pixel, minlength=hpt.nside2npix(nside))
return skymap.heatmap(count, opath=opath, **kwargs)
def test_07_pix2map(self):
nside = 1
npix = hpt.nside2npix(nside)
# pixel as single integer
ipix = 4
expectation = np.zeros(npix)
expectation[ipix] = 1
self.assertTrue(np.allclose(hpt.pix2map(nside, ipix), expectation))
# pixel as array
ipix = np.array([0, 2, 5, 10, 5])
expectation = np.array([1, 0, 1, 0, 0, 2, 0, 0, 0, 0, 1, 0])
self.assertTrue(np.allclose(hpt.pix2map(nside, ipix), expectation))
# check pixel outside nside
with self.assertRaises(AssertionError):
hpt.pix2map(nside, 12)
def test_08d_rotate_map(self):
# size(rot_axis) = n and size(rot_angle) = 1
nside = 64
npix = hpt.nside2npix(nside)
for i in range(10):
ipix = np.random.randint(npix)
_inmap = np.zeros(npix)
_inmap[ipix] = 1
rot_axis = coord.rand_vec(5)
rot_angle = 4 * np.pi * np.random.random(1) - 2 * np.pi
_rot_map = hpt.rotate_map(_inmap, rot_axis, rot_angle)
# compare with well tested coord rotate function
for j in range(5):
v_hpt = hpt.pix2vec(nside, np.argmax(_rot_map[j]))
v_coord = coord.rotate(hpt.pix2vec(nside, ipix),
rot_axis[:, j], rot_angle)
self.assertTrue(
coord.angle(v_hpt, v_coord) < hpt.max_pixrad(nside))
def test_08a_rotate_map(self):
# size(rot_axis) = 1 and size(rot_angle) = 1
nside = 64
npix = hpt.nside2npix(nside)
for i in range(10):
ipix = np.random.randint(npix)
_inmap = np.zeros(npix)
_inmap[ipix] = 1
rot_axis = np.squeeze(
coord.rand_vec(1)) if i < 5 else coord.rand_vec(1)
rot_angle = 4 * np.pi * np.random.random() - 2 * np.pi
_rot_map = hpt.rotate_map(_inmap, rot_axis, rot_angle)
v_hpt = hpt.pix2vec(nside, np.argmax(_rot_map))
# compare with well tested coord rotate function
v_coord = coord.rotate(hpt.pix2vec(nside, ipix), rot_axis,
rot_angle)
self.assertTrue(
coord.angle(v_hpt, v_coord) < hpt.max_pixrad(nside))
def setup_roi(nside=256,
ncrs=2000,
roi_size=0.25,
energy_spectrum='uniform',
energy_ordering=False,
emin=19):
npix = hpt.nside2npix(nside)
roipix = 0
angles_pix_to_roi = hpt.angle(nside, roipix, np.arange(npix))
iso_map = np.zeros(npix)
iso_map[angles_pix_to_roi < roi_size] = 1
p = np.cumsum(iso_map)
pix = np.sort(p.searchsorted(np.random.rand(ncrs) * p[-1]))
if energy_spectrum == 'auger':
energies = auger.rand_energy_from_auger(ncrs, emin)
elif energy_spectrum == 'uniform':
energies = np.random.uniform(10, 20, ncrs)
if energy_ordering:
energies = np.sort(energies)[::-1]
return pix, energies
import unittest
import os
import numpy as np
from scipy import sparse
from astrotools import gamale, healpytools as hpt
path = os.path.dirname(os.path.realpath(__file__))
nside = 4 # nside resolution of the test toy-lens
npix = hpt.nside2npix(nside)
stat = 10 # statistic (per pixel) of the test toy-lens
lens_bins = np.linspace(17, 20.48, 175)
dlE = (lens_bins[1] - lens_bins[0]) / 2.
test_bins = [100, 150]
class TestLens(unittest.TestCase):
def setUp(self):
self.lens_path = path + '/toy-lens/jf12-regular.cfg'
def test_01_load_and_dimensions(self):
""" Test raw mldat matrices with simple load function"""
old_mcs = None
for bin_t in test_bins:
lenspart_path = path + '/toy-lens/jf12-regular-%d.npz' % bin_t
lp = gamale.load_lens_part(lenspart_path)
# Sparse matrix that maps npix_extragalactic to npix_observed:
self.assertTrue(lp.shape == (npix, npix))
mrs = lp.sum(axis=1).max()
mcs = lp.sum(axis=0).max()
def setUp(self):
self.nside = 64
self.npix = hpt.nside2npix(self.nside)
def test_nside2npix(self):
self.assertEqual(hpt.nside2npix(512), 3145728)
self.assertEqual(hpt.nside2npix(1024), 12582912)
def setUp(self):
self.nside, self.stat, self.nbins = 64, 1000, 180
self.npix = hpt.nside2npix(self.nside)
self.vecs = hpt.rand_vec_in_pix(self.nside,
np.random.choice(self.npix, self.stat))