def get_qubic_map(instrument, sampling, scene, input_maps, withplanck=True, covlim=0.1):
acq = QubicAcquisition(instrument, sampling, scene, photon_noise=True, effective_duration=1)
C = acq.get_convolution_peak_operator()
coverage = acq.get_coverage()
observed = coverage > covlim * np.max(coverage)
acq_restricted = acq[:, :, observed]
H = acq_restricted.get_operator()
x0_convolved = C(input_maps)
if not withplanck:
pack = PackOperator(observed, broadcast='rightward')
y_noiseless = H(pack(x0_convolved))
noise = acq.get_noise()
y = y_noiseless + noise
invntt = acq.get_invntt_operator()
A = H.T * invntt * H
b = (H.T * invntt)(y)
preconditioner = DiagonalOperator(1 / coverage[observed], broadcast='rightward')
solution_qubic = pcg(A, b, M=preconditioner, disp=True, tol=1e-3, maxiter=1000)
maps = pack.T(solution_qubic['x'])
maps[~observed] = 0
else:
acq_planck = PlanckAcquisition(150, acq.scene, true_sky=x0_convolved)#, fix_seed=True)
acq_fusion = QubicPlanckAcquisition(acq, acq_planck)
map_planck_obs=acq_planck.get_observation()
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
y = acq_fusion.get_observation()
A = H.T * invntt * H
b = H.T * invntt * y
solution_fusion = pcg(A, b, disp=True, maxiter=1000, tol=1e-3)
maps = solution_fusion['x']
maps[~observed] = 0
x0_convolved[~observed] = 0
return(maps, x0_convolved, observed)
def tod2map(self, tod, tol=1e-5, maxiter=1000, verbose=True):
p = self.planck
H = []
for q, w in zip(self.qubic, self.weights):
H.append(QubicPlanckAcquisition(q, p).get_operator() * w)
invntt = self.get_invntt_operator()
A_columns = []
for h1 in H:
c = []
for h2 in H:
c.append(h2.T * invntt * h1)
A_columns.append(BlockColumnOperator(c, axisout=0))
A = BlockRowOperator(A_columns, axisin=0)
b = (self.get_operator()).T * (invntt * tod)
sh = b.shape
if len(sh) == 3:
b = b.reshape((sh[0] * sh[1], sh[2]))
else:
b = b.reshape((sh[0] * sh[1]))
solution = pcg(A, b, disp=verbose, tol=tol, maxiter=maxiter)
if len(sh) == 3:
maps_recon = solution["x"].reshape(sh[0], sh[1], sh[2])
else:
maps_recon = solution["x"].reshape(sh[0], sh[1])
return maps_recon
def tod2map(tod,pointing,instrument_in,detector_list=False,disp=True,kmax=2,displaytime=False):
t0=time.time()
#### Detectors
mask_packed = np.ones(len(instrument_in.detector.packed), bool)
if detector_list:
mask_packed[detector_list] = False
mask_unpacked = instrument_in.unpack(mask_packed)
instrument = QubicInstrument('monochromatic', removed=mask_unpacked,nside=instrument_in.sky.nside)
else:
instrument = instrument_in
#### Observations
obs = QubicAcquisition(instrument, pointing)
projection = obs.get_projection_peak_operator(kmax=kmax)
coverage = projection.pT1()
mask = coverage == 0
projection = pack_projection_inplace(projection, mask)
hwp = obs.get_hwp_operator()
polgrid = DenseOperator([[0.5, 0.5, 0],
[0.5,-0.5, 0]])
H = polgrid * hwp * projection
preconditioner = DiagonalOperator(1/coverage[~mask], broadcast='rightward')
solution = pcg(H.T * H, H.T(tod), M=preconditioner, disp=disp, tol=1e-3)
output_map = unpack(solution['x'], mask)
t1=time.time()
if displaytime: print(' Map done in {0:.4f} seconds'.format(t1-t0))
return output_map,coverage
def reconstruct(Y,nus,sub_nus,bands,sub_deltas,deltas): ################ ### Coverage ### ################ instruments = [QubicInstrument(filter_nu=nus[i]*10**9,detector_nep=4.7e-17*np.sqrt(len(sampling) * sampling.period / (365 * 86400))) for i in range(Nbfreq)] acqs = [QubicAcquisition(instruments[i], sampling, scene) for i in range(Nbfreq)] covlim=0.1 coverage = np.array([acqs[i].get_coverage() for i in range(len(nus))]) observed = [(coverage[i] > covlim*np.max(coverage[i])) for i in range(Nbfreq)] obs=reduce(logical_and,tuple(observed[i] for i in range(Nbfreq))) pack = PackOperator(obs, broadcast='rightward') ###################### ### Reconstruction ### ###################### sub_instruments=[QubicInstrument(filter_nu=sub_nus[i]*10**9,detector_nep=2.7e-17) for i in range(Nbsubfreq)] sub_acqs=[QubicAcquisition(sub_instruments[i], sampling, scene,photon_noise=True, effective_duration=3) for i in range(Nbsubfreq)] sub_acqs_restricted=[sub_acqs[i][:,:,obs] for i in range(Nbsubfreq)] operators=np.array([sub_acqs_restricted[i].get_operator() for i in range(Nbsubfreq)]) K=np.array([np.sum([operators[j]*sub_deltas[j]*10**9 for j in bands[i]],axis=0) for i in range(Nbfreq)]) H=BlockRowOperator([K[i] for i in range(Nbfreq)], new_axisin=0) invntt = acqs[0].get_invntt_operator() A=H.T*invntt*H b = (H.T * invntt)(Y) preconditioner = BlockDiagonalOperator([DiagonalOperator(1 / coverage[0][obs], broadcast='rightward') for i in range(Nbfreq)], new_axisin=0) solution_qubic = pcg(A, b, M=preconditioner ,disp=True, tol=1e-3, maxiter=1000) blockpack = BlockDiagonalOperator([pack for i in range(Nbfreq)], new_axisin=0) maps =blockpack.T(solution_qubic['x']) maps[:,~obs] = 0 return maps
def tod2map(self, tod, tol=1e-5, maxiter=1000, verbose=True):
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(H)
solution = pcg(A, b, M=preconditioner, disp=verbose, tol=tol, maxiter=maxiter)
return solution['x']
def tod2map(self, tod, tol=1e-5, maxiter=1000, verbose=True):
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(H)
solution = pcg(A, b, M=preconditioner, disp=verbose, tol=tol, maxiter=maxiter)
return solution['x']
def tod2map(self, tod, tol=1e-5, maxiter=1000, verbose=True):
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
solution = pcg(A, b, disp=verbose, tol=tol, maxiter=maxiter)
return solution["x"]
def reconstruct(Y,nu_min,nu_max,delta_nu,subdelta_nu,obs,sampling,scene,effective_duration): ################### ### Frequencies ### ################### #frequencies to reconstruct Nbfreq=int(floor(log(nu_max/nu_min)/log(1+delta_nu)))+1 nus=nu_min*np.logspace(0,Nbfreq-1,Nbfreq,endpoint=True,base=delta_nu+1)#edge frequencies of reconstructed bands deltas=(delta_nu)*(nus) #frequencies assumed to have been used for construction of TOD subnu_min=nu_min subnu_max=nu_max Nbsubfreq=int(floor(log(subnu_max/subnu_min)/log(1+subdelta_nu)))+1 sub_nus=subnu_min*np.logspace(0,Nbsubfreq-1,Nbsubfreq,endpoint=True,base=subdelta_nu+1) sub_deltas=(subdelta_nu)*(sub_nus) sub_nus=sub_nus+0.5*sub_deltas #central frequencies #Bands bands=[sub_nus[reduce(logical_and,(sub_nus<=nus[i],sub_nus>=nus[i-1]))] for i in range(Nbfreq)][1:] bands.append(sub_nus[sub_nus>=np.max(nus)]) numbers=np.cumsum(np.array([len(bands[i]) for i in range(Nbfreq)])) numbers=np.append(0,numbers) bands_numbers=np.array([(np.arange(numbers[i-1],numbers[i])) for i in range(Nbfreq+1)])[1:] ################ ### Coverage ### ################ sub_instruments=[QubicInstrument(filter_nu=sub_nus[i]*10**9,detector_nep=2.7e-17) for i in range(Nbsubfreq)] sub_acqs=[QubicAcquisition(sub_instruments[i], sampling, scene,photon_noise=True, effective_duration=effective_duration) for i in range(Nbsubfreq)] covlim=0.1 coverage = np.array([sub_acqs[i].get_coverage() for i in range(Nbsubfreq)]) observed = [(coverage[i] > covlim*np.max(coverage[i])) for i in range(Nbsubfreq)] obs=reduce(logical_and,tuple(observed[i] for i in range(Nbsubfreq))) pack = PackOperator(obs, broadcast='rightward') ###################### ### Reconstruction ### ###################### sub_instruments=[QubicInstrument(filter_nu=sub_nus[i]*10**9,detector_nep=2.7e-17) for i in range(Nbsubfreq)] sub_acqs=[QubicAcquisition(sub_instruments[i], sampling, scene,photon_noise=True, effective_duration=3) for i in range(Nbsubfreq)] sub_acqs_restricted=[sub_acqs[i][:,:,obs] for i in range(Nbsubfreq)] operators=np.array([sub_acqs_restricted[i].get_operator() for i in range(Nbsubfreq)]) K=np.array([np.sum([operators[j]*sub_deltas[j]*10**9 for j in bands_numbers[i]],axis=0) for i in range(Nbfreq)]) H=BlockRowOperator([K[i] for i in range(Nbfreq)], new_axisin=0) invntt = sub_acqs[0].get_invntt_operator() A=H.T*invntt*H b = (H.T * invntt)(Y) preconditioner = BlockDiagonalOperator([DiagonalOperator(1 / coverage[0][obs], broadcast='rightward') for i in range(Nbfreq)], new_axisin=0) solution_qubic = pcg(A, b, M=preconditioner ,disp=True, tol=1e-3, maxiter=1000) blockpack = BlockDiagonalOperator([pack for i in range(Nbfreq)], new_axisin=0) maps =blockpack.T(solution_qubic['x']) maps[:,~obs] = 0 return maps, bands
def tod2map(self, tod, cov=None, tol=1e-5, maxiter=1000, verbose=True):
'''
Reconstruct map from tod
'''
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(cov)
solution = pcg(A, b, M=preconditioner,
disp=verbose, tol=tol, maxiter=maxiter)
return solution['x']
def tod2map(self, tod, cov=None, tol=1e-5, maxiter=1000, verbose=True):
'''
Reconstruct map from tod
'''
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(cov)
solution = pcg(A, b, M=preconditioner,
disp=verbose, tol=tol, maxiter=maxiter)
return solution['x']
def toloop(arguments):
print(arguments)
print('Getting noise')
noise = acq.get_noise()/np.sqrt(real_duration*ndetectors)
print('noise done')
#noise = highpass_tod(noise, ts, 0.05)
y = y_noiseless + noise
b = (H.T * invntt)(y)
solution_qubic = pcg(A, b, M=preconditioner, disp=True, tol=1e-3, maxiter=1000)
maps = pack.T(solution_qubic['x'])
maps[~observed] = 0
x0_convolved[~observed,:]=0
residuals = maps-x0_convolved
pxsize_arcmin2 = 4*pi*(180/pi)**2 / (12*nside**2) * 60**2
sigs= np.std(residuals[observed,:], axis=0)*sqrt(pxsize_arcmin2)
return(sigs)
def test_ls():
H = projection
m = pcg(H.T * invntt * H, (H.T*invntt)(tod), M=M, tol=1e-7)
map_ls_packed = Map(m['x'])
map_ls_packed.header['TIME'] = m['time']
#print('Elapsed time:', map_ls_packed.header['TIME'])
#from tamasis import mapper_ls
#map_ls_packed = mapper_ls(tod, projection, invntt=invntt, tol=1e-7, M=M,
# callback=callback, criterion=False,
# profile=profile)
if profile:
return
print('Elapsed time:', map_ls_packed.header['TIME'])
assert m['nit'] < 50
ref = packing(Map(path + 'madmapSpirePSW.fits'))
assert_allclose(map_ls_packed, ref, atol=1e-5)
def tod2map(self, tod, d):
tol = d['tol']
maxiter = d['maxiter']
verbose = d['verbose']
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(H)
solution = pcg(A,
b,
M=preconditioner,
disp=verbose,
tol=tol,
maxiter=maxiter)
return solution['x']
def TOD2map(tod,pointing,nside,kmax=2,disp=True,P=False,covmin=10):
qubic = QubicInstrument('monochromatic,nopol',nside=nside)
#### configure observation
obs = QubicAcquisition(qubic, pointing)
if not P:
P = obs.get_projection_peak_operator(kmax=kmax)
coverage = P.T(np.ones_like(tod))
mask=coverage < covmin
P.matrix.pack(mask)
P_packed = ProjectionInMemoryOperator(P.matrix)
unpack = UnpackOperator(mask)
# data
solution = pcg(P_packed.T * P_packed, P_packed.T(tod), M=DiagonalOperator(1/coverage[~mask]), disp=disp)
output_map = unpack(solution['x'])
output_map[mask] = np.nan
coverage[mask]=np.nan
return(output_map,mask,coverage)
def tod2map(self, tod, d, cov=None):
tol = d['tol']
maxiter = d['maxiter']
verbose = d['verbose']
p = self.planck
H = []
for q, w in zip(self.qubic, self.weights):
H.append(QubicPlanckAcquisition(q, p).get_operator() * w)
H = np.array(H)
H = [H[(self.qubic.nus > mi) * (self.qubic.nus < ma)].sum() * \
self.weights[(self.qubic.nus > mi) * (self.qubic.nus < ma)].sum() \
for (mi, ma) in self.qubic.bands]
invntt = self.get_invntt_operator()
A_columns = []
for h1 in H:
c = []
for h2 in H:
c.append(h2.T * invntt * h1)
A_columns.append(BlockColumnOperator(c, axisout=0))
A = BlockRowOperator(A_columns, axisin=0)
H = [h.T for h in H]
b = BlockColumnOperator(H, new_axisout=0) * (invntt * tod)
sh = b.shape
if (len(self.qubic.nus) -
1) > 1: # If number of subbands is more than one
if len(sh) == 3:
b = b.reshape((sh[0] * sh[1], sh[2]))
else:
b = b.reshape((sh[0], sh[1]))
preconditioner = self.get_preconditioner(cov)
solution = pcg(A,
b,
M=preconditioner,
disp=verbose,
tol=tol,
maxiter=maxiter)
# solution = pcg(A, b, disp=verbose, tol=tol, maxiter=maxiter)
if len(sh) == 3:
maps_recon = solution['x'].reshape(sh[0], sh[1], sh[2])
else:
maps_recon = solution['x'].reshape(sh[0], sh[1])
return maps_recon
def tod2map(self, tod, d, cov=None):
"""
Reconstruct map from tod
"""
tol = d['tol']
maxiter = d['maxiter']
verbose = d['verbose']
H = self.get_operator()
invntt = self.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(cov)
solution = pcg(A,
b,
M=preconditioner,
disp=verbose,
tol=tol,
maxiter=maxiter)
return solution['x'], solution['nit'], solution['error']
def tod2map(self, tod, cov=None, tol=1e-5, maxiter=1000, verbose=True):
p = self.planck
H = []
for q, w in zip(self.qubic, self.weights):
H.append(QubicPlanckAcquisition(q, p).get_operator() * w)
H = np.array(H)
H = [H[(self.qubic.nus > mi) * (self.qubic.nus < ma)].sum() * \
self.weights[(self.qubic.nus > mi) * (self.qubic.nus < ma)].sum() \
for (mi, ma) in self.qubic.bands]
invntt = self.get_invntt_operator()
A_columns = []
for h1 in H:
c = []
for h2 in H:
c.append(h2.T * invntt * h1)
A_columns.append(BlockColumnOperator(c, axisout=0))
A = BlockRowOperator(A_columns, axisin=0)
H = [h.T for h in H]
b = BlockColumnOperator(H, new_axisout=0) * (invntt * tod)
sh = b.shape
if len(self.qubic.nus) - 1 > 1: # If number of subbands is more than one
if len(sh) == 3:
b = b.reshape((sh[0] * sh[1], sh[2]))
else:
b = b.reshape((sh[0] * sh[1]))
preconditioner = self.get_preconditioner(cov)
solution = pcg(A, b, M=preconditioner, disp=verbose, tol=tol, maxiter=maxiter)
# solution = pcg(A, b, disp=verbose, tol=tol, maxiter=maxiter)
if len(sh) == 3:
maps_recon = solution['x'].reshape(sh[0], sh[1], sh[2])
else:
maps_recon = solution['x'].reshape(sh[0], sh[1])
return maps_recon
def tod2map(self, tod, d):
'''
Reconstruct map from tod
'''
tol = d['tol']
maxiter = d['maxiter']
cov = d['cov']
verbose = d['verbose']
sampling = self[0].sampling
H = self.get_operator()
invntt = self.get_invntt_operator(d)
A = H.T * invntt * H
b = H.T * invntt * tod
preconditioner = self.get_preconditioner(cov)
solution = pcg(A,
b,
M=preconditioner,
disp=verbose,
tol=tol,
maxiter=maxiter)
return solution['x']
input_map = np.zeros((hp.nside2npix(nside), 3))
acq_planck = PlanckAcquisition(band, acq_qubic.scene, true_sky=input_map)
acq_fusion = QubicPlanckAcquisition(acq_qubic, acq_planck)
obs_noiseless = acq_fusion.get_observation(noiseless=True)
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
A = H.T * invntt * H
for realization in xrange(nrealizations):
print 'rank={}: realization {} / {}'.format(rank, realization + 1, nrealizations)
obs = obs_noiseless + acq_fusion.get_noise()
b = H.T * invntt * obs
solution = pcg(A, b, disp=True, maxiter=maxiter)
rec_map = solution['x']
if rank == 0:
file_name = 'angspeed{}_delta_az{}_realization{}.fits'.format(angspeed,
delta_az,
realization)
with open(directory + '/rec_map_' + file_name, 'w') as f:
write_map(f, rec_map, mask=coverage>0.)
# release the pointing matrix
del H, A
gc.collect()
print rank, 'got here'
print('finished')
coverage = H.T(np.ones(H.shapeout))
mask = coverage > 0
# restrict the scene to the observed pixels
acq_restricted = acq[..., mask]
H_restricted = acq_restricted.get_operator()
x0_restricted = x0[mask]
y = H_restricted(x0_restricted)
invntt = acq_restricted.get_invntt_operator()
# solve for x
A = H_restricted.T * invntt * H_restricted
b = H_restricted.T(invntt(y))
solution = pcg(A,
b,
M=DiagonalOperator(1 / coverage[mask]),
disp=True,
tol=1e-4)
x = np.zeros_like(x0)
x[mask] = solution['x']
# some display
def display(x, title, lim=200):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x,
rot=center_gal,
reso=5,
xsize=600,
min=-lim,
for i in xrange(len(all_instruments)):
acq_qubic = QubicAcquisition(150, sampling, nside=nside,
detector_nep=detector_nep[i])
all_coverages.append(acq_qubic.get_coverage())
convolved_sky = acq_qubic.instrument.get_convolution_peak_operator()(sky)
acq_planck = PlanckAcquisition(150, acq_qubic.scene, true_sky=convolved_sky)
acq_fusion = QubicPlanckAcquisition(acq_qubic, acq_planck)
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
obs = acq_fusion.get_observation()
A = H.T * invntt * H
b = H.T * invntt * obs
solution_fusion = pcg(A, b, disp=True)
all_solutions_fusion.append(solution_fusion)
mask = all_coverages[0] > np.max(all_coverages[0]/10)
reso=3
Trange=[10, 10, 10]
for i in xrange(len(nbptg)):
figure(i)
resid = all_solutions_fusion[i]['x'] - convolved_sky
resid[~mask,:] = 0
display(resid, 'Difference map', iplot=7, reso=reso, Trange=Trange)
def _tod2map(acq, tod, coverage_threshold, max_nbytes, callback, disp_pcg,
maxiter, tol, criterion, full_output, save_map, hyper):
# coverage normalization:
# sum coverage = #detectors x #samplings for a uniform secondary beam
H = acq.get_operator()
coverage = H.T(ones(H.shapeout))
if acq.scene.kind == 'IQU':
coverage = coverage[..., 0]
elif acq.scene.kind == 'QU':
raise NotImplementedError()
theta, phi = acq.instrument.detector.theta, acq.instrument.detector.phi
ndetectors = acq.instrument.detector.comm.allreduce(
np.sum(acq.instrument.secondary_beam(theta, phi)))
nsamplings = acq.sampling.comm.allreduce(len(acq.sampling))
coverage *= ndetectors * nsamplings / np.sum(coverage)
cov = coverage[coverage > 0]
i = np.argsort(cov)
cdf = np.cumsum(cov[i])
j = np.argmax(cdf >= coverage_threshold * cdf[-1])
threshold = cov[i[j]]
mask = coverage >= threshold
rejected = 1 - np.sum(mask) / cov.size
if acq.comm.rank == 0 and coverage_threshold > 0:
print('Total coverage:', cdf[-1])
print('Threshold coverage set to:', threshold)
print('Fraction of rejected observed pixels:', rejected)
header = OrderedDict()
coverage = coverage.view(ndarraywrap)
coverage.header = header
header['thresrel'] = coverage_threshold, 'Relative coverage threshold'
header['thresabs'] = threshold, 'Absolute coverage threshold'
header['fracrej'] = rejected, 'Fraction of rejected observed pixels'
acq_restricted = acq[..., mask]
H = acq_restricted.get_operator()
invNtt = acq_restricted.get_invntt_operator()
M = (H.T * H * np.ones(H.shapein))[..., 0]
preconditioner = DiagonalOperator(1 / M, broadcast='rightward')
# preconditioner = DiagonalOperator(1/coverage[mask], broadcast='rightward')
nsamplings = acq.comm.allreduce(len(acq.sampling))
npixels = np.sum(mask)
A = H.T * invNtt * H / nsamplings
if hyper != 0:
L = HealpixLaplacianOperator(acq.scene.nside)
L = L.restrict(mask, inplace=True).corestrict(mask, inplace=True)
A = A - hyper / npixels / 4e5 * L
if criterion:
def f(x):
Hx_y = H(x)
Hx_y -= tod
out = [np.dot(Hx_y.ravel(), invNtt(Hx_y).ravel()) / nsamplings]
if hyper != 0:
out += [
-np.dot(x.ravel(), hyper / npixels / 4e5 * L(x).ravel())
]
else:
out += [0.]
return out
def callback(self):
criteria = f(self.x)
if len(criteria) == 1:
details = ''
else:
fmt = ', '.join(len(criteria) * ['{:e}'])
details = ' (' + fmt.format(*criteria) + ')'
print('{:4}: {:e} {:e}{}'.format(self.niterations, self.error,
sum(criteria), details))
if not hasattr(self, 'history'):
self.history = {}
self.history['criterion'] = []
self.history['error'] = []
self.history['iteration'] = []
self.history['criterion'].append(criteria)
self.history['error'].append(self.error)
self.history['iteration'].append(self.niterations)
if save_map is not None and self.niterations in save_map:
if not hasattr(self, 'xs'):
self.xs = {}
self.xs[self.niterations] = self.x.copy()
solution = pcg(A,
H.T(invNtt(tod)) / nsamplings,
M=preconditioner,
callback=callback,
disp=disp_pcg,
maxiter=maxiter,
tol=tol)
output = acq_restricted.scene.unpack(solution['x']), coverage
if full_output:
algo = solution['algorithm']
algo.H = H
if criterion:
pack = PackOperator(mask, broadcast='rightward')
algo.f = asoperator(f, shapeout=2)(pack)
output += (algo, )
return output
def reconstruction(
racenter, deccenter, NPOINTS, NFREQS, filter_name, scene,
maxiter, tol, rank, n, start):
sampling = create_random_pointings([racenter, deccenter], 1000, 10)
detector_nep = 4.7e-17 * np.sqrt(
len(sampling) * sampling.period / (365 * 86400))
#x0 = read_map(PATH + 'syn256_pol.fits')
x0 = np.zeros((12*nside**2, 3))
q = MultiQubicInstrument(
NPOINTS=NPOINTS, NFREQS=NFREQS, filter_name=filter_name,
detector_nep=detector_nep)
C_nf = q.get_convolution_peak_operator()
conv_sky_ = C_nf(x0)
fwhm_t = np.sqrt(q.synthbeam.peak150.fwhm**2 - C_nf.fwhm**2)
C_transf = HealpixConvolutionGaussianOperator(fwhm=fwhm_t)
acq = MultiQubicAcquisition(q, sampling, scene=scene)
H = acq.get_operator()
coverage = acq.get_coverage(H)
acq_planck = MultiPlanckAcquisition(
np.int(filter_name/1e9), scene, true_sky=conv_sky_)
acq_fusion = QubicPlanckAcquisition(acq, acq_planck)
H = acq_fusion.get_operator()
y = acq_fusion.get_observation()
invntt = acq_fusion.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * y
solution_fusion = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
x_rec_fusion_ = solution_fusion['x']
x_rec_fusion = C_transf(x_rec_fusion_)
#H = acq.get_operator()
#COV = acq.get_coverage(H)
#y = acq.get_observation(conv_sky_)
#invntt = acq.get_invntt_operator()
# A = H.T * invntt * H
# b = H.T * invntt * y
# solution_qubic = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
# x_rec_qubic_ = solution_qubic['x']
# x_rec_qubic = C_transf(x_rec_qubic_)
# conv_sky = C_transf(conv_sky_)
path = '/home/fincardona/Qubic/map_making/maps/montecarlo'
if rank==0:
hp.write_map('%s/fusion_n{}_N{}_s{}_mi{}_niter{}.fits'.format(
NFREQS, NPOINTS, len(sampling), maxiter, n+start) % path,
x_rec_fusion.T)
#hp.write_map('maps_test/qubic_n{}_N{}_s{}_mi{}.fits'.format(
# NFREQS, NPOINTS, len(sampling), maxiter), x_rec_qubic.T)
gc.collect()
return coverage, sampling, path
#### configure observation obs = QubicConfiguration(qubic, pointings) C = obs.get_convolution_peak_operator() P = obs.get_projection_peak_operator(kmax=kmax) H = P * C # Produce the Time-Ordered data tod = H(input_map) # map-making coverage = P.T(np.ones_like(tod)) mask = coverage < 10 P.matrix.pack(mask) P_packed = ProjectionInMemoryOperator(P.matrix) unpack = UnpackOperator(mask) solution = pcg(P_packed.T * P_packed, P_packed.T(tod), M=DiagonalOperator(1/coverage[~mask]), disp=True) output_map = unpack(solution['x']) # some display output_map[mask] = np.nan hp.gnomview(input_map, rot=[0,90], reso=0.3, xsize=600,title='Input Map') hp.gnomview(output_map, rot=[0,90], reso=0.3, xsize=600,title='Output Map') # get theta iprings=np.arange(12*nside**2) vecs=hp.pix2vec(int(nside),iprings[~mask]) vec0=hp.pix2vec(int(nside),0) angles=np.arccos(np.dot(np.transpose(vec0),vecs)) themap=output_map[~mask] clf() plot(angles*180/np.pi,themap,'b.')
sampling = create_random_pointings([racenter, deccenter], 1000, 10)
scene = QubicScene(nside)
acq_qubic = QubicAcquisition(150, sampling, scene, effective_duration=1)
convolved_sky = acq_qubic.instrument.get_convolution_peak_operator()(sky)
acq_planck = PlanckAcquisition(150, acq_qubic.scene, true_sky=convolved_sky)
acq_fusion = QubicPlanckAcquisition(acq_qubic, acq_planck)
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
y = acq_fusion.get_observation()
A = H.T * invntt * H
b = H.T * invntt * y
solution_fusion = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
acq_qubic = QubicAcquisition(150, sampling, scene, effective_duration=1)
H = acq_qubic.get_operator()
invntt = acq_qubic.get_invntt_operator()
y, sky_convolved = acq_qubic.get_observation(sky, convolution=True)
A = H.T * invntt * H
b = H.T * invntt * y
solution_qubic = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
# some display
def display(input, msg, iplot=1):
out = []
coverage = acq.get_coverage()
observed = coverage > covlim * np.max(coverage)
acq_restricted = acq[:, :, observed]
H = acq_restricted.get_operator()
x0_convolved = C(input_maps)
pack = PackOperator(observed, broadcast='rightward')
y_noiseless = H(pack(x0_convolved))
invntt = acq.get_invntt_operator()
A = H.T * invntt * H
preconditioner = DiagonalOperator(1 / coverage[observed], broadcast='rightward')
for nn in xrange(nbmc):
noise = acq.get_noise()/np.sqrt(real_duration*ndetectors)
y = y_noiseless + noise
b = (H.T * invntt)(y)
solution_qubic = pcg(A, b, M=preconditioner, disp=True, tol=1e-3, maxiter=1000)
maps = pack.T(solution_qubic['x'])
maps[~observed] = 0
x0_convolved[~observed,:]=0
residuals = maps-x0_convolved
freq, ps = powspec_inst(ts, y_noiseless+noise)
pxsize_arcmin2 = 4*pi*(180/pi)**2 / (12*nside**2) * 60**2
sigs= np.std(residuals[observed,:], axis=0)*sqrt(pxsize_arcmin2)
print(s, f, nn, sigs)
allsigs[i,j,nn,:] = sigs
clf()
subplot(2,1,1)
detector_nep = 4.7e-17/np.sqrt(365*86400 / len(sampling)*sampling.period)
acq_qubic = QubicAcquisition(150, sampling, nside=nside,
detector_nep=detector_nep)
convolved_sky = acq_qubic.instrument.get_convolution_peak_operator()(sky)
acq_planck = PlanckAcquisition(150, acq_qubic.scene, true_sky=convolved_sky)
acq_fusion = QubicPlanckAcquisition(acq_qubic, acq_planck)
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
obs = acq_fusion.get_observation()
A = H.T * invntt * H
b = H.T * invntt * obs
solution_fusion = pcg(A, b, disp=True)
H = acq_qubic.get_operator()
invntt = acq_qubic.get_invntt_operator()
obs, sky_convolved = acq_qubic.get_observation(sky, convolution=True)
A = H.T * invntt * H
b = H.T * invntt * obs
solution_qubic = pcg(A, b, disp=True)
# some display
detector_nep = 4.7e-17/np.sqrt(365*86400 / len(sampling)*sampling.period)/fact[i]
acq_qubic = QubicAcquisition(150, sampling, nside=nside,
detector_nep=detector_nep)
convolved_sky = acq_qubic.instrument.get_convolution_peak_operator()(sky)
acq_planck = PlanckAcquisition(150, acq_qubic.scene, true_sky=convolved_sky)
acq_fusion = QubicPlanckAcquisition(acq_qubic, acq_planck)
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
obs = acq_fusion.get_observation()
A = H.T * invntt * H
b = H.T * invntt * obs
solution_fusion = pcg(A, b, disp=True, maxiter=1000000, tol=1e-5)
sols.append(solution_fusion)
# some display
center = equ2gal(racenter, deccenter)
def display(input, msg, iplot=1, reso=5, Trange=[100, 5, 5], xsize=800, subx=3, suby=3):
out = []
for i, (kind, lim) in enumerate(zip('IQU', Trange)):
map = input[..., i]
out += [hp.gnomview(map, rot=center, reso=reso, xsize=xsize, min=-lim,
max=lim, title=msg + ' ' + kind,
sub=(suby, subx, iplot + i), return_projected_map=True)]
return out
tod = H(input_map)
tods[kind] = tod
pTxs[kind] = H.T(tod)[coverage > 0]
if kind != 'QU':
pTx_pT1 = P.pTx_pT1(tod)
pTx_pT1s[kind] = pTx_pT1[0][coverage > 0], pTx_pT1[1][coverage > 0]
cbik = P.canonical_basis_in_kernel()
mask = coverage > 10
P = P.restrict(mask, inplace=True)
unpack = UnpackOperator(mask, broadcast='rightward')
x0 = unpack.T(input_map)
M = DiagonalOperator(1 / coverage[mask], broadcast='rightward')
H = W * P
solution = pcg(H.T * H, H.T(tod), M=M, disp=True, tol=1e-5)
pT1s[kind] = coverage
cbiks[kind] = cbik
outputs[kind] = solution['x']
def test_sky():
assert_same(tods['I'], tods['IQU'][..., 0].astype(np.float32))
assert_same(tods['QU'], tods['IQU'][..., 1:].astype(np.float32))
assert_same(pTxs['I'], pTxs['IQU'][..., 0].astype(np.float32))
assert_same(pTxs['QU'], pTxs['IQU'][..., 1:].astype(np.float32))
assert_same(pTx_pT1s['I'][0], pTx_pT1s['IQU'][0].astype(np.float32))
assert_same(pTx_pT1s['I'][1], pTx_pT1s['IQU'][1].astype(np.float32))
def reconstruction(racenter, deccenter, NPOINTS, NFREQS, filter_name, scene,
maxiter, tol, rank, n, start):
sampling = create_random_pointings([racenter, deccenter], 1000, 10)
detector_nep = 4.7e-17 * np.sqrt(
len(sampling) * sampling.period / (365 * 86400))
#x0 = read_map(PATH + 'syn256_pol.fits')
x0 = np.zeros((12 * nside**2, 3))
q = MultiQubicInstrument(NPOINTS=NPOINTS,
NFREQS=NFREQS,
filter_name=filter_name,
detector_nep=detector_nep)
C_nf = q.get_convolution_peak_operator()
conv_sky_ = C_nf(x0)
fwhm_t = np.sqrt(q.synthbeam.peak150.fwhm**2 - C_nf.fwhm**2)
C_transf = HealpixConvolutionGaussianOperator(fwhm=fwhm_t)
acq = MultiQubicAcquisition(q, sampling, scene=scene)
H = acq.get_operator()
coverage = acq.get_coverage(H)
acq_planck = MultiPlanckAcquisition(np.int(filter_name / 1e9),
scene,
true_sky=conv_sky_)
acq_fusion = QubicPlanckAcquisition(acq, acq_planck)
H = acq_fusion.get_operator()
y = acq_fusion.get_observation()
invntt = acq_fusion.get_invntt_operator()
A = H.T * invntt * H
b = H.T * invntt * y
solution_fusion = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
x_rec_fusion_ = solution_fusion['x']
x_rec_fusion = C_transf(x_rec_fusion_)
#H = acq.get_operator()
#COV = acq.get_coverage(H)
#y = acq.get_observation(conv_sky_)
#invntt = acq.get_invntt_operator()
# A = H.T * invntt * H
# b = H.T * invntt * y
# solution_qubic = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
# x_rec_qubic_ = solution_qubic['x']
# x_rec_qubic = C_transf(x_rec_qubic_)
# conv_sky = C_transf(conv_sky_)
path = '/home/fincardona/Qubic/map_making/maps/montecarlo'
if rank == 0:
hp.write_map(
'%s/fusion_n{}_N{}_s{}_mi{}_niter{}.fits'.format(
NFREQS, NPOINTS, len(sampling), maxiter, n + start) % path,
x_rec_fusion.T)
#hp.write_map('maps_test/qubic_n{}_N{}_s{}_mi{}.fits'.format(
# NFREQS, NPOINTS, len(sampling), maxiter), x_rec_qubic.T)
gc.collect()
return coverage, sampling, path
y = H(x0)
# noise
psd = _gaussian_psd_1f(len(acq.sampling), sigma=sigma, fknee=fknee,
fslope=fslope, sampling_frequency=1/ts)
invntt = acq.get_invntt_operator()
noise = acq.get_noise()
# map-making
coverage = P.pT1()
mask = coverage > 10
P = P.restrict(mask, inplace=True)
unpack = UnpackOperator(mask)
# map without covariance matrix
solution1 = pcg(P.T * P, P.T(y + noise),
M=DiagonalOperator(1/coverage[mask]), disp=True)
x1 = unpack(solution1['x'])
# map with covariance matrix
solution2 = pcg(P.T * invntt * P, (P.T * invntt)(y + noise),
M=DiagonalOperator(1/coverage[mask]), disp=True)
x2 = unpack(solution2['x'])
def display(x, title):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x, rot=center, reso=5, xsize=600, min=-200, max=200,
title=title)
center = equ2gal(racenter, deccenter)
x0_convolved = acq.get_convolution_peak_operator()(x0)
H = acq.get_operator()
coverage = H.T(np.ones(H.shapeout))
mask = coverage > 0
# restrict the scene to the observed pixels
acq_restricted = acq[..., mask]
H_restricted = acq_restricted.get_operator()
x0_restricted = x0[mask]
y = H_restricted(x0_restricted)
invntt = acq_restricted.get_invntt_operator()
# solve for x
A = H_restricted.T * invntt * H_restricted
b = H_restricted.T(invntt(y))
solution = pcg(
A, b, M=DiagonalOperator(1/coverage[mask]), disp=True, tol=1e-4)
x = np.zeros_like(x0)
x[mask] = solution['x']
# some display
def display(x, title, lim=200):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x, rot=center_gal, reso=5, xsize=600, min=-lim, max=lim,
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)')
clf()
xn,yn,dxn,dyn=pyquad.profile(ang.flatten(),cormc.flatten(),0.001,50,200,plot=True,dispersion=False)
clf()
imshow(abs(cormc),interpolation='nearest',vmin=0,vmax=0.2)
title('Map Correlation Matrix')
colorbar()
clf()
errorbar(xn,yn,xerr=dxn,yerr=dyn,fmt='bo')
from Homogeneity import SplineFitting
spl=SplineFitting.MySplineFitting(xn,yn,dyn,100)
#plot(xn,spl(xn),'r',lw=3)
plot(xn,xn*0,'k--')
ylabel('Noise Correlation Matrix')
xlabel('Angle [degrees]')
sol2 = pcg(P_packed.T * P_packed, P_packed.T(tod*0+1), M=DiagonalOperator(1/coverage[~mask]), disp=True)
errmap = unpack(sol2['x'])
hp.gnomview(errmap,rot=[0,90],reso=14)
mm=np.zeros(12*nside**2)
mm[maskok]=sqrt(diag(covmc))
hp.gnomview(mm,rot=[0,90],reso=14)
def _tod2map(acq, tod, coverage_threshold, max_nbytes, callback,
disp_pcg, maxiter, tol, criterion, full_output, save_map, hyper):
# coverage normalization:
# sum coverage = #detectors x #samplings for a uniform secondary beam
H = acq.get_operator()
coverage = H.T(ones(H.shapeout))
if acq.scene.kind == 'IQU':
coverage = coverage[..., 0]
elif acq.scene.kind == 'QU':
raise NotImplementedError()
theta, phi = acq.instrument.detector.theta, acq.instrument.detector.phi
ndetectors = acq.instrument.detector.comm.allreduce(
np.sum(acq.instrument.secondary_beam(theta, phi)))
nsamplings = acq.sampling.comm.allreduce(len(acq.sampling))
coverage *= ndetectors * nsamplings / np.sum(coverage)
cov = coverage[coverage > 0]
i = np.argsort(cov)
cdf = np.cumsum(cov[i])
j = np.argmax(cdf >= coverage_threshold * cdf[-1])
threshold = cov[i[j]]
mask = coverage >= threshold
rejected = 1 - np.sum(mask) / cov.size
if acq.comm.rank == 0 and coverage_threshold > 0:
print('Total coverage:', cdf[-1])
print('Threshold coverage set to:', threshold)
print('Fraction of rejected observed pixels:', rejected)
header = OrderedDict()
coverage = coverage.view(ndarraywrap)
coverage.header = header
header['thresrel'] = coverage_threshold, 'Relative coverage threshold'
header['thresabs'] = threshold, 'Absolute coverage threshold'
header['fracrej'] = rejected, 'Fraction of rejected observed pixels'
acq_restricted = acq[..., mask]
H = acq_restricted.get_operator()
invNtt = acq_restricted.get_invntt_operator()
M = (H.T * H * np.ones(H.shapein))[..., 0]
preconditioner = DiagonalOperator(1/M, broadcast='rightward')
# preconditioner = DiagonalOperator(1/coverage[mask], broadcast='rightward')
nsamplings = acq.comm.allreduce(len(acq.sampling))
npixels = np.sum(mask)
A = H.T * invNtt * H / nsamplings
if hyper != 0:
L = HealpixLaplacianOperator(acq.scene.nside)
L = L.restrict(mask, inplace=True).corestrict(mask, inplace=True)
A = A - hyper / npixels / 4e5 * L
if criterion:
def f(x):
Hx_y = H(x)
Hx_y -= tod
out = [np.dot(Hx_y.ravel(), invNtt(Hx_y).ravel()) / nsamplings]
if hyper != 0:
out += [-np.dot(x.ravel(),
hyper / npixels / 4e5 * L(x).ravel())]
else:
out += [0.]
return out
def callback(self):
criteria = f(self.x)
if len(criteria) == 1:
details = ''
else:
fmt = ', '.join(len(criteria) * ['{:e}'])
details = ' (' + fmt.format(*criteria) + ')'
print('{:4}: {:e} {:e}{}'.format(self.niterations, self.error,
sum(criteria), details))
if not hasattr(self, 'history'):
self.history = {}
self.history['criterion'] = []
self.history['error'] = []
self.history['iteration'] = []
self.history['criterion'].append(criteria)
self.history['error'].append(self.error)
self.history['iteration'].append(self.niterations)
if save_map is not None and self.niterations in save_map:
if not hasattr(self, 'xs'):
self.xs = {}
self.xs[self.niterations] = self.x.copy()
solution = pcg(A, H.T(invNtt(tod)) / nsamplings, M=preconditioner,
callback=callback, disp=disp_pcg, maxiter=maxiter, tol=tol)
output = acq_restricted.scene.unpack(solution['x']), coverage
if full_output:
algo = solution['algorithm']
algo.H = H
if criterion:
pack = PackOperator(mask, broadcast='rightward')
algo.f = asoperator(f, shapeout=2)(pack)
output += (algo,)
return output
# noise
sigma = acq.instrument.detector.nep / np.sqrt(2 * sampling.period)
psd = _gaussian_psd_1f(len(acq.sampling), sigma=sigma, fknee=fknee,
fslope=fslope, sampling_frequency=1/ts)
invntt = acq.get_invntt_operator()
noise = acq.get_noise()
noise[...] = 0
# map-making
coverage = acq.get_coverage()
mask = coverage / coverage.max() > 0.01
acq_red = acq[..., mask]
H_ga_red = acq_red.get_operator()
# map without covariance matrix
solution1 = pcg(H_ga_red.T * H_ga_red, H_ga_red.T(y + noise),
M=DiagonalOperator(1/coverage[mask]), disp=True)
x1 = acq_red.scene.unpack(solution1['x'])
# map with covariance matrix
solution2 = pcg(H_ga_red.T * invntt * H_ga_red,
(H_ga_red.T * invntt)(y + noise),
M=DiagonalOperator(1/coverage[mask]), disp=True)
x2 = acq_red.scene.unpack(solution2['x'])
def display(x, title, min=None, max=None):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x, rot=center, reso=5, xsize=600, min=min, max=max,
title=title)
fknee=fknee,
fslope=fslope,
sampling_frequency=1 / ts)
invntt = acq.get_invntt_operator()
noise = acq.get_noise()
noise[...] = 0
# map-making
coverage = acq.get_coverage()
mask = coverage / coverage.max() > 0.01
acq_red = acq[..., mask]
H_ga_red = acq_red.get_operator()
# map without covariance matrix
solution1 = pcg(H_ga_red.T * H_ga_red,
H_ga_red.T(y + noise),
M=DiagonalOperator(1 / coverage[mask]),
disp=True)
x1 = acq_red.scene.unpack(solution1['x'])
# map with covariance matrix
solution2 = pcg(H_ga_red.T * invntt * H_ga_red,
(H_ga_red.T * invntt)(y + noise),
M=DiagonalOperator(1 / coverage[mask]),
disp=True)
x2 = acq_red.scene.unpack(solution2['x'])
def display(x, title, min=None, max=None):
x = x.copy()
x[~mask] = np.nan
hp.gnomview(x,
def reconstruct(Y,nu_min,nu_max,delta_nu,subdelta_nu,sampling,scene,effective_duration, verbose=True,return_mono=False, photon_noise=True):
###################
### Frequencies ###
###################
#frequencies to reconstruct
Nbfreq=int(floor(log(nu_max/nu_min)/log(1+delta_nu)))+1 ## number of edge frequencies
nus_edge=nu_min*np.logspace(0,log(nu_max/nu_min)/log(1+delta_nu),Nbfreq,endpoint=True,base=delta_nu+1) #edge frequencies of reconstructed bands
nus=np.array([(nus_edge[i]+nus_edge[i-1])/2 for i in range(1,Nbfreq)])
deltas=(delta_nu)*(nus)
deltas=np.array([(nus_edge[i]-nus_edge[i-1]) for i in range(1,Nbfreq)])
Nbbands=len(nus)
#frequencies assumed to have been used for construction of TOD
subnu_min=nu_min
subnu_max=nu_max
Nbsubfreq=int(floor(log(subnu_max/subnu_min)/log(1+subdelta_nu)))+1
sub_nus_edge=subnu_min*np.logspace(0,log(subnu_max/subnu_min)/log(1+subdelta_nu),Nbsubfreq,endpoint=True,base=subdelta_nu+1)
sub_nus=np.array([(sub_nus_edge[i]+sub_nus_edge[i-1])/2 for i in range(1,Nbsubfreq)])
sub_deltas=np.array([(sub_nus_edge[i]-sub_nus_edge[i-1]) for i in range(1,Nbsubfreq)])
Nbsubbands=len(sub_nus)
#Bands
bands=[sub_nus[reduce(logical_and,(sub_nus<=nus_edge[i+1],sub_nus>=nus_edge[i]))] for i in range(Nbbands)]
numbers=np.cumsum(np.array([len(bands[i]) for i in range(Nbbands)]))
numbers=np.append(0,numbers)
bands_numbers=np.array([(np.arange(numbers[i],numbers[i+1])) for i in range(Nbbands)])
if verbose:
print('Nombre de bandes utilisées pour la reconstruction : '+str(Nbsubbands))
print('Nombre de bandes reconstruites : '+str(Nbbands))
print('Résolution spectrale : '+str(delta_nu))
print ('Bandes reconstruites : ' + str(bands))
################
### Coverage ###
################
sub_instruments=[QubicInstrument(filter_nu=sub_nus[i]*10**9,filter_relative_bandwidth=sub_deltas[i]/sub_nus[i],detector_nep=2.7e-17) for i in range(Nbsubbands)]
sub_acqs=[QubicAcquisition(sub_instruments[i], sampling, scene,photon_noise=photon_noise, effective_duration=effective_duration) for i in range(Nbsubbands)]
covlim=0.1
coverage = np.array([sub_acqs[i].get_coverage() for i in range(Nbsubbands)])
observed = [(coverage[i] > covlim*np.max(coverage[i])) for i in range(Nbsubbands)]
obs=reduce(logical_and,tuple(observed[i] for i in range(Nbsubbands)))
pack = PackOperator(obs, broadcast='rightward')
######################
### Reconstruction ###
######################
sub_acqs_restricted=[sub_acqs[i][:,:,obs] for i in range(Nbsubbands)]
operators=np.array([sub_acqs_restricted[i].get_operator() for i in range(Nbsubbands)])
K=np.array([np.sum([operators[j] for j in bands_numbers[i]],axis=0) for i in range(Nbbands)])
H=BlockRowOperator([K[i] for i in range(Nbbands)], new_axisin=0)
invntt = sub_acqs[0].get_invntt_operator()
A=H.T*invntt*H
b = (H.T * invntt)(Y)
preconditioner = BlockDiagonalOperator([DiagonalOperator(1 / coverage[0][obs], broadcast='rightward') for i in range(Nbbands)], new_axisin=0)
solution_qubic = pcg(A, b, M=preconditioner ,disp=True, tol=1e-3, maxiter=1000)
blockpack = BlockDiagonalOperator([pack for i in range(Nbbands)], new_axisin=0)
maps =blockpack.T(solution_qubic['x'])
if Nbbands==1:
sh=np.shape(maps)
maps=maps.reshape((1,sh[0],sh[1]))
maps[:,~obs] = 0
#################
### Input map ###
#################
# x0=np.zeros((Nbsubbands,Nbpixels,3))
# for i in range(Nbsubbands):
# #x0[i,:,0]=cmb.T[0]+dust.T[0]*scaling_dust(150,sub_nus[i]e-9,1.59)
# x0[i,:,1]=cmb.T[1]+dust.T[1]*scaling_dust(150,sub_nus[i],1.59)
# x0[i,:,2]=cmb.T[2]+dust.T[2]*scaling_dust(150,sub_nus[i],1.59)
# maps_mono=np.zeros((Nbbands,Nbpixels,3))
# if return_mono:
# (m,n)=shape(Y)
# Y_mono=np.zeros((Nbbands,m,n))
# for i in range(Nbbands):
# for j in bands_numbers[i]:
# C=HealpixConvolutionGaussianOperator(fwhm=sub_instruments[j].synthbeam.peak150.fwhm * (150 / (sub_nus[j])))
# Y_mono[i]=Y_mono[i]+operators[j]*pack*C*x0[j]
# Global_instrument=QubicInstrument(filter_nu=nus[i],filter_relative_bandwidth=deltas[i]/nus[i],detector_nep=2.7e-17)
# Global_acquisition=QubicAcquisition(Global_instrument, sampling, scene,photon_noise=photon_noise, effective_duration=effective_duration)
# noise=Global_acquisition.get_noise()
# Y_mono[i]=Y_mono[i]+noise
# H_mono=np.sum([operators[j] for j in bands_numbers[i]],axis=0)
# A_mono=H_mono.T*invntt*H_mono
# b_mono = (H_mono.T * invntt)(Y_mono[i])
# preconditioner_mono = DiagonalOperator(1 / coverage[0][obs], broadcast='rightward')
# solution_qubic_mono = pcg(A_mono, b_mono, M=preconditioner_mono ,disp=True, tol=1e-3, maxiter=1000)
# maps_mono[i] =pack.T(solution_qubic_mono['x'])
# maps_mono[i,~obs] = 0
# return maps, maps_mono, bands, deltas
return maps, bands, deltas
cov = acq_qubic.get_coverage()
mask = cov < cov.max() * 0.2
acq_planck = PlanckAcquisition(150,
acq_qubic.scene,
true_sky=convolved_sky,
mask=mask)
acq_fusion = QubicPlanckAcquisition(acq_qubic, acq_planck)
H = acq_fusion.get_operator()
invntt = acq_fusion.get_invntt_operator()
y = acq_fusion.get_observation()
A = H.T * invntt * H
b = H.T * invntt * y
solution_fusion = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
acq_qubic = QubicAcquisition(150, sampling, scene, effective_duration=1)
H = acq_qubic.get_operator()
invntt = acq_qubic.get_invntt_operator()
y, sky_convolved = acq_qubic.get_observation(sky, convolution=True)
A = H.T * invntt * H
b = H.T * invntt * y
solution_qubic = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
# some display
def display(input, msg, iplot=1):
out = []
