def to_pixel(self, Nside=None, Npix=None, dtype=None, out=None): """ :: >>> insh = harmonic_sphere_map(0, 0, 4) >>> insh.to_pixel(8) Pixel sphere map (ring-ordered, Nside=8, Npix=768) Convert a uniform map:: >>> shmap = harmonic_sphere_map([[23], [0, 0], [0, 0, 0]]) >>> pixmap = shmap.to_pixel(8); pixmap Pixel sphere map (ring-ordered, Nside=8, Npix=768) >>> np.allclose(pixmap, 23.0 / np.sqrt(4*np.pi)) True One can convert multiple maps at once:: >>> M = shmap >>> M = np.hstack((M[:,None], M[:,None], M[:,None], M[:,None])) >>> M = np.dstack((M, M)) >>> M = harmonic_sphere_map(M, 0, 2); M (4, 2)-stack of brief complex harmonic sphere maps with l=0..2 (6 coefficients) >>> x = M.to_pixel(4); x (4, 2)-stack of pixel sphere maps (ring-ordered, Nside=4, Npix=192) >>> np.allclose(x, 23.0 / np.sqrt(4*np.pi)) True """ self._check_not_pretending() if self.format is not COMPLEX_BRIEF: return self.to_complex().to_pixel(Nside, Npix, dtype, out) if Nside is None: if Npix is None: raise ValueError("Provide Nside or Npix") Nside = npix2nside(Npix) if Npix is None: Npix = nside2npix(Nside) if dtype is None: dtype = self.dtype dtype = to_real_dtype(dtype) # for now, only double... assert dtype == np.float64 size = self.shape[1:] if out is None: out = np.empty((Npix,) + size, dtype, order='F') # Todo: Optimize -- have lmin in complexpacked2complexmatrix if self.lmin == 0: source = self else: source = np.empty((l_to_lm(self.lmax + 1),) + size, complex_dtype, order='F') source[:l_to_lm(self.lmin)] = 0 source[l_to_lm(self.lmin):] = self for mapidx in np.ndindex(*size): idx = (slice(None),) + mapidx alm_matrix = mapdatautils.alm_complexpacked2complexmatrix(source[idx]) mapdatautils.alm2map(Nside, alm_matrix, out=out[idx]) return _PixelSphereMap(out, pixel_order='ring')
def simulate_pixel_sphere_maps(Nside, size=None, pixel_order='ring', state=np.random): """ Simulates standard normal maps in pixel space. INPUT: - ``Nside`` - Size of maps - size (optional) EXAMPLES:: >>> simulate_pixel_sphere_maps(4) Pixel sphere map (ring-ordered, Nside=4, Npix=192) >>> simulate_pixel_sphere_maps(4, (2,3,4)) (2, 3, 4)-stack of pixel sphere maps (ring-ordered, Nside=4, Npix=192) """ Npix = nside2npix(Nside) if size is None: size = () elif not isinstance(size, tuple): size = (size,) # A bit complicated in order to simulate Fortran-ordered array; # simulate the reverse shape and then transpose the result size = list(size) size.reverse() size = tuple(size) + (Npix,) return _PixelSphereMap(state.standard_normal(size).T, pixel_order=pixel_order)
def change_resolution(self, Nside): """ >>> M = pixel_sphere_map(np.arange(3072)); M Pixel sphere map (ring-ordered, Nside=16, Npix=3072) >>> np.mean(M) 1535.5 >>> P = M.change_resolution(32); P Pixel sphere map (ring-ordered, Nside=32, Npix=12288) >>> np.mean(P) 1535.5 """ if self.Nside == Nside: return self.copy() elif self.pixel_order == 'ring': return self.to_nested().change_resolution(Nside).to_ring() else: assert self.pixel_order == 'nested' size = self.shape[1:] Npix_new = nside2npix(Nside) buf = np.empty((Npix_new,) + size, order='F', dtype=np.double) for mapidx in np.ndindex(*size): idx = (slice(None),) + mapidx healpix.sub_udgrade_nest(self[idx], buf[idx]) return _PixelSphereMap(buf, pixel_order='nested')
if options.PSD == None: parser.error("You must specify the PSD!") if len(args) < 1: parser.error("I need the output file!") # get the name of the output file if options.nproc == 1: outputfilenames = [args[0]] else: outputfilenames = [re.sub('.xml','',args[0]) + ('-%s.xml' % str(i)) for i in range(options.nproc)] outputfiles = [lisaxml.lisaXML(filename,author='M. Vallisneri') for filename in outputfilenames] npixels = healpix.nside2npix(2**options.refine) random.seed(options.seed) PSD = options.PSD * (1.0 + random.uniform(-options.randomizePSD,options.randomizePSD)) whichfile = 0 for i in range(npixels): mysystem = Stochastic.Stochastic(options.sourceName + ' pseudosource #%s' % i) mysystem.EclipticLatitude, mysystem.EclipticLongitude = healpix.pix2ang_ring(2**options.refine,i) mysystem.Polarization = 0 # Check normalization: divide by the number of pixels, or by solid angle / (4 pi)? # The 2 in the denominator is for the two polarizations
def set_properties(self, pixel_order): if pixel_order not in ('ring', 'nested'): raise ValueError('invalid pixel order') self.pixel_order = pixel_order if nside2npix(npix2nside(self.shape[0])) != self.shape[0]: raise ValueError('invalid shape (must be valid Npix)')
def pixel_sphere_map(data, Nside=None, shape=None, pixel_order=None, nested=None, ring=None): """ INPUT: - ``Nside`` - The resolution of the map, given as the :math:`N_{side}` argument. The number of pixels is ``12*Nside**2``. Can be given as None to infer from data. - ``data`` - (default 0) The data. Can be a scalar - ``pixel_order`` - (default 'ring') whether the data should be ring-ordered. Set to 'nested' for the nested scheme. EXAMPLES:: >>> pixel_sphere_map(0, 4) Pixel sphere map (ring-ordered, Nside=4, Npix=192) >>> M = pixel_sphere_map(np.arange(0, 49152)); M Pixel sphere map (ring-ordered, Nside=64, Npix=49152) >>> M.dtype dtype('float64') >>> M[23] 23.0 # Disable this for now >>> M[:,None,None] >>> np.sin(M) + 34 Pixel sphere map (ring-ordered, Nside=64, Npix=49152) >>> M2 = pixel_sphere_map(np.hstack((M[:,None], M[:,None], M[:,None]))); M2 (3,)-stack of pixel sphere maps (ring-ordered, Nside=64, Npix=49152) >>> M3 = pixel_sphere_map(np.dstack((M2[:,:,None], M2[:,:,None], M2[:,:,None]))); M3 (3, 3)-stack of pixel sphere maps (ring-ordered, Nside=64, Npix=49152) >>> pixel_sphere_map(1) Traceback (most recent call last): ... ValueError: Cannot infer Nside from data """ if (ring or nested) and pixel_order: raise ValueError() if nested: pixel_order = 'nested' elif ring or pixel_order is None: pixel_order = 'ring' if Nside not in (None, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192): raise ValueError('Invalid Nside (must be None or power of 2 <= 8192)') if np.isscalar(data): if shape is None: shape = () elif np.isscalar(shape): shape = (shape,) if Nside is None: raise ValueError('Cannot infer Nside from data') Npix = nside2npix(Nside) data = np.ones((Npix,) + shape, dtype=real_dtype, order='F') * float(data) else: if shape is not None: raise ValueError() data = np.asfortranarray(data, dtype=real_dtype) Npix = data.shape[0] if Nside is not None and nside2npix(Nside) != Npix: raise ValueError('Nside given but mismatches data size') return _PixelSphereMap(data, pixel_order=pixel_order)