def test_accept_ma_allows_only_keywords(self): """ Test whether 'smoothing' wrapped with accept_ma works with only keyword arguments. """ ma = np.ones(12 * 16 ** 2) try: hp.smoothing(map_in=ma) except IndexError: self.fail()
def smoothing(m, fwhm, nest=True): full_map = np.ones(npix) full_map[total_mask] = m if fwhm <= 0: return m if nest: smoothed_map = hpf.reorder(hp.smoothing(hpf.reorder(full_map, n2r=True), fwhm=fwhm), r2n=True) else: smoothed_map = hp.smoothing(full_map, fwhm=fwhm) return smoothed_map[total_mask]
def beam(self, feed, freq): # bm = visibility.cylinder_beam(self._angpos, self.zenith, # self.cylinder_width / self.wavelengths[freq]) # sigma = np.radians(self.fwhm) / (8.0*np.log(2.0))**0.5 / (self.frequencies[freq] / 150.0) # pointing = np.array([np.pi / 2.0 - np.radians(self.pointing), self.zenith[1]]) # x2 = (1.0 - coord.sph_dot(self._angpos, pointing)**2) / (4*sigma**2) # self._bc_map = np.exp(-x2) # self._bc_freq = freq # self._bc_nside = self._nside uhatc, vhatc = visibility.uv_plane_cart(self.zenith) ## Note sinc function is normalised hence lack of pi bmh = np.sinc(np.inner(coord.sph_to_cart(self._angpos), self.cylinder_width * uhatc / self.wavelengths[freq])) bmv = np.where( np.abs(np.inner(coord.sph_to_cart(self._angpos), vhatc)) * 180.0 / np.pi < self.vwidth / 2.0, np.ones_like(bmh), np.zeros_like(bmh), ) bmv = healpy.smoothing(bmv, degree=True, fwhm=(self.vwidth / 10.0)) return bmv * bmh
def direct(self, input, output): if input.ndim > 1: input = [_ for _ in input.T] output.T[...] = hp.smoothing( input, fwhm=self.fwhm, iter=self.iter, lmax=self.lmax, mmax=self.mmax, use_weights=self.use_weights, datapath=self.datapath, pol=self.pol, verbose=False)
def surv_sum_diff(surveydict,ss=1,nside=128,freq=70,mask_ps=True,fwhm=10.0): """ function to genreate smoothed difference between chosen survey and sum of the other 5 surveys from andreas interactive destriper/binner. uses common masks smooth to 10 degrees fwhm is in degrees, if zero or negative don't smooth at all, default 10 degrees """ sumlist=surveydict.keys() sumlist.remove(ss) nsum=len(sumlist) m=hp.ma(np.array(surveydict[sumlist[0]]))/nsum totalmask=m.mask if mask_ps==True: psmask = np.logical_not(np.floor(hp.ud_grade(hp.read_map(glob('/project/projectdirs/planck/data/mission/DPC_maps/dx8/lfi/DX8_MASKs/' + 'mask_ps_%dGHz_*.fits' % freq)[0]), nside,order_out='NEST'))) totalmask=m.mask | psmask for ss in sumlist[1:]: m1=hp.ma(np.array(surveydict[ss])) m=m+m1/nsum totalmask=m1.mask | totalmask m.mask=totalmask m.mask |= np.isnan(m) m1=hp.ma(np.array(surveydict[ss])) totalmask=totalmask | m1.mask d=(m1-m)/2. d=hp.ud_grade(d,nside,order_in='NEST',order_out='RING') if fwhm>0: dsm=hp.ma(hp.smoothing(d.filled(),fwhm*np.pi/180.)) dsm.mask=m.mask if fwhm<=0: dsm=d hp.mollview(dsm,min=-1e-5,max=1e-5,title='SS'+np.str(ss)+ ' - sum of others') return dsm
def smoother(self, map_array): """Function to smooth an array of N (T, Q, U) maps with N beams in units of arcmin. :param map_array: :type map_array: """ if not self.Use_Smoothing: return map_array elif self.Use_Smoothing: if self.pixel_indices is None: full_map = map_array else: full_map = build_full_map(self.pixel_indices, map_array, self.Nside) smoothed_map_array = np.array([hp.smoothing(m, fwhm = np.pi / 180. * b / 60., verbose = False) for (m, b) in zip(full_map, self.Beams)]) if self.pixel_indices is None: return smoothed_map_array else: assert smoothed_map_array.ndim == 3, \ "Assuming map array is 3 dimensional (n_freqs x n_maps x n_pixels)" return smoothed_map_array[..., self.pixel_indices] else: print("Please set 'Use_Smoothing' in Instrument object.") sys.exit(1)
def test_smooth(self): op = LibSharpSmooth(comm=self.comm, signal_map="signal_map", lmax=self.lmax, grid=self.dist_rings.libsharp_grid, fwhm_deg=self.fwhm_deg, beam=None) op.exec(self.data) # Copy our local piece into a buffer of zeros that we will # reduce to the root process. We could also use a gather, but # this is a small buffer. local_output_map = np.zeros(self.input_map.shape, dtype=np.float64) local_output_map[:, self.dist_rings.local_pixels] = \ self.data["smoothed_signal_map"] output_map = None if self.comm.rank == 0: output_map = np.zeros(self.input_map.shape, dtype=np.float64) self.comm.Reduce(local_output_map, output_map, root=0, op=MPI.SUM) if self.comm.rank == 0: hp_smoothed = hp.smoothing(self.input_map, fwhm=np.radians(self.fwhm_deg), lmax=self.lmax) np.testing.assert_array_almost_equal(hp_smoothed, output_map, decimal=2) print("Std of difference between libsharp and healpy", (hp_smoothed-output_map).std()) return
def _load_data(self): print "Loading data for galaxy simulation." _haslam_file = join(_datadir, "haslam.fits") _sp_ind_file = join(_datadir, "spectral.hdf5") if not exists(_haslam_file): print "Needed data files missing! Try and fetch the Haslam map from LAMBDA [y/n]?" choice = raw_input().lower() if choice == "y": import urllib _haslam_url = "http://lambda.gsfc.nasa.gov/data/foregrounds/haslam/lambda_haslam408_dsds.fits" print "Downloading %s ...." % _haslam_url urllib.urlretrieve(_haslam_url, _haslam_file) print "Done." elif choice == "n": raise Exception("No Haslam map found. Can not continue.") else: print "Please respond with 'y' or 'n'." self._haslam = healpy.read_map(join(_datadir, "haslam.fits")) self._sp_ind = h5py.File(_sp_ind_file)["spectral_index"][:] # Upgrade the map resolution to the same as the Healpix map (nside=512). self._sp_ind = healpy.smoothing(healpy.ud_grade(self._sp_ind, 512), degree=True, sigma=1.0)
def smooth_variance_map(var_m, fwhm): """Smooth a variance map Algorithm from 'Pixel errors in convolved maps' J.P. Leahy, version 0.2 Parameters ---------- var_m : array input variance map fwhm : float (radians) target fwhm Returns ------- smoothed_var_m : array smoothed variance map """ # smooth map fwhm_variance = fwhm / np.sqrt(2) smoothed_var_m = hp.smoothing(var_m, fwhm=fwhm_variance, regression=False) # normalization factor pix_area = hp.nside2pixarea(hp.npix2nside(len(var_m))) orig_beam_width = fwhm/np.sqrt(8*np.log(2)) A_vb = pix_area / (4. * np.pi * orig_beam_width**2) smoothed_var_m *= A_vb return smoothed_var_m
def timemaps(maps,fwhm_degrees, eortime): timemaps=[] for index in range(len(eortime)): testmap = galmap2eqmap(maps) testmap = eqmap2azelmap(testmap,ut=eortime[index]) testmap = replace_with_earth(testmap) timemaps.append(hp.smoothing(testmap,np.radians(fwhm_degrees),regression=False )) return testmap
def mask_from_map(nmap, fwhm_deg=3.0, final_fwhm_deg=5.0, thresh_min=0.9, thresh_max=3.0, lat_gal_cut=20., ecl_pole_rad=5., coord='G'): import healpy as hp mask = np.ones_like(nmap) # mask out low galactic latitudes npix = len(nmap) nside = hp.npix2nside(npix) ipix = np.arange(npix) theta_c, phi_c = hp.pix2ang(nside, ipix, nest=False) r = hp.Rotator(coord=[coord,'G']) # transforms to galactic theta_gal, phi_gal = r(theta_c, phi_c) lat_gal_deg = (np.pi/2.-theta_gal)*180./np.pi wh_gal = np.where(np.abs(lat_gal_deg)<lat_gal_cut)[0] mask[wh_gal]=0. # mask out the ecliptic poles # actually, isn't the coverage *better* at the poles?? r = hp.Rotator(coord=[coord,'E']) # transforms to ecliptic theta_ecl, phi_ecl = r(theta_c, phi_c) lat_ecl_deg = (np.pi/2.-theta_ecl)*180./np.pi wh_ecl_pole = np.where(np.abs(np.abs(lat_ecl_deg)-90.)<ecl_pole_rad)[0] mask[wh_ecl_pole]=0. # mask out Magellanic clouds. # tmpp # mask according to <nmap>, which is a proxy for coverage. sm = hp.smoothing(nmap*mask, fwhm=fwhm_deg*np.pi/180.) wh=np.where((sm<(thresh_min*np.median(sm))))[0] mask[wh]=0. wh=np.where((sm>(thresh_max*np.median(sm))))[0] mask[wh]=0. # apply a final smoothing/threshold/smoothing mask = hp.smoothing(mask, fwhm=final_fwhm_deg*np.pi/180.) #hp.mollview(mask);ipdb.set_trace() mask = hp.smoothing(mask>0.95, fwhm=0.5*final_fwhm_deg*np.pi/180.) if False: hp.mollview(mask*nmap) pdb.set_trace() return mask
def test_smoothing_masked(self): smoothed = hp.smoothing(self.map1, fwhm=np.radians(10), lmax=self.lmax, regression=False) smoothed_f90 = hp.ma(hp.read_map(os.path.join(self.path, 'data', 'wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits'), (0,1,2))) # fortran does not restore the mask for mm in smoothed_f90: mm.mask = smoothed[0].mask for i in range(3): np.testing.assert_array_almost_equal(smoothed[i].filled(), smoothed_f90[i].filled(), decimal=6)
def make_healpix_image(events, nside, sigma): theta = np.deg2rad(90 - events['B']) phi = np.deg2rad(events['L']) bins = np.arange(hp.nside2npix(nside) + 1) - 0.5 data = hp.ang2pix(nside, theta, phi) counts, _ = np.histogram(data, bins) counts = hp.smoothing(counts, sigma=sigma) return counts
def skypatch(phi, theta, radius, skyres=2.): import healpy baseres = (skyres / 4.) * np.pi/180. # require this resolution from healpix grid nside = 2**int(min(10, np.ceil(np.log2(healpy.nside2resol(1) / baseres)))) # don't go past 2**10 (12.6 million pixels) npix = healpy.nside2npix(nside) p = healpy.ang2pix(nside, theta, phi) n = np.zeros(npix) n[p] = 1. # put all probability at (p, t) m = healpy.smoothing(n, sigma=radius) # smooth out Gaussian return m
def getsky(self, debug=False, celestial=True): # Read in data files. haslam = healpy.smoothing( healpy.ud_grade(self._haslam, self.nside), degree=True, fwhm=3.0 ) # hputil.coord_g2c() beam = 1.0 syn = FullSkySynchrotron() lmax = 3 * self.nside - 1 efreq = np.concatenate((np.array([408.0, 1420.0]), self.nu_pixels)) cla = skysim.clarray(syn.angular_powerspectrum, lmax, efreq) fg = skysim.mkfullsky(cla, self.nside) sub408 = healpy.smoothing(fg[0], fwhm=3.0, degree=True) sub1420 = healpy.smoothing(fg[1], fwhm=5.8, degree=True) fgs = skysim.mkconstrained(cla, [(0, sub408), (1, sub1420)], self.nside) sc = healpy.ud_grade(self._sp_ind, self.nside) am = healpy.ud_grade(self._amp_map, self.nside) mv = healpy.smoothing( map_variance(healpy.smoothing(fg[0], sigma=0.5, degree=True), 16) ** 0.5, degree=True, sigma=1.0 ).mean() fgt = (am / mv) * (fg - fgs) fg2 = (haslam[np.newaxis, :] * ((efreq / 408.0)[:, np.newaxis] ** sc) + fgt)[2:] if celestial: for i in range(fg2.shape[0]): fg2[i] = hputil.coord_g2c(fg2[i]) if debug: return fg2, fg, fgs, fgt return fg2
def smooth_and_combine_maps(maps_and_weights, output_file_name, reader_function, stokes_components=(0, 1, 2), smoothing_angle=2.0, degraded_nside=32): '''Combine a set of FITS maps into another. The maps are specified by `maps_and_weights', a list of tuples of the form (PATH, WEIGHT), where PATH is a string containing the path of the FITS file, and ''' combined_map = [] for map_file_name, weight in maps_and_weights: log.info("Reading map %s (weight %f)", map_file_name, weight) pixels = reader_function(map_file_name) if len(combined_map) == 0: combined_map = [x * weight for x in pixels] else: for idx in xrange(len(pixels)): combined_map[idx] = combined_map[idx] + weight * pixels[idx] # Maps with NSIDE=1024 are large, so it's better to free memory we # are not going to use any longer del pixels component_name = {0: 'I', 1: 'Q', 2: 'U'} smoothed_map = [] if smoothing_angle > 0.0: log.info('Applying smoothing filter to %d Stokes maps', len(combined_map)) sm_angle = np.deg2rad(smoothing_angle) for idx, diff_component in enumerate(combined_map): nan_mask = np.isnan(diff_component) diff_component[nan_mask] = 0.0 log.info('Applying a smoothing filter to %s map...', component_name[stokes_components[idx]]) smoothed_component = hp.smoothing(diff_component, sm_angle) smoothed_component[nan_mask] = np.NaN smoothed_map.append(smoothed_component) else: smoothed_map = combined_map if degraded_nside > 0: log.info('Degrading the map to NSIDE = %d', degraded_nside) degraded_map = hp.ud_grade(smoothed_map, degraded_nside) log.info('Saving the map into %s', output_file_name) hp.write_map(output_file_name, degraded_map)
def test_smoothing_notmasked(self): smoothed = hp.smoothing( [m.data for m in self.map1], fwhm=np.radians(10), lmax=self.lmax ) smoothed_f90 = hp.read_map( os.path.join( self.path, "data", "wmap_band_iqumap_r9_7yr_W_v4_udgraded32_smoothed10deg_fortran.fits", ), (0, 1, 2), ) np.testing.assert_array_almost_equal(smoothed, smoothed_f90, decimal=6)
def mk_map_onescale(nside,lmin=0,alpha=-2.17,smooth=1.): """ One power law model -> random field realization """ lmax = 3*nside - 1 ll = np.array(range(lmin,lmax,1)) Cl = np.power(ll,alpha) Cl[0] = 0. #zero mean Q = hp.synfast(Cl,nside,lmax=lmax) Qsm = hp.smoothing(Q,fwhm=np.radians(smooth)) return Qsm
def skyhist(posteriorsamples='posterior_samples.dat', skyres=2.): import healpy if type(posteriorsamples) is str: posteriorsamples = loadposteriorsamples(posteriorsamples) baseres = (skyres / 4.) * np.pi/180. # require this resolution from healpix grid nside = 2**int(min(10, np.ceil(np.log2(healpy.nside2resol(1) / baseres)))) # don't go past 2**10 (12.6 million pixels) npix = healpy.nside2npix(nside) p = healpy.ang2pix(nside, posteriorsamples[:,2], posteriorsamples[:,1]) # convert (theta, phi) to healpix numbers # n = np.bincount(p, minlength=npix) # bin the samples n = np.zeros(npix) n[:max(p)+1] = np.bincount(p) # support old version of numpy that does not have minlength argument m = healpy.smoothing(n, sigma=skyres*np.pi/180.) # smoothed map return m
def test_healpix_convolution(): nside = 16 keywords = {'fwhm': np.radians(30), 'iter': 2, 'lmax': 8, 'use_weights': False} input = np.arange(12 * nside**2) op = HealpixConvolutionGaussianOperator(**keywords) for i in input, np.repeat(input[:, None], 3, 1): expected = np.transpose(hp.smoothing(i.T, verbose=False, **keywords)) assert_same(op(i), expected) if hp.__version__ <= '1.8.6': # healpy #259 return op = HealpixConvolutionGaussianOperator(pol=False, **keywords) input_ = np.arange(12 * nside**2) input = np.array([input_, input_, input_]).T expected_ = hp.smoothing(input_, verbose=False, **keywords) expected = np.array([expected_, expected_, expected_]).T assert_same(op(input), expected)
def smooth(self, fwhm, lmax=None, pol_only=False): """Smooth the map with a Gaussian kernel. """ if self.rank == 0: if pol_only: print("Smoothing the polarization to {} arcmin".format(fwhm), flush=True) else: print("Smoothing the map to {} arcmin".format(fwhm), flush=True) if lmax is None: lmax = min(np.int(fwhm / 60 * 512), 2 * self.nside) # If the map is in node-shared memory, only the root process on each # node does the smoothing. if not self.shmem or self._map.nodecomm.rank == 0: if self.pol: m = np.vstack([self._map[:], self._map_Q[:], self._map_U[:]]) else: m = self._map[:] if self.nest: m = hp.reorder(m, n2r=True) smap = hp.smoothing(m, fwhm=fwhm * arcmin, lmax=lmax, verbose=False) del m if self.nest: smap = hp.reorder(smap, r2n=True) else: # Convenience dummy variable smap = np.zeros([3, 12]) if not pol_only: if self.shmem: self._map.set(smap[0].astype(DTYPE), (0, ), fromrank=0) else: self._map[:] = smap[0] if self.pol: if self.shmem: self._map_Q.set(smap[1].astype(DTYPE), (0, ), fromrank=0) self._map_U.set(smap[2].astype(DTYPE), (0, ), fromrank=0) else: self._map_Q[:] = smap[1] self._map_U[:] = smap[2] self.pol_fwhm = fwhm return
def process_healpix(filename, out_nside): print 'Process {0} on {1}'.format(MP.current_process().name, filename) pixval = HP.read_map(filename, verbose=False) nside = HP.npix2nside(pixval.size) out_pixres = HP.nside2resol(out_nside) print 'Before: ', pixval.min(), pixval.max(), NP.mean(pixval), NP.std(pixval) if nside > out_nside: if nside/out_nside > 4: pixval = HP.ud_grade(pixval, 4*out_nside) nside = 4*out_nside pix_smoothed = HP.smoothing(pixval, fwhm=out_pixres, regression=False, verbose=False) pix_resampled = HP.ud_grade(pix_smoothed, out_nside) print 'After: ', pixval.min(), pixval.max(), NP.mean(pix_resampled), NP.std(pix_resampled) return pix_resampled
def test_smoothing_notmasked(self): smoothed = hp.smoothing([m.data for m in self.map1], fwhm=np.radians(10), lmax=self.lmax) smoothed_f90 = hp.read_map( os.path.join( self.path, "data", "wmap_band_iqumap_r9_7yr_W_v4_udgraded32_smoothed10deg_fortran.fits", ), (0, 1, 2), np.float64, ) np.testing.assert_array_almost_equal(smoothed, smoothed_f90, decimal=6)
def smooth(params): inf, opf, fwhm, nside = params print('input = {:s}; output = {:s}; fwhm = {:.5f} deg' .format(inf, opf, fwhm)) m = hp.read_map(inf, verbose=False) m -= m.mean() m_smooth = hp.smoothing(m, fwhm=fwhm*np.pi/180) if nside_out is not None: m_out = hp.ud_grade(m_smooth, nside, order_in='RING', order_out='RING', dtype=np.float64) else: m_out = m_smooth hp.write_map(opf, m_out, fits_IDL=False, coord='C', dtype=np.float64)
def apodize_mask(mask, sigma_arcmin=12., lmax=None, method='hybrid', cache_dir='caches/', mult_factor=3, min_factor=0.1): """Apodize a mask so it can safely be used for Pseudo-CL inversion. Args: mask: input healpix map array sigma_arcmin: characteritic width of smoothing lmax: lmax when apodizing mask method: gaussian or hybrid (hybrid mainly smooths outside existing mask, so reduces fsky) cache_dir: if not None, cache result here if possible mult_factor: for hybrid method, multiply (1-mask) by this factor and truncate (enlarges mask, before resmoothing) min_factor: for hybrid method, set to unity tails larger than 1-min_factor after scaling by mult_factor Returns: the apodized map array """ if not sigma_arcmin: return mask sigma_rad = sigma_arcmin / 180. / 60. * np.pi if cache_dir: name = os.path.join(cache_dir, 'ap_mask_' + '_'.join( '%s' % s for s in [sigma_arcmin, method, lmax, mult_factor, min_factor, hashlib.sha1(mask).hexdigest()])) + '.fits' if cache_dir and os.path.exists(name): ap_mask = hp.read_map(name) else: print('apodizing... (fsky_unapodized=%s)' % (np.sum(mask ** 2) / mask.size)) ap_mask = hp.smoothing(mask, sigma=sigma_rad, lmax=lmax) print('Min/max mask smoothed mask', np.min(ap_mask), np.max(ap_mask)) print('fsky=', np.sum(ap_mask ** 2) / ap_mask.size) if method == 'gaussian': return ap_mask if method != 'hybrid': raise ValueError('Unknown apodization method') ap_mask = 1 - np.minimum(1., np.maximum(0., mult_factor * (1 - ap_mask) - min_factor)) ap_mask = hp.smoothing(ap_mask, sigma=sigma_rad / 2, lmax=lmax) print('Min/max mask re-smoothed mask', np.min(ap_mask), np.max(ap_mask)) print('fsky=', np.sum(ap_mask ** 2) / ap_mask.size) if cache_dir: hp.write_map(name, ap_mask) return ap_mask
def load_map(fn_in, fn_out, nside, fwhm, lmax): if os.path.isfile(fn_out): print('Reading', fn_out, flush=True) m = hp.read_map(fn_out, None, verbose=False) else: if not os.path.isfile(fn_in): print('File not found:', fn_in) return None print('Reading', fn_in, flush=True) m = hp.read_map(fn_in, None, nest=True, verbose=False) m = hp.ud_grade(m, nside, order_in='nest', order_out='ring') m = hp.smoothing(m, fwhm=fwhm, lmax=lmax, iter=0, verbose=False) print('Writing', fn_out) write_map(fn_out, m) return m
def test_smoothing_masked(self): smoothed = hp.smoothing(self.map1, fwhm=np.radians(10), lmax=self.lmax) smoothed_f90 = hp.ma( hp.read_map( os.path.join( self.path, 'data', 'wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits' ), (0, 1, 2))) # fortran does not restore the mask for mm in smoothed_f90: mm.mask = smoothed[0].mask for i in range(3): np.testing.assert_array_almost_equal(smoothed[i].filled(), smoothed_f90[i].filled(), decimal=6)
def changeResolution(map, fwhmCurrent, fwhmNew): """ Given a HEALPix map with full width at half max resolution 'fwhmCurrent' degrees, smooth it to a new FWHM of 'fwhmNew' degrees. """ if fwhmNew <= fwhmCurrent: return map else: smth = np.sqrt(fwhmNew ** 2 - fwhmCurrent ** 2) # smth /= 2*np.sqrt(2*np.log(2)) if getattr(map, 'mask', None) is not None: data = map.data * 1.0 data[np.where(map.mask == 1)] = 0 map2 = hp.smoothing(data, fwhm=smth, degree=True) mask2 = hp.smoothing(map.mask.astype(np.float64), fwhm=smth, degree=True) map2 = hp.ma(map2) map2.mask = np.where(mask2 >= 0.005, 1, 0).astype(np.bool) else: map2 = hp.smoothing(map, fwhm=smth, degree=True) return map2
def smooth(self, fwhm, lmax=None, pol_only=False): """ Smooth the map with a Gaussian kernel. """ autotimer = timing.auto_timer(type(self).__name__) if self.rank == 0: if pol_only: print('Smoothing the polarization to {} arcmin'.format(fwhm), flush=True) else: print('Smoothing the map to {} arcmin'.format(fwhm), flush=True) if lmax is None: lmax = min(np.int(fwhm / 60 * 512), 2 * self.nside) # If the map is in node-shared memory, only the root process on each # node does the smoothing. if not self.shmem or self._map.nodecomm.rank == 0: if self.pol: m = np.vstack([self._map[:], self._map_Q[:], self._map_U[:]]) else: m = self._map[:] if self.nest: m = hp.reorder(m, n2r=True) smap = hp.smoothing(m, fwhm=fwhm * arcmin, lmax=lmax, verbose=False) del m if self.nest: smap = hp.reorder(smap, r2n=True) else: # Convenience dummy variable smap = np.zeros([3, 12]) if not pol_only: if self.shmem: self._map.set(smap[0].astype(DTYPE), (0,), fromrank=0) else: self._map[:] = smap[0] if self.pol: if self.shmem: self._map_Q.set(smap[1].astype(DTYPE), (0,), fromrank=0) self._map_U.set(smap[2].astype(DTYPE), (0,), fromrank=0) else: self._map_Q[:] = smap[1] self._map_U[:] = smap[2] self.pol_fwhm = fwhm del autotimer return
def load_map(fn_in, fn_out, nside, fwhm, lmax): if os.path.isfile(fn_out): print('Loading', fn_out) m = hp.read_map(fn_out, None, verbose=False) else: print('Reading', fn_in) m = hp.read_map(fn_in, None, nest=True, verbose=False) m = hp.ud_grade(m, nside, order_in='nest', order_out='ring') m = hp.smoothing(m, fwhm=fwhm, lmax=lmax, iter=0, verbose=False) print('Writing', fn_out) hp.write_map(fn_out, m, coord='g') return m
def apply_window(parameters,ar,window_badval,window_unseen,smoothing_radius): window = sp.ones_like(ar) if window_badval: window[ar == parameters.badval] = 0 if window_unseen: window[ar == parameters.unseen] = 0 window = hp.smoothing(window,fwhm=smoothing_radius,verbose=False) ar_windowed = window*ar return ar_windowed, window
def update_mask(self,rand_sigma_arcmin=2.,rand_threshold=1e-3): if rand_sigma_arcmin>1.e-3: if self.verbose: print( "Smoothing...") if self.curved: smap = hp.smoothing(self.rand_map,sigma=rand_sigma_arcmin*np.pi/180./60.) else: smap = enmap.smooth_gauss(self.rand_map,rand_sigma_arcmin*np.pi/180./60.) if self.verbose: print( "Done smoothing...") else: if self.verbose: smap = self.rand_map self.mask = np.zeros(self.shape) self.mask[smap>rand_threshold] = 1 if not self.curved: self.mask = enmap.enmap(self.mask,self.wcs) self._counts()
def test_smoothing_masked(self): smoothed = hp.smoothing(self.map1, fwhm=np.radians(10), lmax=self.lmax) smoothed_f90 = hp.ma( hp.read_map( os.path.join( self.path, "data", "wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits", ), (0, 1, 2), )) # fortran does not restore the mask smoothed_f90.mask = smoothed.mask np.testing.assert_array_almost_equal(smoothed.filled(), smoothed_f90.filled(), decimal=6)
def run(self): print 'Starting Thread-%s' % self.threadID self.smoothed_map = hp.smoothing(self.input_map, fwhm=np.radians(self.smooth_fwhm)) self.smoothed_degraded_map = hp.ud_grade(self.smoothed_map, nside_out=self.nside_out, order_in='RING', pess=True) self.write_smoothed_map('Smoothed_' + setup.frequencies[self.threadID] + 'GHz' + '.fits') self.write_smoothed_and_degraded_map('Smoothed_' + setup.frequencies[self.threadID] + 'GHz_' + str(self.nside_out) + 'N' + '.fits') print 'Thread-%s Finished' % self.threadID
def integrate_surface_flux(flux_map, r, smooth=False, ret_map=False, **smooth_kwargs): ''' Integrates a healpix surface flux to compute the total net flux out of the sphere. r is the radius of the sphere in meters ''' import healpy as hp from scipy.integrate import trapz from seren3.array import SimArray raise Exception("Function deprecated") if not ((isinstance(flux_map, SimArray) or isinstance(r, SimArray))): raise Exception("Must pass SimArrays") # Compute theta/phi npix = len(flux_map) nside = hp.npix2nside(npix) # theta, phi = hp.pix2ang(nside, range(npix)) theta, phi = hp.pix2ang(nside, range(npix)) r = r.in_units("m") # make sure r is in meters # Smoothing? if smooth: flux_map = hp.smoothing(flux_map, **smooth_kwargs) # Compute the integral integrand = np.zeros(len(theta)) for i in range(len(theta)): th, ph = (theta[i], phi[i]) unit_r = unit_vec_r(th, ph) integrand[i] = r**2 * np.sin(th)\ * np.dot(flux_map[i], unit_r)\ * heaviside(np.dot(flux_map[i], unit_r)) integrand = integrand[:, None] + np.zeros( len(phi)) # 2D over theta and phi I = trapz(trapz(integrand, phi), theta) return SimArray(I, "s**-1")
def test_smoothing_masked(self): smoothed = hp.smoothing(self.map1, fwhm=np.radians(10), lmax=self.lmax) smoothed_f90 = hp.ma( hp.read_map( os.path.join( self.path, "data", "wmap_band_iqumap_r9_7yr_W_v4_udgraded32_masked_smoothed10deg_fortran.fits", ), (0, 1, 2), ) ) # fortran does not restore the mask smoothed_f90.mask = smoothed.mask np.testing.assert_array_almost_equal( smoothed.filled(), smoothed_f90.filled(), decimal=6 )
def test_k2g2k_rand(): """Test that transformation of k->g->k recovers the input convergence map.""" nside = 16 npix = hp.nside2npix(nside) lmax = 32 k = np.random.standard_normal(npix) k = hp.smoothing(k, lmax=lmax, verbose=False) k = hp.remove_monopole(k) k = hp.remove_dipole(k) g1, g2 = transformations.conv2shear(k, lmax) k_recov = transformations.shear2conv(g1, g2, lmax) np.testing.assert_almost_equal(k, k_recov, decimal=3)
def smoother(self, map_array): """Function to smooth an array of N (T, Q, U) maps with N beams in units of arcmin. :param map_array: :type map_array: """ if not self.Use_Smoothing: return map_array elif self.Use_Smoothing: return np.array([ hp.smoothing(m, fwhm=np.pi / 180. * b / 60., verbose=False) for (m, b) in zip(map_array, self.Beams) ]) else: print("Please set 'Use_Smoothing' in Instrument object.") sys.exit(1)
def smooth(hpxmap, badval=hp.UNSEEN, sigma=None): """ Smooth a healpix map Parameters ---------- hpxmap : full healpix map badval : bad value for masking sigma : smoothing kernel (deg) Returns ------- smooth : smoothed map """ check_hpxmap(hpxmap, None, None) hpxmap = masked_array(hpxmap, badval) hpxmap.fill_value = np.ma.median(hpxmap) smooth = hp.smoothing(hpxmap, sigma=np.radians(sigma), verbose=False) return np.ma.array(smooth, mask=hpxmap.mask)
def get_sdss_mask(sample='LOWZ', nside=512, fwhm1=5.0, fwhm2=5.0, quick=True): # FWHM1 and FWHM2 are in degrees. savename = datadir+'sdss_mask_'+sample+'_%i_%i.pkl'%(fwhm1,fwhm2) if quick: return pickle.load(open(savename,'r')) nmap = np.zeros(hp.nside2npix(nside)) for ind in ['1','2']: for reg in ['North','South']: filename = datadir+'random'+ind+'_DR10v8_'+sample+'_'+reg+'.fits' data = fits.open(filename)[1].data nmap += ra_dec_to_hpix(data.RA, data.DEC, nside=nside) mask = nmap>0 mask = hp.smoothing(mask, fwhm=fwhm1*np.pi/180., verbose=False) mask = mask>0.05 mask = hp.sphtfunc.smoothing(mask, fwhm=fwhm2*np.pi/180., verbose=False) mask -= mask.min() mask /= mask.max() pickle.dump(mask, open(savename,'w')) return mask
def deconv(maps, beam_in, beam_out, lmax): ''' Beam in unit of arc-miniute. This function changes the value of the input map itself. ''' _maps = np.copy(maps) for j in range(1, 3): ### only for Q\U; _maps[j] = hp.sphtfunc.decovlving(_maps[j], fwhm=beam_in / 60 / 180 * np.pi, lmax=lmax, verbose=False) _maps[j] = hp.smoothing(_maps[j], fwhm=beam_out / 60 / 180 * np.pi, lmax=lmax, verbose=False) return _maps
def ilc_map_from_weights(maps, weights, regions_map=None, sigma=1.5 * np.pi / 180, return_weights_map=False): """ Construct an ILC map from a set of raw temperature maps, a set of weights per region, and a map of regions. `maps` must have shape (Nfreq, Npix). `weights` must have shape (Nregions, Nfreq). `regions_map` must have shape (Npix,) and each pixel should contain the integer identifier to which region the pixel is assigned. If `regions_map` is None, simply performs the linear combination of the maps according to the weights. #TODO NEEDS TO BE IMPLEMENTED `sigma` is the smoothing factor to reduce edge effects. It is applied to each region's weight map before multiplying into the raw maps. See Bennett 2003 or Hinshaw 2007 for details. `sigma` is the kernel radius (standard deviation) in radians. If `return_weights_map` is True, then also returns the summed weight map as a diagnostic tool. All of the maps must be in RING format! """ Thats = np.dot(weights, maps) That = np.zeros(Thats.shape[1]) weights_map = np.zeros(Thats.shape[1]) for i in range(len(Thats)): m = np.zeros_like(That) m[regions_map == i] = 1 if sigma is not None: # hp.smoothing does not preserve the mean, so add it back in mbar = m.mean() m = hp.smoothing(m, sigma=sigma, verbose=False) + mbar That += Thats[i] * m weights_map += m That = That / weights_map if return_weights_map: return That, weights_map else: return That
def hpmollview(map1, unit, figax, smooth=False, cmap=plt.cm.bwr, galaxy=False, **kw): ''' Example: kw = dict(min=-0.5, max=.5, cmap=dataviz.mycolor(), rot=-85, title='') fig, ax = plt.subplots(nrows=2, figsize=(7, 7)) plt.subplots_adjust(hspace=0.05) dataviz.hpmollview(d0, r'$\delta_{\rm ELG}$', [fig,ax[0]], **kw) dataviz.hpmollview(d1, r'$\delta_{\rm LRG}$', [fig,ax[1]], **kw) plt.savefig('delta_dr8.png', bbox_inches='tight', dpi=300) ''' fig, ax = figax cmap.set_over(cmap(1.0)) cmap.set_under('w') cmap.set_bad('white') fig.sca(ax) if smooth: map1 = hp.smoothing(map1, fwhm=np.deg2rad(0.5)) hp.mollview(map1, hold=True, unit=unit, cmap=cmap, **kw) hp.graticule(dpar=45, dmer=45, coord='C', verbose=False, alpha=0.5, color='grey') # galactic plane if galaxy: r = hp.Rotator(coord=['G', 'C']) theta_gal, phi_gal = np.zeros(1000) + np.pi / 2, np.linspace( 0, 360, 1000) theta_cl, phi_cl = r(theta_gal, phi_gal) hp.projplot(theta_cl, phi_cl, 'r.', alpha=1.0, markersize=1.)
def MapToEqNorm(self, eqmap, smoothing): print 'wtf', eqmap, np.sum(eqmap) if NSIDE != 32: if DEBUG: print PF("warn"), "rebinning EqNormMap to ", NSIDE eqmap = hp.pixelfunc.ud_grade(eqmap, NSIDE) if not np.sum(eqmap): return np.zeros(len(eqmap)) if smoothing: eqmap = hp.smoothing(eqmap, sigma=np.deg2rad(smoothing), verbose=False, lmax=64) posmap = eqmap - 1. * np.min(eqmap) eqmap[eqmap < 0.] = 0. if not np.sum(eqmap): eqmap = np.ones(len(eqmap)) return eqmap / float(np.sum(eqmap)), posmap / float(np.sum(posmap))
def calc_residual_cmb_amp_map(self, nmc, fwhm=None): """ Method to calculate the stacked residual map of a set of Nmc cleaned CMB maps, removing the true CMB. Parameters ---------- nmc: int Number of MC realizations to use. Returns ------- ndarray Array containing map of residuals. """ cmb = self.calc_stacked_amp_map('cmb', nmc) if fwhm is not None: cmb_true = hp.smoothing(self.cmb_true, pol=True, fwhm=np.pi / 180. * fwhm / 60.) return cmb - cmb_true[1:]
def skyhist(posteriorsamples='posterior_samples.dat', skyres=2.): import healpy if type(posteriorsamples) is str: posteriorsamples = loadposteriorsamples(posteriorsamples) baseres = (skyres / 4.) * np.pi / 180. # require this resolution from healpix grid nside = 2**int(min(10, np.ceil( np.log2(healpy.nside2resol(1) / baseres)))) # don't go past 2**10 (12.6 million pixels) npix = healpy.nside2npix(nside) p = healpy.ang2pix( nside, posteriorsamples[:, 2], posteriorsamples[:, 1]) # convert (theta, phi) to healpix numbers # n = np.bincount(p, minlength=npix) # bin the samples n = np.zeros(npix) n[:max(p) + 1] = np.bincount( p ) # support old version of numpy that does not have minlength argument m = healpy.smoothing(n, sigma=skyres * np.pi / 180.) # smoothed map return m
def add_beam(name1,name2,nameout): f1=h5py.File(name1) f2=h5py.File(name2) map1=f1['map'].value map2=f2['map'].value f1.close() f2.close() fr=map1.shape[0] def fwhm(freq): D=40 return 1.22*1440.*0.21/freq/D freq=np.linspace(700,800,fr,endpoint=True) Fwhm=map(fwhm,freq) map0=map1[:,0,:]+map2[:,0,:] del map1 del map2 for i in range(fr): map0[i]=hp.smoothing(map0[i],fwhm=Fwhm[i]) f=h5py.File(nameout,mode='w') f.create_dataset(name='map',data=map0) f.close()
def surv_diff(surveydict,ss1=1,ss2=2,nside=128,freq=70,mask_ps=True,fwhm=10.0): """ function to make differences among 5 surveys from andreas interactive destriper/binner. uses common masks smooth to 10 degrees fwhm is in degrees, if zero or negative don't smooth at all, default 10 degrees """ m1=hp.ma(np.array(surveydict[ss1])) m2=hp.ma(np.array(surveydict[ss2])) totalmask=m1.mask|m2.mask if mask_ps==True: psmask = np.logical_not(np.floor(hp.ud_grade(hp.read_map(glob('/project/projectdirs/planck/data/mission/DPC_maps/dx8/lfi/DX8_MASKs/' + 'mask_ps_%GHz_*.fits' % freq)[0]), nside,order_out='NEST'))) totalmask=m1.mask | m2.mask | psmask dif=(m1-m2)/2. dif.mask=totalmask dif.mask |= np.isnan(dif) dif=hp.ud_grade(dif,nside,order_in='NEST',order_out='RING') if fwhm>0: difsm=hp.ma(hp.smoothing(dif.filled(),fwhm*np.pi/180.)) difsm.mask=dif.mask if fwhm<=0: difsm=dif return difsm
def fname2real_alms(fname, l_max): the_map = np.genfromtxt(fname) the_map = hp.pixelfunc.ud_grade(the_map, 128, pess=True, power=1.) the_map /= the_map.sum() the_map = hp.smoothing(the_map, sigma=np.deg2rad(2), verbose=False) the_map -= 1. * np.min(the_map) the_map /= the_map.sum() # the_map[hp.pixelfunc.ang2pix(128, np.pi/2 - 0.222, 3.26)] += 0.1 # virgo cluster in equatorial coordinates # the_map[hp.pixelfunc.ang2pix(128, 1.23, 5.4)] += 0.1 # cen a in galactic coordinates cplx_alms = hp.sphtfunc.map2alm(the_map, l_max) cplx_alms /= cplx_alms[Alm.getidx(l_max, 0, 0)] cplx_alms /= np.sqrt(4 * np.pi) # hp.visufunc.mollview(hp.sphtfunc.alm2map(cplx_alms, 128)) # plt.show() real_alms = cplx2real_alms(cplx_alms) return real_alms
def do_harmonic_analysis(parameters,vrmap,bincenter): radius_largest_hole = find_largest_hole(parameters,vrmap) smoothing_fwhm_Mpch = parameters.smoothing_radius_fwhm # Mpc/h # bincenter is currently calculated as the mean of the distances to the halos in the bin smoothing_fwhm = smoothing_fwhm_Mpch/bincenter lmax = int(sp.floor(sp.pi/smoothing_fwhm)) print "The mean distance to the halos in the bin is", bincenter,"Mpc/h" print "The radius of the largest hole is", radius_largest_hole*bincenter, "Mpc/h" print "The smoothing fwhm is", smoothing_fwhm_Mpch print "The smoothing fwhm is", smoothing_fwhm, "rad." print "This corresponds to l = pi/%s = %s" \ %(smoothing_fwhm,sp.pi/smoothing_fwhm) print "The pixel size is", pixelsize_in_radians(parameters), "rad." empty_pixels_total = len(vrmap[(vrmap == parameters.unseen)\ | (vrmap == parameters.badval)]) empty_pixels_fraction = empty_pixels_total/hp.nside2npix(parameters.nside) print "empty_pixels_fraction = ", empty_pixels_fraction ar_dummy, window = apply_window(parameters,vrmap,1,1,smoothing_fwhm) ar_masked, mask = apply_mask(parameters,vrmap,1,1) ar_final = hp.smoothing(ar_masked*window,fwhm=smoothing_fwhm,verbose=False) pixels_total = hp.nside2npix(parameters.nside) factor = pixels_total/(pixels_total-empty_pixels_total) print "Note: I am correcting the pseudo and the master coefficients by factor." print "factor = ", factor ls, pseudo_cls = get_pseudo_powerspectrum(ar_final,lmax) ls, master_cls = get_MASTER_corrected_powerspectrum(pseudo_cls,window,lmax) return ls,master_cls
def smooth_and_norm_healpy_map(logl_map, smooth_sigma=None): """ Takes a lnLLH map, converts it to normal space, applies gaussian smoothing and normalizes it, so that the integral over the unit sphere is 1. Parameters ---------- logl_map : array-like healpy map array with logLLH values. smooth_sigma : float or None, optional Width in sigma of gaussian smoothing kernel, must be ``>0.``. (default: None) Returns ------- pdf_map : array-like Smoothed and normalized spatial PDF map. """ if smooth_sigma < 0.: raise ValueError("`smooth_sigma` can be in range [0, *].") # Normalize to sane values in [*, 0] for conversion llh = exp(logllh) pdf_map = np.exp(logl_map - np.amax(logl_map)) # Smooth with a gaussian kernel pdf_map = hp.smoothing(map_in=pdf_map, sigma=smooth_sigma, verbose=False) # Healpy smoothing may produce numerical erros, so fix them after smoothing pdf_map[pdf_map < 0.] = 0. # Normalize to PDF, integral is the sum over discrete pixels here NSIDE = hp.get_nside(logl_map) dA = hp.nside2pixarea(NSIDE) norm = dA * np.sum(pdf_map) if norm > 0.: pdf_map = pdf_map / norm assert np.isclose(np.sum(pdf_map) * dA, 1.) else: print(" !! Map norm is < 0. Returning unnormed map instead !!") return pdf_map
def many_spectra(): import healpy as hp chunks = ['f','g','h'] thresh = {'f':1.0, 'g':1.0, 'h':1.8} fwhm_deg = {'f':7.0, 'g':7.0, 'h':5.0} final_fwhm_deg = {'f':7.0, 'g':7.0, 'h':7.0} cl={} pl.figure(1) pl.clf() xlim = [10,700] ylim = [1e-7, 3e-4] for k in chunks: print k nmap = get_hpix(quick=True,name=k) mask = mask_from_map(nmap, fwhm_deg=fwhm_deg[k], final_fwhm_deg=final_fwhm_deg[k], thresh=thresh[k]) # mean_nmap = np.mean(nmap[np.where(mask!=0)[0]]) mean_nmap = np.mean(nmap[np.where(mask>0.5)[0]]) delta = (nmap-mean_nmap)/mean_nmap hp.mollview(hp.smoothing(delta*mask,fwhm=1.*np.pi/180.),title=k,min=-0.3,max=0.3) continue this_cl = hp.anafast(delta*mask)/np.mean(mask**2.) l=np.arange(len(this_cl)) # smooth in l*cl lcl = this_cl*l sm_lcl = np.zeros_like(lcl) rbox = 15 for i in l: imin = np.max([0,i-rbox]) imax = np.min([np.max(l), i+rbox]) sm_lcl[i]=np.mean(lcl[imin:imax]) # cl[k:this_cl] # pl.loglog(l,this_cl,linewidth=2) pl.loglog(l,sm_lcl,linewidth=2) pdb.set_trace() pl.xlim(xlim) # pl.ylim(ylim) pl.legend(chunks) pl.xlabel('L') pl.ylabel('L*CL')
def reconvolve(maps, fwhms, ref_fwhm, verbose=False): if verbose: print('Reconvolution to common FWHM') sig_conv = np.sqrt(ref_fwhm**2 - fwhms**2) maps_out = np.zeros_like(maps) for i in range(len(fwhms)): if sig_conv[i] == 0: if verbose: print( 'Map {0:} fwhmin={1:6.3f} fwhmout={2:6.3f} => We do not reconvolve' .format(i, fwhms[i], ref_fwhm)) maps_out[i, :] = maps[i, :] else: if verbose: print( 'Map {0:} fwhmin={1:6.3f} fwhmout={2:6.3f} => We reconvolve with {3:6.3f}' .format(i, fwhms[i], ref_fwhm, sig_conv[i])) maps_out[i, :] = hp.smoothing(maps[i, :], fwhm=np.deg2rad(sig_conv[i]), pol=True, verbose=False) return maps_out
def updateCoverage(self, time=None): time = time or datetime.datetime.utcnow() night = self.favor2.get_night(time) images = self.favor2.query( "SELECT * FROM images WHERE type='avg' AND night=%s AND time>%s ORDER BY time", (night, self.latest_time), simplify=False) cmap = np.zeros_like(self.coverage) for i, image in enumerate(images): #print i,len(images) ra, dec = image['ra0'], image['dec0'] sr0 = float(image['keywords']['PIXSCALE']) * 0.5 * min( image['width'], image['height']) cmap += self.snapshot_fn(ra, dec, sr0, smooth=False) self.latest_time = image['time'] if images: self.coverage += hp.smoothing(cmap, fwhm=np.deg2rad(self.r0), verbose=False) self.storeCoverage()
def _simulate_sss(self, key1, key2, counter1, counter2, weather, comm): """ Create a map of the ground signal to observe with all detectors """ # FIXME: we could store the map in node-shared memory # # Surface temperature is made available but not used yet # to scale the SSS if comm is None or comm.rank == 0: # Only the root process loads or simulates the map temperature = weather.surface_temperature if self._path: sssmap = hp.read_map(self._path, verbose=False) else: npix = 12 * self._nside**2 sssmap = random( npix, key=(key1, key2), counter=(counter1, counter2), sampler="gaussian", ) sssmap = np.array(sssmap, dtype=np.float) sssmap = hp.smoothing(sssmap, fwhm=np.radians(self._fwhm), lmax=self._lmax) sssmap /= np.std(sssmap) lon, lat = hp.pix2ang(self._nside, np.arange(npix, dtype=np.int), lonlat=True) scale = self._scale * (np.abs(lat) / 90 + 0.5)**self._power sssmap *= scale else: sssmap = None if comm is not None: sssmap = comm.bcast(sssmap) return sssmap
def get_mask(fname_hits): fname_mask = "mask_" + os.path.basename(fname_hits) if os.path.isfile(fname_mask): mask = hp.read_map(fname_mask) else: hits = hp.read_map(fname_hits) good = hits > 0 ngood = np.sum(good) sorted_hits = np.sort(hits[good]) hit_lim = sorted_hits[np.int(ngood * .01)] mask = hits > hit_lim pix = np.arange(hits.size) lon, lat = hp.pix2ang(nside, pix, lonlat=True) lat_min = np.amin(lat[mask]) lat_max = np.amax(lat[mask]) mask = np.zeros(npix) tol = 10.0 # degrees mask[np.logical_and(lat_min + tol < lat, lat < lat_max - tol)] = 1 mask = hp.smoothing(mask, fwhm=np.radians(3), lmax=2048) hp.write_map(fname_mask, mask) return mask
import healpy as hp import numpy as np from pycsphere.mesh import HEALPixPointSet from pycsphere.linop import DiscreteSphericalLaplacian nside = 16 rng = np.random.default_rng(0) map_in = rng.binomial(n=1, p=0.005, size=hp.nside2npix(nside=nside)) map_in = hp.smoothing(map_in, sigma=10 * np.pi / 180) laplacian = DiscreteSphericalLaplacian(point_set=HEALPixPointSet(nside=nside)) map_d2 = laplacian(map_in) hp.mollview(map=map_in, title='Input Map', cmap='viridis') hp.mollview(map=np.abs(map_d2), title='Magnitude of Laplacian Map', cmap='viridis')
def main_hp(args): '''Main function for simple Healpy estimation.''' print('>> Simple fsky estimation.') bbs = np.loadtxt(args.fb, dtype='int32') lmax = bbs[-1, -1] print('>> Loading mask 1: {}'.format(args.mask1)) mask1 = hp.read_map(args.mask1) if args.fwhm1 != -1: fwhm1 = args.fwhm1 * np.pi / 180 # get fwhm in radians print('>> Smoothing mask1, FWHM: {0:f} degrees'.format(args.fwhm1)) mask1 = hp.smoothing(mask1, fwhm=fwhm1, pol=False) if args.alm1 != '': print('>> Loading alm 1: {}'.format(args.alm1)) alm1 = hp.read_alm(args.alm1) elif args.map1 != '': print('>> Loading map 1: {}'.format(args.map1)) map1 = hp.read_map(args.map1) if args.eccl[0] == '0': print(':: Multiplying mask on the map ::') map1 = map1 * mask1 alm1 = hp.map2alm(map1, lmax=lmax, pol=False) else: sys.exit('No input map or alm 1.') if args.tp == 'cross': # cross correlation print('>> Loading mask 2: {}'.format(args.mask2)) mask2 = hp.read_map(args.mask2) if args.fwhm2 != -1: fwhm2 = args.fwhm2 * np.pi / 180 # get fwhm in radians print('>> Smoothing mask2, FWHM: {0:f} degrees'.format(args.fwhm2)) mask2 = hp.smoothing(mask2, fwhm=fwhm2, pol=False) if args.alm2 != '': print('>> Loading alm 2: {}'.format(args.alm2)) alm2 = hp.read_alm(args.alm2) elif args.map2 != '': print('>> Loading map 2: {}'.format(args.map2)) map2 = hp.read_map(args.map2) if args.eccl[1] == '0': print(':: Multiplying mask on the map ::') map2 = map2 * mask2 alm2 = hp.map2alm(map2, lmax=lmax, pol=False) else: sys.exit('No input map or alm 2.') elif args.tp == 'auto': alm2 = None else: sys.exit('>> Wrong correlation type!') cl = hp.alm2cl(alm1, alms2=alm2, lmax_out=lmax) cl = cl / args.fsky data = bin_cl(cl, bbs) header = 'ell cl xerr yerr' fn = args.focl np.savetxt(fn, data, header=header) print(':: Written to: {}'.format(fn))