def test_precomputed_alms(setup): alms, filename = setup nside = 64 # we assume the original `alms` are in `K_CMB` ref_freq = 40 test_map_K_CMB = hp.alm2map(alms, nside=nside) alms_K_RJ = alms * pysm.convert_units("K_CMB", "K_RJ", ref_freq) filename_K_RJ = filename.replace(".fits", "_RJ.fits") hp.write_alm(filename_K_RJ, alms_K_RJ) precomputed_alms = PrecomputedAlms( filename=filename_K_RJ, nside=nside, input_units="uK_RJ", input_reference_frequency_GHz=ref_freq, ) m = precomputed_alms.signal(23) np.testing.assert_allclose( m, test_map_K_CMB * pysm.convert_units("uK_CMB", "uK_RJ", 23)) freqs = np.array([1, 10, 100]) m_multifreq = precomputed_alms.signal(freqs) assert m_multifreq.shape == (3, 3, hp.nside2npix(64)) for freq, m in zip(freqs, m_multifreq): np.testing.assert_allclose( m, test_map_K_CMB * pysm.convert_units("uK_CMB", "uK_RJ", freq))
def get_foreground_maps_and_cl(sky_obj, miscalibration_angle, frequencies2use, mask, mask_apo, wsp, purify_e, purify_b, return_dust=True, return_synchrotron=True, return_maps=False): dust_map_freq = [] sync_map_freq = [] Cl_dust_freq = [] Cl_sync_freq = [] for f in frequencies2use: if return_dust: dust_maps_ = sky_obj.sky.dust(f) * \ convert_units('K_RJ', 'K_CMB', f) dust_maps = lib.map_rotation(dust_maps_, miscalibration_angle) dust_map_freq.append(dust_maps) f2_dust = get_field(mask * dust_maps[1, :], mask * dust_maps[2, :], mask_apo, purify_e=purify_e, purify_b=purify_b) Cl_dust_freq.append(compute_master(f2_dust, f2_dust, wsp)) if return_synchrotron: sync_maps_ = sky_obj.sky.synchrotron(f) * \ convert_units('K_RJ', 'K_CMB', f) sync_maps = lib.map_rotation(sync_maps_, miscalibration_angle) sync_map_freq.append(sync_maps) f2_sync = get_field(mask * sync_maps[1, :], mask * sync_maps[2, :], mask_apo, purify_e=purify_e, purify_b=purify_b) Cl_sync_freq.append(compute_master(f2_sync, f2_sync, wsp)) if return_dust: dust_map_freq = np.array(dust_map_freq) Cl_dust_freq = np.array(Cl_dust_freq) if return_synchrotron: sync_map_freq = np.array(sync_map_freq) Cl_sync_freq = np.array(Cl_sync_freq) if return_maps: if return_dust and return_synchrotron: return Cl_dust_freq, Cl_sync_freq, dust_map_freq, sync_map_freq elif return_dust: return Cl_dust_freq, dust_map_freq elif return_synchrotron: return Cl_sync_freq, sync_map_freq else: return Cl_dust_freq, Cl_sync_freq
def get_freq_maps(self, output=0): cmb_freq_maps = self.sky.cmb(sky_map.cmb_freq) * \ pysm.convert_units('K_RJ', 'K_CMB', sky_map.cmb_freq) dust_freq_maps = self.sky.dust(sky_map.dust_freq) * \ pysm.convert_units('K_RJ', 'K_CMB', sky_map.dust_freq) sync_freq_maps = self.sky.synchrotron(sky_map.synchrotron_freq) *\ pysm.convert_units('K_RJ', 'K_CMB', sky_map.synchrotron_freq) self.cmb_freq_maps = cmb_freq_maps self.dust_freq_maps = dust_freq_maps self.sync_freq_maps = sync_freq_maps del self.sky if output: return cmb_freq_maps, dust_freq_maps, sync_freq_maps
def signal(self, nu, **kwargs): """Return map in uK_RJ at given frequency or array of frequencies""" if np.isscalar(nu): nu = np.array([nu]) filename = utils.get_data_from_url(self.get_filename()) m = pysm.read_map( filename, nside=self.nside, field=0, pixel_indices=self.pixel_indices, mpi_comm=self.mpi_comm, ) npix = (len(self.pixel_indices) if self.pixel_indices is not None else hp.nside2npix(self.nside)) all_maps = np.zeros((len(nu), 1, npix), dtype=np.double) szfac = np.ones(len(nu)) if self.sz_type == "thermal": szfac = y2uK_CMB(nu) all_maps[:, 0, :] = np.outer( pysm.convert_units("uK_CMB", "uK_RJ", nu) * szfac, m) # the output of out is always 3D, (num_freqs, IQU, npix), if num_freqs is one # we return only a 2D array. if len(all_maps) == 1: return all_maps[0] else: return all_maps
def main(fname_config): #Read configuration into classes Config = ConfigParser.ConfigParser() Config.read(fname_config) out = output(Config._sections['GlobalParameters']) Config.read('./ConfigFiles/'+Config.get('FreeFree','model')+'_config.ini') freefree = component(Config._sections['FreeFree'],out.nside) with open(out.output_dir+out.output_prefix+'freefree_config.ini','w') as configfile\ : Config.write(configfile) print('Computing free-free maps.') print '----------------------------------------------------- \n' if out.debug == True: print ''.join("%s: %s \n" % item for item in vars(freefree).items()) print '----------------------------------------------------- \n' conv_I = convert_units(freefree.template_units,out.output_units,out.output_frequency) scaled_map_ff = scale_freqs(freefree,out)*conv_I[...,np.newaxis]*freefree.em_template scaled_map_ff_pol = np.zeros((2,np.asarray(out.output_frequency).size,hp.nside2npix(out.nside))) if out.debug == True: ff = np.concatenate([scaled_map_ff[np.newaxis,...],scaled_map_ff_pol]) for i in range(0,len(out.output_frequency)): hp.write_map(out.output_dir+out.output_prefix+'ff_%d'%(out.output_frequency[i])+'_'+str(out.nside)+'.fits',ff[:,i,:],coord='G',column_units=out.output_units) return np.concatenate([scaled_map_ff[np.newaxis,...],scaled_map_ff_pol])
def instrument_noise(fname_config): Config = ConfigParser.ConfigParser() Config.read(fname_config) out = output(Config._sections['GlobalParameters']) print('Adding instrument noise.') print '----------------------------------------------------- \n' npix = hp.nside2npix(out.nside) #Convert noise to sigma per pixel. fsky_pix = 1./npix pix_ster = 4.*np.pi*fsky_pix pix_amin2 = pix_ster*(180.*60./np.pi)**2 #converts size of pixel from steradians to square arcminutes sigma_pix_I = np.sqrt(out.instrument_noise_i**2/pix_amin2) sigma_pix_pol = np.sqrt(out.instrument_noise_pol**2/pix_amin2) #Generate noise as gaussian with variances above: np.random.seed(out.instrument_noise_seed) instrument_noise = np.random.randn(3,np.asarray(out.output_frequency).size,npix) #standard_normal*sigma+mu = N(mu,sigma) instrument_noise[0,...]=sigma_pix_I[np.newaxis,:,np.newaxis]*instrument_noise[0,...] instrument_noise[1,...]=sigma_pix_pol[np.newaxis,:,np.newaxis]*instrument_noise[1,...] instrument_noise[2,...]=sigma_pix_pol[np.newaxis,:,np.newaxis]*instrument_noise[2,...] return instrument_noise*convert_units(['u','K_CMB'],out.output_units,out.output_frequency)[np.newaxis,:,np.newaxis]
def read_map(self, freq): if self.verbose: print("Reading map {}".format(self.maps[freq])) m = pysm.read_map(self.maps[freq], nside=self.nside, field = (0,1,2) if self.has_polarization else 0, pixel_indices=self.pixel_indices, mpi_comm=self.mpi_comm) return m * pysm.convert_units(self.input_units, "uK_RJ", freq)
def main(fname_config): #Read in configuration file to classes. Config = ConfigParser.ConfigParser() Config.read(fname_config) out = output(Config._sections['GlobalParameters']) Config.read('./ConfigFiles/'+Config.get('Synchrotron','model')+'_config.ini') synch = component(Config._sections['Synchrotron'],out.nside) with open(out.output_dir+out.output_prefix+'synchrotron_config.ini','w') as configfile: Config.write(configfile) print('Computing synchrotron maps.') print '----------------------------------------------------- \n' if out.debug == True: print ''.join("%s: %s \n" % item for item in vars(synch).items()) print '----------------------------------------------------- \n' #The unit conversion takes care of the scaling being done in uK_RJ. After scaling we convert to whatever the output units are. conv_I = convert_units(synch.template_units, ['u','K_RJ'], synch.freq_ref) conv_pol = convert_units(synch.template_units, ['u','K_RJ'], synch.pol_freq_ref) conv2 = convert_units(['u','K_RJ'],out.output_units,out.output_frequency) unit_conversion_I = conv_I*conv2.reshape((len(out.output_frequency),1)) unit_conversion_pol = conv_pol*conv2.reshape((len(out.output_frequency),1)) #Do the scaling. scaled_map_synch = scale_freqs(synch, out, pol=False)*synch.em_template*unit_conversion_I scaled_map_synch_pol = scale_freqs(synch, out, pol=True)[np.newaxis,...]*np.array([synch.polq_em_template,synch.polu_em_template])[:,np.newaxis,:]*unit_conversion_pol #This section forces P/I<0.75. This is done using the same procedure as the PSM 1.7.8 psm_synchrotron.pro. P = np.sqrt(scaled_map_synch_pol[0,:,:]**2+scaled_map_synch_pol[1,:,:]**2)/scaled_map_synch F = 0.75*np.tanh(P/0.75)/P scaled_map_synch_pol[0,:,:]=F*scaled_map_synch_pol[0,:,:] scaled_map_synch_pol[1,:,:]=F*scaled_map_synch_pol[1,:,:] #------- if out.debug == True: syn = np.concatenate([scaled_map_synch[np.newaxis,...],scaled_map_synch_pol]) for i in range(0,len(out.output_frequency)): hp.write_map(out.output_dir+out.output_prefix+'synch_%d'%(out.output_frequency[i])+'_'+str(out.nside)+'.fits',syn[:,i,:],coord='G',column_units=out.output_units) return np.concatenate([scaled_map_synch[np.newaxis,...],scaled_map_synch_pol])
def test_dependence_on_nu0_CMB(self): NSIDE = 8 MODEL = 'c1s0' INSTRUMENT = 'litebird' sky = pysm.Sky(get_sky(NSIDE, MODEL)) instrument = pysm.Instrument(get_instrument(INSTRUMENT, NSIDE)) components100 = [cm.CMB(), cm.Synchrotron(100.)] components10 = [cm.CMB(), cm.Synchrotron(10.)] with suppress_stdout(): freq_maps, _ = instrument.observe(sky, write_outputs=False) res100 = basic_comp_sep(components100, instrument, freq_maps) res10 = basic_comp_sep(components10, instrument, freq_maps) aac(res100.Sigma, res10.Sigma) aac(res100.x, res10.x) aac(res100.s[0], res10.s[0]) factor = convert_units('K_CMB', 'K_RJ', 10.) factor /= convert_units('K_CMB', 'K_RJ', 100.) aac(res100.s[1], res10.s[1] * 10**res10.x[0] * factor)
def main(fname_config): #Read in configuration file to classes. Config = ConfigParser.ConfigParser() Config.read(fname_config) out = output(Config._sections['GlobalParameters']) Config.read('./ConfigFiles/'+Config.get('SpinningDust','model')+'_config.ini') spdust_general = component(Config._sections['General'],out.nside) spdust1 = component(Config._sections['SpinningDust1'],out.nside) spdust2 = component(Config._sections['SpinningDust2'],out.nside) print('Computing spinning dust map.') print '----------------------------------------------------- \n' if out.debug == True: print ''.join("%s: %s \n" % item for item in vars(spdust1).items()) print ''.join("%s: %s \n" % item for item in vars(spdust2).items()) print '----------------------------------------------------- \n' with open(out.output_dir+out.output_prefix+'spdust_config.ini','w') as configfile: Config.write(configfile) #Compute a map of the polarisation angle from the commander dust map polariationn angle. pol_angle = np.arctan2(spdust_general.thermaldust_polu,spdust_general.thermaldust_polq) #Units to do the scaling in MJysr and then bring the result back to the output units. conv1 = convert_units(spdust1.template_units, ['u','K_RJ'], spdust1.freq_ref) conv2 = convert_units(spdust2.template_units, ['u','K_RJ'], spdust2.freq_ref) conv_end = convert_units(['u','K_RJ'],out.output_units,out.output_frequency) unit_conversion1 = conv1*conv_end.reshape((len(out.output_frequency),1)) unit_conversion2 = conv2*conv_end.reshape((len(out.output_frequency),1)) scaled_map_spdust = scale_freqs(spdust1,out,pol=False)*spdust1.em_template*unit_conversion1 + scale_freqs(spdust2,out,pol=False)*spdust2.em_template*unit_conversion2 scaled_map_spdust_pol = scaled_map_spdust[np.newaxis,...]*np.asarray([np.cos(pol_angle),np.sin(pol_angle)])[:,np.newaxis,:]*spdust_general.pol_frac if out.debug == True: for i in range(0,len(out.output_frequency)): hp.write_map(out.output_dir+'spdust_%d.fits'%(out.output_frequency[i]),scaled_map_spdust[i],coord='G',column_units=out.output_units) return np.concatenate([scaled_map_spdust[np.newaxis,...],scaled_map_spdust_pol])
def scale_dust_pop(pop, out, Config): dust = component(Config._sections[pop], out.nside) print ("Computing dust maps.") print "----------------------------------------------------- \n" if out.debug == True: print "".join("%s: %s \n" % item for item in vars(dust).items()) print "----------------------------------------------------- \n" conv_I = convert_units(dust.template_units, ["u", "K_RJ"], dust.freq_ref) conv_pol = convert_units(dust.template_units, ["u", "K_RJ"], dust.pol_freq_ref) conv2 = convert_units(["u", "K_RJ"], out.output_units, out.output_frequency) unit_conversion_I = conv_I * conv2.reshape((len(out.output_frequency), 1)) unit_conversion_pol = conv_pol * conv2.reshape((len(out.output_frequency), 1)) scaled_map_dust = scale_freqs(dust, out, pol=False) * dust.em_template * unit_conversion_I scaled_map_dust_pol = ( scale_freqs(dust, out, pol=True)[np.newaxis, ...] * np.array([dust.polq_em_template, dust.polu_em_template])[:, np.newaxis, :] * unit_conversion_pol ) if out.debug == True: dus = np.concatenate([scaled_map_dust[np.newaxis, ...], scaled_map_dust_pol]) for i in range(0, len(out.output_frequency)): hp.write_map( out.output_dir + out.output_prefix + "dust_%d" % (out.output_frequency[i]) + "_" + str(out.nside) + ".fits", dus[:, i, :], coord="G", column_units=out.output_units, ) return np.concatenate([scaled_map_dust[np.newaxis, ...], scaled_map_dust_pol])
def signal(self): """ Simulate CO signal """ out = hp.ud_grade(map_in=self.planck_templatemap, nside_out=self.nside) if self.include_high_galactic_latitude_clouds: out += self.simulate_high_galactic_latitude_CO() if self.has_polarization: Q_map, U_map = self.simulate_polarized_emission(out) out = np.array([out, Q_map, U_map]) unit_conversion = convert_units("K_CMB", self.output_units, self.line_frequency) return out * unit_conversion
def test_precomputed_alms_K_CMB(setup): alms, filename = setup nside = 64 test_map = hp.alm2map(alms, nside=nside) precomputed_alms = PrecomputedAlms(filename=filename, nside=nside, input_units="K_CMB") freqs = np.array([1, 10, 100]) m_multifreq = precomputed_alms.signal(freqs) assert m_multifreq.shape == (3, 3, hp.nside2npix(64)) for freq, m in zip(freqs, m_multifreq): np.testing.assert_allclose( m, test_map * pysm.convert_units("K_CMB", "uK_RJ", freq))
def signal(self, nu=[148.], fwhm_arcmin=None, output_units="uK_RJ", **kwargs): """Return map in uK_RJ at given frequency or array of frequencies If nothing is specified for nu, we default to providing an unmodulated map at 148 GHz. The value 148 Ghz does not matter if the output is in uK_RJ. Parameters ---------- nu : list or ndarray Frequency or frequencies in GHz at which compute the signal fwhm_arcmin : float (optional) Smooth the input alms before computing the signal, this can only be used if the class was initialized with `precompute_output_map` to False. output_units : str Output units, as defined in `pysm.convert_units`, by default this is "uK_RJ" as expected by PySM. Returns ------- output_maps : ndarray Output maps array with the shape (num_freqs, 1 or 3 (I or IQU), npix) """ try: nnu = len(nu) except TypeError: nnu = 1 nu = np.array([nu]) try: output_map = self.output_map except AttributeError: if fwhm_arcmin is None: alm = self.alm else: alm = hp.smoothalm( self.alm, fwhm=np.radians(fwhm_arcmin / 60), pol=True, inplace=False ) output_map = self.compute_output_map(alm) # use tile to output the same map for all frequencies out = np.tile(output_map, (nnu, 1, 1)) if self.wcs is not None: out = enmap.enmap(out, self.wcs) out *= ( ( pysm.convert_units( self.input_units, "uK_CMB", self.input_reference_frequency_GHz ) * pysm.convert_units("uK_CMB", output_units, nu) ) .reshape((nnu, 1, 1)) .astype(float) ) # the output of out is always 3D, (num_freqs, IQU, npix), if num_freqs is one # we return only a 2D array. if len(out) == 1: return out[0] else: return out