def get_coverage_onedet(idetector=231, angspeed=1., delta_az=15., angspeed_psi=0., maxpsi=15., nsweeps_el=100, duration=24, ts=1., decrange=2., decspeed=2., recenter=False):
print('##### Getting Coverage for: ')
print('## idetector = '+str(idetector))
print('## duration = '+str(duration))
print('## ts = '+str(ts))
print('## recenter = '+str(recenter))
print('## angspeed = '+str(angspeed))
print('## delta_az = '+str(delta_az))
print('## nsweeps_el = '+str(nsweeps_el))
print('## decrange = '+str(decrange))
print('## decspeed = '+str(decspeed))
print('## angspeed_psi = '+str(angspeed_psi))
print('## maxpsi = '+str(maxpsi))
print('##########################')
nside = 256
racenter = 0.0
deccenter = -57.0
pointing = pointings_modbyJC.create_sweeping_pointings(
[racenter, deccenter], duration, ts, angspeed, delta_az, nsweeps_el,
angspeed_psi, maxpsi, decrange=decrange, decspeed=decspeed, recenter=recenter)
pointing.angle_hwp = np.random.random_integers(0, 7, pointing.size) * 22.5
ntimes = len(pointing)
# get instrument model with only one detector
instrument = QubicInstrument('monochromatic')
mask_packed = np.ones(len(instrument.detector.packed), bool)
mask_packed[idetector] = False
mask_unpacked = instrument.unpack(mask_packed)
instrument = QubicInstrument('monochromatic', removed=mask_unpacked)
obs = QubicAcquisition(instrument, pointing)
convolution = obs.get_convolution_peak_operator()
projection = obs.get_projection_peak_operator(kmax=0)
coverage = projection.pT1()
return coverage
def test_polarizer():
sampling = QubicSampling(0, 0, 0)
scene = QubicScene(150, kind='I')
instruments = [
QubicInstrument(polarizer=False, detector_ngrids=2),
QubicInstrument(polarizer=True, detector_ngrids=2),
QubicInstrument(polarizer=False),
QubicInstrument(polarizer=True),
QubicInstrument(polarizer=False, detector_ngrids=2)[:992],
QubicInstrument(polarizer=True, detector_ngrids=2)[:992]
]
n = len(instruments[0])
expecteds = [
np.r_[np.ones(n // 2), np.zeros(n // 2)],
np.full(n, 0.5),
np.ones(n // 2),
np.full(n // 2, 0.5),
np.ones(n // 2),
np.full(n // 2, 0.5)
]
def func(instrument, expected):
op = instrument.get_polarizer_operator(sampling, scene)
sky = np.ones((len(instrument), 1))
assert_equal(op(sky).ravel(), expected)
for instrument, expected in zip(instruments, expecteds):
yield func, instrument, expected
def test():
kinds = 'I', 'IQU'
instrument = QubicInstrument(synthbeam_dtype=float)[:400]
np.random.seed(0)
sampling = create_random_pointings([0, 90], 30, 5)
skies = np.ones(12 * 256**2), np.ones((12 * 256**2, 3))
def func(sampling, kind, sky, ref1, ref2, ref3, ref4, ref5, ref6):
nprocs_instrument = max(size // 2, 1)
acq = QubicAcquisition(instrument,
sampling,
kind=kind,
nprocs_instrument=nprocs_instrument)
assert_equal(acq.comm.size, size)
assert_equal(acq.instrument.detector.comm.size, nprocs_instrument)
assert_equal(acq.sampling.comm.size, size / nprocs_instrument)
H = acq.get_operator()
invntt = acq.get_invntt_operator()
tod = H(sky)
#actual1 = acq.unpack(H(sky))
#assert_same(actual1, ref1, atol=20)
actual2 = H.T(invntt(tod))
assert_same(actual2, ref2, atol=20)
actual2 = (H.T * invntt * H)(sky)
assert_same(actual2, ref2, atol=20)
actual3, actual4 = tod2map_all(acq, tod, disp=False, maxiter=2)
assert_same(actual3, ref3, atol=20)
assert_same(actual4, ref4, atol=20)
#actual5, actual6 = tod2map_each(acq, tod, disp=False)
#assert_same(actual5, ref5, atol=1000)
#assert_same(actual6, ref6)
for kind, sky in zip(kinds, skies):
acq = QubicAcquisition(instrument,
sampling,
kind=kind,
comm=MPI.COMM_SELF)
assert_equal(acq.comm.size, 1)
H = acq.get_operator()
invntt = acq.get_invntt_operator()
tod = H(sky)
ref1 = acq.unpack(tod)
ref2 = H.T(invntt(tod))
ref3, ref4 = tod2map_all(acq, tod, disp=False, maxiter=2)
ref5, ref6 = None, None #tod2map_each(acq, tod, disp=False)
yield (func, sampling, kind, sky, ref1, ref2, ref3, ref4, ref5, ref6)
def test():
instrument = QubicInstrument()[:10]
sampling = create_random_pointings([0, 90], 30, 5)
nside = 64
scenes = QubicScene(nside, kind='I'), QubicScene(nside)
def func(scene, max_nbytes, ref1, ref2, ref3, ref4, ref5, ref6):
acq = QubicAcquisition(instrument,
sampling,
scene,
max_nbytes=max_nbytes)
sky = np.ones(scene.shape)
H = acq.get_operator()
actual1 = H(sky)
assert_same(actual1, ref1, atol=10)
actual2 = H.T(actual1)
assert_same(actual2, ref2, atol=10)
actual2 = (H.T * H)(sky)
assert_same(actual2, ref2, atol=10)
actual3, actual4 = tod2map_all(acq, ref1, disp=False)
assert_same(actual3, ref3, atol=10000)
assert_same(actual4, ref4)
actual5, actual6 = tod2map_each(acq, ref1, disp=False)
assert_same(actual5, ref5, atol=1000)
assert_same(actual6, ref6)
for scene in scenes:
acq = QubicAcquisition(instrument, sampling, scene)
sky = np.ones(scene.shape)
nbytes_per_sampling = acq.get_operator_nbytes() // len(acq.sampling)
H = acq.get_operator()
ref1 = H(sky)
ref2 = H.T(ref1)
ref3, ref4 = tod2map_all(acq, ref1, disp=False)
ref5, ref6 = tod2map_each(acq, ref1, disp=False)
for max_sampling in 10, 29, 30:
max_nbytes = None if max_sampling is None \
else max_sampling * nbytes_per_sampling
yield (func, scene, max_nbytes, ref1, ref2, ref3, ref4, ref5, ref6)
center = equ2gal(racenter, deccenter)
maxiter = 1000
nside = 1024
sampling = create_random_pointings([racenter, deccenter], 5000, 5)
scene = QubicScene(nside, kind='I')
#sky = read_map(PATH + 'syn256_pol.fits')[:,0]
sky = np.zeros(12*nside**2)
ip0=hp.ang2pix(nside, np.radians(90.-center[1]), np.radians(center[0]))
v0 = np.array(hp.pix2vec(nside, ip0))
sky[ip0] = 1000
#hp.gnomview(sky, rot=center, reso=5, xsize=800)
instrument = QubicInstrument(filter_nu=150e9,
detector_nep=1e-30)
acq_qubic = QubicAcquisition(instrument, sampling, scene, effective_duration=1, photon_noise=False)
coverage = acq_qubic.get_coverage()
observed = coverage > 0.01 * np.max(coverage)
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
tol = 5e-6
solution_qubic = pcg(A, b, disp=True, maxiter=maxiter, tol=tol)
from __future__ import division
import numpy as np
from pyoperators.utils import settingerr
from pyoperators.utils.testing import assert_equal, assert_same, assert_is_type
from pysimulators import BeamGaussian, BeamUniformHalfSpace, FitsArray
from qubic import (create_random_pointings, QubicAcquisition, QubicInstrument,
QubicSampling, QubicScene)
q = QubicInstrument()
s = create_random_pointings([0, 90], 5, 10.)
def test_detector_indexing():
expected = FitsArray('test/data/detector_indexing.fits')
assert_same(q.detector.index, expected)
def test_beams():
assert_is_type(q.primary_beam, BeamGaussian)
assert_is_type(q.secondary_beam, BeamGaussian)
a = QubicAcquisition(150,
s,
primary_beam=BeamUniformHalfSpace(),
secondary_beam=BeamUniformHalfSpace())
assert_is_type(a.instrument.primary_beam, BeamUniformHalfSpace)
assert_is_type(a.instrument.secondary_beam, BeamUniformHalfSpace)
def test_primary_beam():
def primary_beam(theta, phi):
import numpy as np
os.system('\cp ' + path + '/TD_CalQubic_HornArray_v4.fits ' + path +
'/CalQubic_HornArray_v5.fits')
os.system('\cp ' + path + '/TD_CalQubic_DetArray_v3.fits ' + path +
'/CalQubic_DetArray_v4.fits')
else:
print('First Instrument')
os.system('rm -f ' + path + '/CalQubic_HornArray_v5.fits')
os.system('rm -f ' + path + '/CalQubic_DetArray_v4.fits')
###### Monochromatic Instrument #####################################################################
nside = 256
scene = QubicScene(nside)
from qubic import QubicInstrument
instTD = QubicInstrument(filter_nu=150e9)
############ Visualizing the Horns and detectors ################################
clf()
subplot(1, 2, 1)
instTD.detector.plot()
xx, yy, zz = instTD.detector.center.T
index_det = instTD.detector.index
for i in range(len(instTD.detector)):
text(xx[i] - 0.0012,
yy[i],
'{}'.format(index_det[i]),
fontsize=6,
color='r')
subplot(1, 2, 2)
instTD.horn.plot()
SOURCE_POWER = 1 # [W]
SOURCE_THETA = np.radians(3) # [rad]
SOURCE_PHI = np.radians(45) # [rad]
NPOINT_FOCAL_PLANE = 512**2 # number of detector plane sampling points
NSIDE = 512
#primary_beam = MyBeam(alternative_beam, fwhm1, fwhm2, x0_1, x0_2, weight1, weight2, NSIDE)
#secondary_beam = MyBeam(alternative_beam, fwhm1, fwhm2, x0_1, x0_2, weight1, weight2, NSIDE, backward=True)
#qubic = MyQubicInstrument(
# primary_beam=primary_beam, secondary_beam=secondary_beam,
# detector_ngrids=1, filter_nu=NU)
qubic = QubicInstrument(detector_ngrids=1, filter_nu=NU)
qubic.horn.open[:] = False
#qubic.horn.open[10] = True
#qubic.horn.open[14] = True
qubic.horn.open[78] = True
qubic.horn.open[82] = True
qubic.horn.plot(facecolor_closed='white', facecolor_open='red')
FOCAL_PLANE_LIMITS = (np.nanmin(qubic.detector.vertex[..., 0]),
np.nanmax(qubic.detector.vertex[..., 0])) # [m]
# to check energy conservation (unrealistic detector plane):
#FOCAL_PLANE_LIMITS = (-4, 4) # [m]
#FOCAL_PLANE_LIMITS = (-0.2, 0.2) # [m]
#################
# read the input map x0 = qubic.io.read_map(qubic.data.PATH + 'syn256_pol.fits', field='I_STOKES') # 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 model scene = QubicScene(hp.npix2nside(x0.size), kind='I') # instrument model instrument = QubicInstrument(filter_nu=150e9) # acquisition model acq = QubicAcquisition(instrument, sampling, scene) 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()
ang = 20 # degrees
##################################################################################
############## True Pointing #####################################################
pointing = create_random_pointings([racenter, deccenter], duration*3600/ts, ang, period=ts)
hwp_angles = np.random.random_integers(0, 7, len(pointing)) * 11.25
pointing.pitch = 0
pointing.angle_hwp = hwp_angles
npoints = len(pointing)
##################################################################################
############# Instrument with Alternative Primary Beam ###########################
inst = QubicInstrument(detector_tau=0.0001,
detector_sigma=noise,
detector_fknee=0.,
detector_fslope=1)
if hornprofile != 0:
pb = AltPrimaryBeam(14,hornprofile)
inst.primary_beam=pb
##################################################################################
############## Input maps ########################################################
# x0 = None
# if rank == 0:
# print('Rank '+str(rank)+' is Running Synfast')
# x0 = np.array(hp.synfast(spectra[1:],nside,fwhm=0,pixwin=True,new=True)).T
# x0 = MPI.COMM_WORLD.bcast(x0)
# x0_noI = x0.copy()
def __init__(self,
calibration=None,
detector_fknee=0,
detector_fslope=1,
detector_ncorr=10,
detector_nep=4.7e-17,
detector_ngrids=1,
detector_tau=0.01,
filter_name=150e9,
filter_nu=None,
filter_relative_bandwidth=None,
polarizer=True,
primary_beam=None,
secondary_beam=None,
synthbeam_dtype=np.float32,
synthbeam_fraction=0.99,
synthbeam_kmax=8,
synthbeam_peak150_fwhm=np.radians(0.3859879),
NPOINTS=1,
detector_points=None,
NFREQS=1):
"""
The QubicInstrument class. It represents the instrument setup.
The exact values of synthbeam_peak150_fwhm are:
mask degrees mean sigma TEST
30 [[[ 3.85987922e-01 5.82749218e-06] energy
[ 3.79987384e-01 1.30462933e-03]] residuals
60 [[ 3.85987936e-01 5.82815020e-06] energy
[ 3.79986166e-01 1.30518810e-03]]] residuals
Parameters
----------
NPOINTS : integer in the range: [n**2 for n integer], optional
Takes into account the spatial extension of the bolometers. It is
the focal plane number of points inside each detector.
detector_points : array-like, optional
Grid of points on the focal plane. They must be conteined inside
the detectors. The shape must be: (ndetectors, NPOINTS, 3). If
None it will be considered a squared grid of NPOINTS points.
filter_name : float, optional
The central wavelength of the band, in Hz: 150e9 or 220e9
NFREQS : integer, optional
Takes into account the polychromaticity of the bandwidth. It is
the bandwidth number of frequencies.
frequencies : array-like, optional
Grid of frequencies for the bandwidth. If None it will be
considered a non-linear grid of NFREQS frequencies.
relative_bandwidths : array-like, optional
The relative bandwidths for each frequency of the bandwidth.
"""
QubicInstrument.__init__(self,
calibration=calibration,
detector_fknee=detector_fknee,
detector_fslope=detector_fslope,
detector_ncorr=detector_ncorr,
detector_nep=detector_nep,
detector_ngrids=detector_ngrids,
detector_tau=detector_tau,
polarizer=polarizer,
filter_nu=filter_name,
filter_relative_bandwidth=0.25,
primary_beam=primary_beam,
secondary_beam=secondary_beam,
synthbeam_dtype=synthbeam_dtype,
synthbeam_fraction=synthbeam_fraction,
synthbeam_kmax=synthbeam_kmax,
synthbeam_peak150_fwhm=synthbeam_peak150_fwhm)
self.filter.name = filter_name
if filter_nu is None and filter_relative_bandwidth is None:
self.filter.NFREQS = NFREQS
self.filter.nu = self.quadratic_grid4freqs()
self.filter.relative_bandwidth = self.weights() / self.filter.nu
elif fiter_nu is None and filter_relative_bandwidths is not None:
raise ValueError("Invalid frequencies or bandwidths")
elif filter_nu is not None and filter_relative_bandwidths is None:
raise ValueError("Invalid frequencies or bandwidths")
else:
self.filter.NFREQS = len(filter_nu)
self.filter.nu = filter_nu
self.filter.relative_bandwidth = filter_relative_bandwidths
self.filter.bandwidth = (self.filter.nu *
self.filter.relative_bandwidth)
if detector_points is None:
self.detector.NPOINTS = NPOINTS
side = np.sqrt(self.detector.area)
self.detector.points = self.shift_grid4pos(self.detector.NPOINTS,
side,
self.detector.center)
elif len(detector_points.shape) != 3:
raise ValueError("The shape must be: (ndetectors, NPOINTS, 3)")
else:
self.detector.NPOINTS = detector_points.shape[1]
self.detector.points = detector_points
def __init__(
self, calibration=None, detector_fknee=0, detector_fslope=1,
detector_ncorr=10, detector_nep=4.7e-17, detector_ngrids=1,
detector_tau=0.01, filter_name=150e9, filter_nu=None,
filter_relative_bandwidth=None, polarizer=True,
primary_beam=None, secondary_beam=None,
synthbeam_dtype=np.float32, synthbeam_fraction=0.99,
synthbeam_kmax=8, synthbeam_peak150_fwhm=np.radians(0.3859879),
NPOINTS=1, detector_points=None, NFREQS=1):
"""
The QubicInstrument class. It represents the instrument setup.
The exact values of synthbeam_peak150_fwhm are:
mask degrees mean sigma TEST
30 [[[ 3.85987922e-01 5.82749218e-06] energy
[ 3.79987384e-01 1.30462933e-03]] residuals
60 [[ 3.85987936e-01 5.82815020e-06] energy
[ 3.79986166e-01 1.30518810e-03]]] residuals
Parameters
----------
NPOINTS : integer in the range: [n**2 for n integer], optional
Takes into account the spatial extension of the bolometers. It is
the focal plane number of points inside each detector.
detector_points : array-like, optional
Grid of points on the focal plane. They must be conteined inside
the detectors. The shape must be: (ndetectors, NPOINTS, 3). If
None it will be considered a squared grid of NPOINTS points.
filter_name : float, optional
The central wavelength of the band, in Hz: 150e9 or 220e9
NFREQS : integer, optional
Takes into account the polychromaticity of the bandwidth. It is
the bandwidth number of frequencies.
frequencies : array-like, optional
Grid of frequencies for the bandwidth. If None it will be
considered a non-linear grid of NFREQS frequencies.
relative_bandwidths : array-like, optional
The relative bandwidths for each frequency of the bandwidth.
"""
QubicInstrument.__init__(
self, calibration=calibration, detector_fknee=detector_fknee,
detector_fslope=detector_fslope, detector_ncorr=detector_ncorr,
detector_nep=detector_nep, detector_ngrids=detector_ngrids,
detector_tau=detector_tau, polarizer=polarizer,
filter_nu=filter_name, filter_relative_bandwidth=0.25,
primary_beam=primary_beam, secondary_beam=secondary_beam,
synthbeam_dtype=synthbeam_dtype,
synthbeam_fraction=synthbeam_fraction,
synthbeam_kmax=synthbeam_kmax,
synthbeam_peak150_fwhm=synthbeam_peak150_fwhm)
self.filter.name = filter_name
if filter_nu is None and filter_relative_bandwidth is None:
self.filter.NFREQS = NFREQS
self.filter.nu = self.quadratic_grid4freqs()
self.filter.relative_bandwidth = self.weights() / self.filter.nu
elif fiter_nu is None and filter_relative_bandwidths is not None:
raise ValueError("Invalid frequencies or bandwidths")
elif filter_nu is not None and filter_relative_bandwidths is None:
raise ValueError("Invalid frequencies or bandwidths")
else:
self.filter.NFREQS = len(filter_nu)
self.filter.nu = filter_nu
self.filter.relative_bandwidth = filter_relative_bandwidths
self.filter.bandwidth = (
self.filter.nu * self.filter.relative_bandwidth)
if detector_points is None:
self.detector.NPOINTS = NPOINTS
side = np.sqrt(self.detector.area)
self.detector.points = self.shift_grid4pos(
self.detector.NPOINTS, side, self.detector.center)
elif len(detector_points.shape) != 3:
raise ValueError(
"The shape must be: (ndetectors, NPOINTS, 3)")
else:
self.detector.NPOINTS = detector_points.shape[1]
self.detector.points = detector_points
ptg = [1., 0, 180]
ptg2 = [1., 1, 180]
pta = np.asarray(ptg)
pta2 = np.asarray(ptg2)
ptgs = ptg, [ptg], [ptg, ptg], [[ptg, ptg], [ptg2, ptg2, ptg2]], \
pta, [pta], [pta, pta], [[pta, pta], [pta2, pta2, pta2]], \
np.asarray([pta]), np.asarray([pta, pta]), [np.asarray([pta, pta])], \
[np.asarray([pta, pta]), np.asarray([pta2, pta2, pta2])]
block_n = [[1], [1], [2], [2, 3], [1], [1], [2], [2, 3], [1], [2], [2], [2, 3],
[2, 3]]
caltree = QubicCalibration(detarray='CalQubic_DetArray_v1.fits')
selection = np.zeros((32, 32), dtype=bool)
selection[30:, 30:] = True
qubic = QubicInstrument(calibration=caltree,
filter_nu=160e9,
synthbeam_fraction=0.99)
qubic = qubic[qubic.pack(selection)]
@skiptest
def test_pointing():
def func(p, n):
p = np.asarray(p)
smp = QubicSampling(azimuth=p[..., 0],
elevation=p[..., 1],
pitch=p[..., 2])
acq = QubicAcquisition(qubic, smp)
assert_equal(acq.block.n, n)
assert_equal(len(acq.pointing), sum(n))
plot(azel[0]*np.pi/180,90-azel[1],'.')
fig.suptitle('Azimuth Elevation')
fig2=figure()
plot(pointings[:,2])
xlabel('Pitch angle')
fig=figure()
plot(pointings[:,1],90-pointings[:,0],',')
xlabel('ra')
ylabel('dec')
mp.show()
map_orig = hp.read_map('/Volumes/Data/Qubic/qubic_v1/syn256.fits')
q = QubicInstrument()
C = q.get_convolution_peak_operator()
P = q.get_projection_peak_operator(pointings, kmax=kmax)
H = P * C
### TOD
tod = H(map_orig)
ndet,npix=tod.shape
#ikeep=511
#for i in arange(ndet):
#if i != ikeep:
# tod[i,:]=0
### noise
white_noise_sig=30
from __future__ import division
import matplotlib.pyplot as mp
import numpy as np
from pyoperators import MaskOperator
from pysimulators import create_fitsheader, SceneGrid
from qubic import QubicInstrument
NU = 150e9 # [Hz]
SOURCE_THETA = np.radians(0) # [rad]
SOURCE_PHI = np.radians(0) # [rad]
NPOINT_FOCAL_PLANE = 512**2 # number of detector plane sampling points
qubic = QubicInstrument(filter_nu=NU)
# example for a baseline selection:
#qubic.horn.open[:] = False
#qubic.horn.open[0] = True
#qubic.horn.open[14] = True
FOCAL_PLANE_LIMITS = (np.nanmin(qubic.detector.vertex[..., 0]),
np.nanmax(qubic.detector.vertex[..., 0])) # [m]
# to check energy conservation (unrealistic detector plane):
FOCAL_PLANE_LIMITS = (-0.2, 0.2) # [m]
#################
# FOCAL PLANE
from pyquad import pyquad
from pyoperators import pcg, DiagonalOperator, UnpackOperator
from pysimulators import ProjectionInMemoryOperator
from qubic import QubicConfiguration, QubicInstrument, create_random_pointings
path = os.path.dirname("/Users/hamilton/idl/pro/Qubic/People/pierre/qubic/script/script_ga.py")
nside = 256
input_map = np.zeros(12 * nside ** 2)
input_map[0] = 1
#### QUBIC Instrument
kmax = 2
qubic = QubicInstrument("monochromatic,nopol", nside=nside)
pointings = create_random_pointings(1, 20)
pointings[0, :] = [0.1, 0, 0]
#### 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)
plot(tod)
corner = qubic.pack(qubic.detector.corner).view(float).reshape((-1, 4, 2))
angspeed_psi = 0.1 # deg/sec
maxpsi = 45. # deg
nsweeps_el = 300
duration = 24 # hours
ts = 0.1 # seconds
# get the sampling model
np.random.seed(0)
sampling = create_sweeping_pointings(
[racenter, deccenter], duration, ts, angspeed, delta_az, nsweeps_el,
angspeed_psi, maxpsi)
scene = QubicScene(nside)
# get the instrument model with only one detector
idetector = 0
instrument = QubicInstrument()[idetector]
# get the acquisition model from the instrument, sampling and scene models
acq = QubicAcquisition(instrument, sampling, scene)
# get noiseless timeline
x0 = qubic.io.read_map(qubic.data.PATH + 'syn256_pol.fits')
y, x0_convolved = acq.get_observation(x0, convolution=True, noiseless=True)
# inversion through Preconditioned Conjugate Gradient
x, coverage = tod2map_all(acq, y, disp=True, tol=1e-3,
coverage_threshold=0)
mask = coverage > 0
# some display
angspeed_psi = 0
maxpsi = 15.
nsweeps_el = int(120*angspeed)
duration = 24 # hours
ts = 0.1 # seconds
decrange=0
decspeed=0
pointing = pointings_modbyJC.create_sweeping_pointings(
[racenter, deccenter], duration, ts, angspeed, delta_az, nsweeps_el,
angspeed_psi, maxpsi, decrange=decrange, decspeed=decspeed,recenter=True)
pointing.angle_hwp = np.random.random_integers(0, 7, pointing.size) * 22.5
ntimes = len(pointing)
# get instrument model with only one detector
idetector = 231
instrument = QubicInstrument('monochromatic')
instrument.plot()
mask_packed = np.ones(len(instrument.detector.packed), bool)
mask_packed[idetector] = False
mask_unpacked = instrument.unpack(mask_packed)
instrument = QubicInstrument('monochromatic', removed=mask_unpacked)
obs = QubicAcquisition(instrument, pointing)
convolution = obs.get_convolution_peak_operator()
projection = obs.get_projection_peak_operator(kmax=0)
hwp = obs.get_hwp_operator()
polarizer = obs.get_polarizer_operator()
coverage = projection.pT1()
mask = coverage > 0
projection.restrict(mask)
pack = PackOperator(mask, broadcast='rightward')
mp.plot(lll, np.sqrt(abs(spectra[4])*(lll*(lll+1))/(2*np.pi)),label='$C_\ell^{TE}$')
mp.plot(lll,np.sqrt(spectra[2]*(lll*(lll+1))/(2*np.pi)),label='$C_\ell^{EE}$')
mp.plot(lll,np.sqrt(spectra[3]*(lll*(lll+1))/(2*np.pi)),label='$C_\ell^{BB}$')
mp.yscale('log')
mp.xlim(0,lmaxcamb+1)
#ylim(0.0001,100)
mp.xlabel('$\ell$')
mp.ylabel('$\sqrt{\ell(\ell+1)C_\ell/(2\pi)}$'+' '+'$[\mu K]$ ')
mp.legend(loc='lower right',frameon=False)
########## Qubic Instrument
NET150 = (220+314)/2*sqrt(2)*sqrt(2) ### Average between witner and summer
NET220 = (520+906)/2*sqrt(2)*sqrt(2) ### Average between witner and summer
inst = QubicInstrument()
############# Shifting horns quarters
def shift_inst(shift):
inst = QubicInstrument()
matback = np.array([[np.cos(np.radians(-inst.horn.angle)), -np.sin(np.radians(-inst.horn.angle))],[np.sin(np.radians(-inst.horn.angle)), np.cos(np.radians(-inst.horn.angle))]])
matfwd = matback = np.array([[np.cos(np.radians(inst.horn.angle)), -np.sin(np.radians(inst.horn.angle))],[np.sin(np.radians(inst.horn.angle)), np.cos(np.radians(inst.horn.angle))]])
xyrot = np.dot(matback, inst.horn.center[:,:2].T).T
xplus = xyrot[:,0] > 0
xyrot[xplus,0] += shift/2
xyrot[~xplus,0] += -shift/2
yplus = xyrot[:,1] > 0
xyrot[yplus,1] += shift/2
xyrot[~yplus,1] += -shift/2
#stop
