def get_maps(spectra, inst, sampling, nside, x0, coverage_threshold=0.01,savefile=None, savefile_noiseless=None, noI=False):
#if x0 is None:
# print("Running Synfast")
# x0 = np.array(hp.synfast(spectra[1:],nside,fwhm=0,pixwin=True,new=True)).T
# if noI: x0[:,0]*=0
acquisition = QubicAcquisition(inst, sampling,
nside=nside,
synthbeam_fraction=0.99)
#max_nbytes=6e9)
# simulate the timeline
print('Now doing MAP2TOD (simulate data)')
tod, x0_convolved = map2tod(acquisition, x0, convolution=True)
print('TOD Done, now adding noise')
bla = acquisition.get_noise()
tod_noisy = tod + bla
# reconstruct using all available bolometers
print('Now doing TOD2MAP (make map)')
map_all, cov_all = tod2map_all(acquisition, tod_noisy, tol=1e-4, coverage_threshold=coverage_threshold)
print('Map done')
print('Now doing TOD2MAP (make map) on noiseless data')
map_all_noiseless, cov_all_noiseless = tod2map_all(acquisition, tod, tol=1e-4, coverage_threshold=coverage_threshold)
print('Noiseless Map done')
mask = map_all_noiseless != 0
x0_convolved[~mask,:] = 0
rank = MPI.COMM_WORLD.rank
if rank == 0:
if savefile is not None:
print('I am rank='+str(rank)+' and I try to save the file '+savefile)
FitsArray(np.array([map_all[:,0], map_all[:,1], map_all[:,2], cov_all, x0_convolved[:,0], x0_convolved[:,1], x0_convolved[:,2]]), copy=False).save(savefile)
print('I am rank='+str(rank)+' and I just saved the file '+savefile)
print('I am rank='+str(rank)+' and I try to save the file '+savefile_noiseless)
FitsArray(np.array([map_all_noiseless[:,0], map_all_noiseless[:,1], map_all_noiseless[:,2], cov_all_noiseless, x0_convolved[:,0], x0_convolved[:,1], x0_convolved[:,2]]), copy=False).save(savefile_noiseless)
print('I am rank='+str(rank)+' and I just saved the file '+savefile_noiseless)
return map_all, x0_convolved, cov_all, x0
def make_a_map(x0, pointing, instrument, nside, coverage_threshold=0.01, todnoise=None, fits_string=None, noiseless=False):
############# Make TODs ###########################################################
acquisition = QubicAcquisition(instrument, pointing,
nside=nside,
synthbeam_fraction=0.99)
tod, x0_convolved = map2tod(acquisition, x0, convolution=True)
if todnoise is None:
todnoise = acquisition.get_noise()
factnoise=1
if noiseless:
factnoise=0
##################################################################################
############# Make mapss ###########################################################
print('Making map')
maps, cov = tod2map_all(acquisition, tod + todnoise * factnoise, tol=1e-4, coverage_threshold=coverage_threshold)
if MPI.COMM_WORLD.rank == 0:
fitsmapname = 'maps_'+fits_string+'.fits'
fitscovname = 'cov_'+fits_string+'.fits'
print('Saving the map: '+fitsmapname)
qubic.io.write_map(fitsmapname,maps)
print('Saving the coverage: '+fitsmapname)
qubic.io.write_map(fitscovname,cov)
##################################################################################
return maps, cov, todnoise
# let's take the galactic north pole as the center of the observation field
center_gal = 0, 90
center = gal2equ(center_gal[0], center_gal[1])
# sampling model
np.random.seed(0)
sampling = create_random_pointings(center, 1000, 10)
scene = QubicScene(nside, kind='I')
# acquisition model
acq = QubicAcquisition(150, sampling, scene)
y, x0_convolved = acq.get_observation(x0, convolution=True, noiseless=True)
# map-making
x, coverage = tod2map_all(acq, y, disp=True, tol=1e-4, coverage_threshold=0)
mask = coverage > 0
# some display
def display(x, title):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x, rot=center_gal, reso=5, xsize=600, min=-200, max=200,
title=title)
display(x0, 'Original map')
display(x0_convolved, 'Convolved original map')
display(x, 'Reconstructed map (gaussian approximation)')
display(x - x0_convolved, 'Residual map (gaussian approximation)')
mp.show()
acquisition = QubicAcquisition(150,
sampling,
scene,
synthbeam_fraction=0.99,
detector_tau=0.01,
detector_nep=1.e-17,
detector_fknee=1.,
detector_fslope=1)
# simulate the timeline
tod, x0_convolved = acquisition.get_observation(x0,
convolution=True,
noiseless=True)
# reconstruct using two methods
map_all, cov_all = tod2map_all(acquisition, tod, tol=1e-2)
map_each, cov_each = tod2map_each(acquisition, tod, tol=1e-2)
# some display
def display(map, cov, msg, sub):
for i, (kind, lim) in enumerate(zip('IQU', [200, 10, 10])):
map_ = map[..., i].copy()
mask = cov == 0
map_[mask] = np.nan
hp.gnomview(map_,
rot=center,
reso=5,
xsize=400,
min=-lim,
max=lim,
from __future__ import division
from qubic import (create_random_pointings, gal2equ, QubicAcquisition,
QubicScene, tod2map_all)
import numpy as np
import qubic
# read the input map
input_map = qubic.io.read_map(qubic.data.PATH + 'syn256_pol.fits',
field='I_STOKES')
nside = 256
# let's take the galactic north pole as the center of the observation field
center_gal = 0, 90
center = gal2equ(center_gal[0], center_gal[1])
# sampling model
np.random.seed(0)
sampling = create_random_pointings(center, 1000, 10)
scene = QubicScene(nside, kind='I')
# acquisition model
acq = QubicAcquisition(150, sampling, scene)
hit = acq.get_hitmap()
# Produce the Time-Ordered data
tod = acq.get_observation(input_map)
output_map, coverage = tod2map_all(acq, tod)
print(acq.comm.rank, output_map[coverage > 0][:5])
print(acq.comm.rank, hit[hit > 0][:10])
# let's take the galactic north pole as the center of the observation field
center_gal = 0, 90
center = gal2equ(center_gal[0], center_gal[1])
# sampling model
np.random.seed(0)
sampling = create_random_pointings(center, 1000, 10)
scene = QubicScene(nside, kind='I')
# acquisition model
acq = QubicAcquisition(150, sampling, scene)
y, x0_convolved = acq.get_observation(x0, convolution=True, noiseless=True)
# map-making
x, coverage = tod2map_all(acq, y, disp=True, tol=1e-4, coverage_threshold=0)
mask = coverage > 0
# some display
def display(x, title):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x,
rot=center_gal,
reso=5,
xsize=600,
min=-200,
max=200,
title=title)
fits_noiseless = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_noiseless_'+strrnd+'.fits'
fits_noise = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_noisy_'+strrnd+'.fits'
fits_spoiled_noiseless = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_spoiled_noiseless_'+strrnd+'.fits'
fits_spoiled_noise = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_spoiled_noisy_'+strrnd+'.fits'
fits_noI_noiseless = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_noI_noiseless_'+strrnd+'.fits'
fits_noI_noise = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_noI_noisy_'+strrnd+'.fits'
fits_noI_spoiled_noiseless = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_noI_spoiled_noiseless_'+strrnd+'.fits'
fits_noI_spoiled_noise = 'maps_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_noI_spoiled_noisy_'+strrnd+'.fits'
fits_cov = 'cov_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_'+strrnd+'.fits'
fits_spoiled_cov = 'cov_ns'+str(nside)+'_noise'+str(noise)+'_sigptg'+str(sigptg)+'_spoiled_'+strrnd+'.fits'
coverage_threshold = 0.01
print('Making noiseless map with true coverage')
maps_noiseless, cov_noiseless = tod2map_all(acquisition, tod, tol=1e-4, coverage_threshold=coverage_threshold)
if rank == 0:
print('Saving the noiseless map with true coverage: '+fits_noiseless)
qubic.io.write_map(fits_noiseless,maps_noiseless)
mask = cov_noiseless == 0
x0_convolved[mask,:] = 0
x0_noI_convolved[mask,:] = 0
if rank == 0:
print('Saving the input map: '+fits_input)
qubic.io.write_map(fits_input,x0_convolved)
print('Saving the noI input map: '+fits_noI_input)
qubic.io.write_map(fits_noI_input, x0_noI_convolved)
from qubic import (
create_random_pointings, gal2equ, QubicAcquisition, QubicScene,
tod2map_all)
import numpy as np
import qubic
# read the input map
input_map = qubic.io.read_map(qubic.data.PATH + 'syn256_pol.fits',
field='I_STOKES')
nside = 256
# let's take the galactic north pole as the center of the observation field
center_gal = 0, 90
center = gal2equ(center_gal[0], center_gal[1])
# sampling model
np.random.seed(0)
sampling = create_random_pointings(center, 1000, 10)
scene = QubicScene(nside, kind='I')
# acquisition model
acq = QubicAcquisition(150, sampling, scene)
hit = acq.get_hitmap()
# Produce the Time-Ordered data
tod = acq.get_observation(input_map)
output_map, coverage = tod2map_all(acq, tod)
print acq.comm.rank, output_map[coverage > 0][:5]
print acq.comm.rank, hit[hit > 0][:10]
# get the acquisition model
acquisition = QubicAcquisition(150, sampling,
nside=nside,
synthbeam_fraction=0.99,
detector_tau=0.01,
detector_sigma=1.,
detector_fknee=1.,
detector_fslope=1)
# simulate the timeline
tod, x0_convolved = map2tod(acquisition, x0, convolution=True)
tod_noisy = tod + acquisition.get_noise()
# reconstruct using two methods
map_all, cov_all = tod2map_all(acquisition, tod, tol=1e-2)
map_each, cov_each = tod2map_each(acquisition, tod, tol=1e-2)
# some display
def display(map, cov, msg, sub):
for i, (kind, lim) in enumerate(zip('IQU', [200, 10, 10])):
map_ = map[..., i].copy()
mask = cov == 0
map_[mask] = np.nan
hp.gnomview(map_, rot=center, reso=5, xsize=400, min=-lim, max=lim,
title=msg + ' ' + kind, sub=(3, 3, 3 * (sub-1) + i+1))
center = equ2gal(racenter, deccenter)
mp.figure(1)
# let's take the galactic north pole as the center of the observation field
center_gal = 0, 90
center = gal2equ(center_gal[0], center_gal[1])
# sampling model
np.random.seed(0)
sampling = create_random_pointings(center, 1000, 10)
# acquisition model
acq = QubicAcquisition(150, sampling, kind='I')
acq_simple = SimpleAcquisition(150, sampling, kind='I')
hit = acq.get_hitmap()
C = acq.get_convolution_peak_operator()
tod = acq.get_observation(input_map)
output_map, coverage = tod2map_all(acq, tod)
output_map[coverage == 0] = np.nan
coverage[coverage == 0] = np.nan
tod_simple = acq_simple.get_observation(input_map)
output_map_simple, coverage_simple = tod2map_all(acq_simple, tod_simple)
output_map_simple[coverage_simple == 0] = np.nan
coverage_simple[coverage_simple == 0] = np.nan
# some display
def display(x, title, min=-200, max=200):
hp.gnomview(x, rot=center_gal, reso=5, xsize=600, min=min, max=max,
title=title)
display(input_map, 'Original map')
