def rand_map_flat(shape,
wcs,
ps,
lmax=None,
lens=True,
aberrate=True,
beta=None,
dir=None,
seed=None,
dtype=None,
verbose=False,
recenter=False,
pad=0):
"""Simulate a random flat-sky map. The input spectrum should be
[{phi,T,E,B},{phi,T,E,b},nl] of lens is True, and just [{T,E,B},{T,E,B},nl]
otherwise."""
if dtype is None: dtype = np.float64
if dir is None: dir = aberration.dir_equ
if beta is None: beta = aberration.beta
ctype = np.result_type(dtype, 0j)
if verbose: print "Generating unlensed cmb"
# No position calculation necessary if we're not lensing or aberrating.
if not lens and not aberrate:
return enmap.rand_map(shape, wcs, ps, seed=seed)
# Otherwise we must deal with various displacements
if aberrate: pad += np.pi * beta * 1.2
pad_pix = int(pad / enmap.pixsize(shape, wcs)**0.5)
if pad_pix > 0:
if verbose: print "Padding"
template = enmap.zeros(shape, wcs, np.int16)
template, pslice = enmap.pad(template, pad_pix, return_slice=True)
pshape, pwcs = template.shape, template.wcs
else:
pshape, pwcs = shape, wcs
# Simulate (padded) lensing map
if lens:
maps = enmap.rand_map((ps.shape[0], ) + pshape[-2:], pwcs, ps)
phi, unlensed = maps[0], maps[1:]
if verbose: print "Lensing"
m = lensing.lens_map_flat(unlensed, phi)
else:
m = enmap.rand_map((ps.shape[0], ) + pshape[-2:], pwcs, ps)
# Then handle aberration if necessary
if aberrate:
if verbose: print "Computing aberration displacement"
pos = m.posmap()
pos = enmap.samewcs(
aberration.remap(pos[1::-1], dir=dir, beta=beta,
recenter=recenter), pos)
amp = pos[3]
pos = pos[1::-1]
if verbose: print "Interpolating aberration"
m = enmap.samewcs(m.at(pos, mask_nan=False), m)
if verbose: print "Applying modulation"
m *= amp
if pad_pix > 0:
if verbose: print "Unpadding"
m = m[pslice]
return m
winAtLens = (comS - comL) / comS
kappa_map, r500 = NFWkappa(cc,
massOverh,
concentration,
zL,
modr_sim,
winAtLens,
overdensity=overdensity,
critical=critical,
atClusterZ=atClusterZ)
else:
grad_cut = None
clkk = theory.gCl("kk", fine_ells)
clkk.resize((1, 1, clkk.size))
kappa_map = enmap.rand_map(shape_sim[-2:], wcs_sim, cov=clkk, scalar=True)
pkk = fmaps.get_simple_power_enmap(kappa_map)
debug_edges = np.arange(2, 12000, 80)
dbinner = stats.bin2D(modlmap_sim, debug_edges)
cents, bclkk = dbinner.bin(pkk)
clkk.resize((clkk.shape[-1]))
pl = io.Plotter(scaleY='log', scaleX='log')
pl.add(fine_ells, clkk)
pl.add(cents, bclkk)
pl.done(out_dir + "clkk.png")
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
io.quickPlot2d(kappa_map, out_dir + "kappa_map.png")
io.quickPlot2d(phi, out_dir + "phi.png")
alpha_pix = enmap.grad_pixf(fphi)
# === DEFLECTION MAP ===
a = alphaMaker(thetaMap)
alpha = a.kappaToAlpha(kappaMap,test=False)
pos = thetaMap.posmap() + alpha
pix = thetaMap.sky2pix(pos, safe=False)
gradfit = 2.*np.pi/180./60.
from scipy.ndimage.interpolation import rotate
N = 100
avgrot = 0.
for i in range(N):
map = enmap.rand_map(shape, wcs, ps)/TCMB
gmap = enmap.grad(map)
angle = np.arctan2(gmap[0][np.where(thetaMap<gradfit)].mean(),gmap[1][np.where(thetaMap<gradfit)].mean())*180./np.pi
lensedTQU = lensing.displace_map(map, pix,order=5)+0.j
diffmap = (lensedTQU-map).real
rotmap = rotate(diffmap, angle,reshape=False)
avgrot += rotmap
print((i,angle))
#io.highResPlot2d(map,out_dir+"unl"+str(i)+".png")
#io.highResPlot2d(rotmap,out_dir+"rot"+str(i)+".png")
for i in range(comm.rank, args.nsim, comm.size):
if args.lensed:
ps = powspec.read_camb_full_lens(args.powspec).astype(dtype)
if args.beam:
raise NotImplementedError("Beam not supported for lensed sims yet")
if args.geometry == "curved":
m, = lensing.rand_map(shape,
wcs,
ps,
lmax=lmax,
maplmax=maplmax,
seed=(seed, i),
verbose=verbose,
dtype=dtype)
else:
maps = enmap.rand_map((shape[0] + 1, ) + shape[1:], wcs, ps)
phi, unlensed = maps[0], maps[1:]
m = lensing.lens_map_flat(unlensed, phi)
else:
ps = powspec.read_spectrum(args.powspec).astype(type)
beam = make_beam(ps.shape[-1], args.beam * utils.arcmin * utils.fwhm)
ps *= beam
if args.geometry == "curved":
m = curvedsky.rand_map(shape,
wcs,
ps,
lmax=lmax,
seed=(seed, i),
method=args.method,
direct=args.direct,
dtype=dtype,
def output(res, dir):
utils.mkdir(dir)
for i, (tqu, teb, desc) in enumerate(zip(res.tqu, res.teb, res.desc)):
enmap.write_map("%s/%02d_%s_tqu.hdf" % (dir,i+1,desc), tqu)
enmap.write_map("%s/%02d_%s_teb.hdf" % (dir,i+1,desc), teb)
cl_scal, cl_phi = powspec.read_camb_scalar(args.scal_cls, expand=True)
cl_tens = powspec.read_spectrum(args.tens_cls, expand="diag")
cl_cmb = cl_scal+cl_tens
np.random.seed(args.seed)
res = bunch.Bunch(tqu=[],teb=[],desc=[])
# 1. Start with last scattering
cmb = enmap.rand_map(shape, wcs, cl_cmb)
m = cmb; add(res, m, "cmb")
# 2. Add lensing
phi = enmap.rand_map(shape[-2:], wcs, cl_phi)
lcmb = lensing.lens_map_flat(cmb, phi)
m = lcmb; add(res, m, "lens")
# 3. Add point sources
pinfo = parse_points(args.ptsrc)
pmap = sim_points(shape, wcs, pinfo)
m += pmap; add(res, m, "ptsrc")
# 4. Add sz clusters
zinfo = parse_points(args.sz)
zmap = sim_points(shape, wcs, zinfo)
m += zmap; add(res, m, "sz")
# 5. Add faraday rotation (probably invisible)
m = enmap.rotate_pol(m, args.faraday)
seed = args.seed if args.seed is not None else np.random.randint(0,100000000)
dtype= {32:np.float32, 64:np.float64}[args.bits]
verbose = args.verbose - args.quiet > 0
def make_beam(nl, bsize):
l = np.arange(nl)
return np.exp(-l*(l+1)*bsize**2)
for i in range(comm.rank, args.nsim, comm.size):
if args.lensed:
ps = powspec.read_camb_full_lens(args.powspec).astype(dtype)
if args.beam:
raise NotImplementedError("Beam not supported for lensed sims yet")
if args.geometry == "curved":
m, = lensing.rand_map(shape, wcs, ps, lmax=lmax, maplmax=maplmax, seed=(seed,i), verbose=verbose, dtype=dtype)
else:
maps = enmap.rand_map((shape[0]+1,)+shape[1:], wcs, ps)
phi, unlensed = maps[0], maps[1:]
m = lensing.lens_map_flat(unlensed, phi)
else:
ps = powspec.read_spectrum(args.powspec).astype(type)
beam = make_beam(ps.shape[-1], args.beam*utils.arcmin*utils.fwhm)
ps *= beam
if args.geometry == "curved":
m = curvedsky.rand_map(shape, wcs, ps, lmax=lmax, seed=(seed,i), method=args.method, direct=args.direct, dtype=dtype, verbose=verbose)
else:
m = enmap.rand_map(shape, wcs, ps)
if args.nsim == 1:
if verbose: print "Writing %s" % args.ofile
enmap.write_map(args.ofile, m)
else:
# Try solving
trifilter = Trifilter(map, iP, S, N)
L.info("Filtering map")
pmap = trifilter.solve(map, verbose=args.verbose, nmin=nmin)
L.info("Writing pmap")
enmap.write_map(args.odir + "/pmap.fits", pmap[0])
# Estimate uncertainty with a couple of other realizations
varmap = inoise * 0
nsim = 2
for i in range(nsim):
L.info("Filtering sim %d" % i)
r = enmap.rand_gauss(map.shape,
map.wcs) * (inoise + np.max(inoise) * 1e-4)[0]**-0.5
c = enmap.rand_map(map.shape, map.wcs, ps_cmb)
sim = r + c
sim_flt = trifilter.solve(sim, verbose=args.verbose, nmin=nmin)
enmap.write_map(args.odir + "/sim%d.fits" % i, sim[0])
enmap.write_map(args.odir + "/sim_flt%d.fits" % i, sim_flt[0])
varmap += sim_flt[None, :] * sim_flt[:, None]
varmap /= nsim
L.info("Writing pstd_raw")
enmap.write_map(args.odir + "/pstd_raw.fits", varmap[0, 0]**0.5)
# Smooth var map to reduce noise
L.info("Computing significance")
varmap = enmap.smooth_gauss(varmap[0, 0], 15 * np.pi / 180 / 60)[None, None]
# Create signal-to-noise map
significance = pmap[0] / varmap[0, 0]**0.5
# io.quickPlot2d(np.fft.fftshift(fMaskCMB_T),out_dir+"presmooth.png")
# fMaskCMB_T = fmaps.smooth(fMaskCMB_T,modlmap_sim,gauss_sigma_arcmin=0.1)
# io.quickPlot2d(np.fft.fftshift(fMaskCMB_T),out_dir+"postsmooth.png")
# fMaskCMB_T[modlmap_sim<2]=0.
def f(rmap):
fk = fftfast.fft(rmap, axes=[-2, -1])
fk = np.nan_to_num(fk) * fMaskCMB_T
return enmap.samewcs(
fftfast.ifft(fk, axes=[-2, -1], normalize=True).real, rmap)
for i in range(Nstack):
unlensed = enmap.rand_map(shape_sim, wcs_sim, ps)
lensed = lensing.lens_map_flat_pix(unlensed, alpha_pix, order=lens_order)
if noiseless_cmb:
measured = lensed
else:
klteb = enmap.map2harm(lensed)
klteb_beam = klteb * kbeam_sim
lteb_beam = enmap.ifft(klteb_beam).real
noise = enmap.rand_map(shape_sim, wcs_sim, ps_noise, scalar=True)
observed = lteb_beam + noise
fkmaps = fftfast.fft(observed, axes=[-2, -1])
fkmaps = np.nan_to_num(fkmaps / kbeam_sim) * fMaskCMB_T
measured = enmap.samewcs(
fftfast.ifft(fkmaps, axes=[-2, -1], normalize=True).real, observed)
if i == 0: io.quickPlot2d((measured - lensed), out_dir + "test2.png")
def get_scans(area, signal, bore, dets, noise, seed=0, real=None, noise_override=None):
scans = []
# Get real scan information if necessary
L.debug("real")
if real:
real_scans = []
filedb.init()
db = filedb.data
ids = fileb.scans[real].ids
for id in ids:
try:
real_scans.append(actscan.ACTScan(db[id]))
except errors.DataMissing as e:
L.debug("Skipped %s (%s)" % (id, str(e)))
# Dets
L.debug("dets")
sim_dets = []
toks = dets.split(":")
if toks[0] == "scattered":
ngroup, nper, rad = int(toks[1]), int(toks[2]), float(toks[3])
sim_dets = [scansim.dets_scattered(ngroup, nper,rad=rad*np.pi/180/60)]
margin = rad*np.pi/180/60
elif toks[0] == "real":
ndet = int(toks[1])
dslice = slice(0,ndet) if ndet > 0 else slice(None)
sim_dets = [bunch.Bunch(comps=s.comps[dslice], offsets=s.offsets[dslice]) for s in real_scans]
margin = np.max([np.sum(s.offsets**2,1)**0.5 for s in sim_dets])
else: raise ValueError
# Boresight. Determines our number of scans
L.debug("bore")
sim_bore = []
toks = bore.split(":")
if toks[0] == "grid":
nscan, density, short = int(toks[1]), float(toks[2]), float(toks[3])
for i in range(nscan):
tbox = shorten(area.box(),i%2,short)
sim_bore.append(scansim.scan_grid(tbox, density*np.pi/180/60, dir=i, margin=margin))
elif toks[0] == "ces":
nscan = int(toks[1])
azs = [float(w)*utils.degree for w in toks[2].split(",")]
els = [float(w)*utils.degree for w in toks[3].split(",")]
mjd0 = float(toks[4])
dur = float(toks[5])
azrate= float(toks[6]) if len(toks) > 6 else 1.5*utils.degree
srate = float(toks[7]) if len(toks) > 7 else 400
nsamp = utils.nint(dur*srate)
for i in range(nscan):
mjd = mjd0 + dur*(i//(2*len(els)))/(24*3600)
el = els[(i//2)%len(els)]
az1, az2 = azs
if i%2 == 1: az1, az2 = -az2, -az1
box = np.array([[az1,el],[az2,el]])
sim_bore.append(scansim.scan_ceslike(nsamp, box, mjd0=mjd, srate=srate, azrate=azrate))
elif toks[0] == "real":
sim_bore = [bunch.Bunch(boresight=s.boresight, hwp_phase=s.hwp_phase, sys=s.sys, site=s.site, mjd0=s.mjd0) for s in real_scans]
else: raise ValueError
nsim = len(sim_bore)
# Make one det info per scan
sim_dets = sim_dets*(nsim/len(sim_dets))+sim_dets[:nsim%len(sim_dets)]
# Noise
L.debug("noise")
sim_nmat = []
toks = noise.split(":")
nonoise = False
if toks[0] == "1/f":
sigma, alpha, fknee = [float(v) for v in toks[1:4]]
nonoise = sigma < 0
for i in range(nsim):
sim_nmat.append(scansim.oneoverf_noise(sim_dets[i].comps.shape[0], sim_bore[i].boresight.shape[0], sigma=np.abs(sigma), alpha=alpha, fknee=fknee))
elif toks[0] == "detcorr":
sigma, alpha, fknee = [float(v) for v in toks[1:4]]
nonoise = sigma < 0
for i in range(nsim):
sim_nmat.append(scansim.oneoverf_detcorr_noise(sim_dets[i].comps.shape[0], sim_bore[i].boresight.shape[0], sigma=np.abs(sigma), alpha=alpha, fknee=fknee))
elif toks[0] == "real":
scale = 1.0 if len(toks) < 2 else float(toks[1])
for i,s in enumerate(real_scans):
ndet = len(sim_dets[i].offsets)
nmat = s.noise[:ndet]*scale**-2
sim_nmat.append(nmat)
else: raise ValueError
noise_scale = not nonoise if noise_override is None else noise_override
sim_nmat = sim_nmat*(nsim/len(sim_nmat))+sim_nmat[:nsim%len(sim_nmat)]
# Signal
L.debug("signal")
toks = signal.split(":")
if toks[0] == "none":
for i in range(nsim):
scans.append(scansim.SimPlain(sim_bore[i], sim_dets[i], sim_nmat[i], seed=seed+i, noise_scale=noise_scale))
elif toks[0] == "ptsrc":
# This one always operates in the same coordinates as
nsrc, amp, fwhm = int(toks[1]), float(toks[2]), float(toks[3])
np.random.seed(seed)
sim_srcs = scansim.rand_srcs(area.box(), nsrc, amp, abs(fwhm)*np.pi/180/60, rand_fwhm=fwhm<0)
for i in range(nsim):
scans.append(scansim.SimSrcs(sim_bore[i], sim_dets[i], sim_srcs, sim_nmat[i], seed=seed+i, noise_scale=noise_scale))
elif toks[0] == "vsrc":
# Create a single variable source
ra, dec, fwhm = float(toks[1])*np.pi/180, float(toks[2])*np.pi/180, float(toks[3])*np.pi/180/60
amps = [float(t) for t in toks[4].split(",")]
for i in range(nsim):
sim_srcs = bunch.Bunch(pos=np.array([[dec,ra]]),amps=np.array([[amps[i],0,0,0]]), beam=np.array([fwhm/(8*np.log(2)**0.5)]))
scans.append(scansim.SimSrcs(sim_bore[i], sim_dets[i], sim_srcs, sim_nmat[i], seed=seed+i, noise_scale=noise_scale, nsigma=20))
elif toks[0] == "cmb":
np.random.seed(seed)
ps = powspec.read_spectrum(toks[1])
sim_map = enmap.rand_map(area.shape, area.wcs, ps)
for i in range(nsim):
scans.append(scansim.SimMap(sim_bore[i], sim_dets[i], sim_map, sim_nmat[i], seed=seed+i, noise_scale=noise_scale))
else: raise ValueError
return scans
overdensity=overdensity,
critical=critical,
atClusterZ=atClusterZ)
phi, fphi = lt.kappa_to_phi(kappa_map, modlmap_sim, return_fphi=True)
# io.quickPlot2d(kappa_map,out_dir+"kappa_map.png")
# io.quickPlot2d(phi,out_dir+"phi.png")
alpha_pix = enmap.grad_pixf(fphi)
ps = cmb.enmap_power_from_orphics_theory(theory, lmax, lensed=False)
np.random.seed(200)
# NO BEAM, NO NOISE
# Unlensed
unlensed = enmap.rand_map(shape_sim, wcs_sim, ps)
test = False
if test:
pl = io.Plotter(scaleY='log')
for k, lens_order in enumerate(range(5, 0, -1)):
alpha = (lens_order - 2 + 1. + 1) / (5 - 2 + 1. + 1)
print((lens_order, alpha))
# Lens with kappa1
lensed = lensing.lens_map_flat_pix(unlensed,
alpha_pix,
order=lens_order)
os = args.oversample shape = (3,1024*os,1024*os) w = shape[-1]*args.res*np.pi/180/60/os box = np.array([[-w,-w],[w,w]])/2 wcs = enmap.create_wcs(shape, box) cl_scal, cl_phi = powspec.read_camb_scalar(args.scal_cls, expand=True) cl_tens = powspec.read_spectrum(args.tens_cls, expand="diag") ## Generate scalar-only lensed and unlensed map #m_scal_u, m_scal_l = lensing.rand_map(shape, wcs, cl_scal, cl_phi, seed=args.seed, output="ul", verbose=args.verbose) ## Generate tensor-only lensed and unlensed map #m_tens_u, m_tens_l = lensing.rand_map(shape, wcs, cl_tens, cl_phi, seed=args.seed, output="ul", verbose=args.verbose) np.random.seed(args.seed) phi = enmap.rand_map(shape[-2:], wcs, cl_phi) m_scal_u = enmap.rand_map(shape, wcs, cl_scal) m_tens_u = enmap.rand_map(shape, wcs, cl_tens) m_scal_l = lensing.lens_map_flat(m_scal_u, phi) m_tens_l = lensing.lens_map_flat(m_tens_u, phi) # And the sums m_tot_u = m_scal_u + m_tens_u m_tot_l = m_scal_l + m_tens_l # Convert from TQU to TEB and downgrade def to_eb(m): return enmap.ifft(enmap.map2harm(m)).real m_scal_u, m_scal_l, m_tens_u, m_tens_l, m_tot_u, m_tot_l = [enmap.downgrade(to_eb(i),os) for i in [m_scal_u, m_scal_l, m_tens_u, m_tens_l, m_tot_u, m_tot_l]] # And output utils.mkdir(args.odir)
parser.add_argument("-n", "--nsamp", type=int, default=4)
args = parser.parse_args()
def sim_scan_fast(imap, sigma, rad, n):
mask = np.zeros(imap.shape[-2:])
mask[rad:-rad,rad:-rad] = 1
w = np.maximum(1 - ndimage.distance_transform_edt(1-mask)/rad,0)**3
w = w[None,:,:]*np.array([1,0.5,0.5])[:,None,None]*sigma**-2*n
w = enmap.samewcs(w, imap)
m = imap + np.random.standard_normal(imap.shape)*w**-0.5
m[~np.isfinite(m)] = 0
return m, w
template = enmap.read_map(args.template)[:,::2,::2]
ps = powspec.read_spectrum(args.powspec, expand="diag")
sim = enmap.rand_map(template.shape, template.wcs, ps)
# Simulate noisy data
m, w = sim_scan_fast(sim, args.sigma, 128, 1)
ncomp = m.shape[0]
iN = enmap.zeros((ncomp,ncomp)+w.shape[-2:])
for i in range(ncomp): iN[i,i] = w[i]
iS = enmap.spec2flat(m.shape, m.wcs, ps, -1)
# Draw samples
sampler = gibbs.FieldSampler(iS, iN, m)
res = enmap.zeros((1+args.nsamp,)+m.shape,m.wcs)
res[0] = m
for i in range(args.nsamp):
res[i] = sampler.sample(True)
cc = ClusterCosmology(lmax=lmax, pickling=True)
TCMB = 2.7255e6
theory = cc.theory
ps = cmb.enmap_power_from_orphics_theory(theory, lmax, lensed=False)
cov = ps
width_deg = 20.
pix = 2.0
shape, wcs = enmap.get_enmap_patch(width_deg * 60., pix, proj="CAR", pol=True)
m1 = enmap.rand_map(shape,
wcs,
cov,
scalar=True,
seed=None,
power2d=False,
pixel_units=False)
modlmap = m1.modlmap()
io.quickPlot2d(m1[0], out_dir + "m1.png")
cltt = ps[0, 0]
ells = np.arange(0, cltt.size)
pl = io.Plotter(scaleY='log')
pl.add(ells, cltt * ells**2.)
debug_edges = np.arange(200, 2000, 80)
dbinner = stats.bin2D(modlmap, debug_edges)
powermap = fmaps.get_simple_power_enmap(m1[0])
cents, dcltt = dbinner.bin(powermap)
io.quickPlot2d(phi, out_dir + "phi.png")
alpha_pix = enmap.grad_pixf(fphi)
# alpha_pix2 = enmap.grad_pix(phi)
print((alpha_pix.shape))
# print alpha_pix2.shape
io.quickPlot2d(alpha_pix[0], out_dir + "alpha_pixx.png")
io.quickPlot2d(alpha_pix[1], out_dir + "alpha_pixy.png")
io.quickPlot2d(np.sum(alpha_pix**2, 0)**0.5, out_dir + "alpha_pix.png")
# io.quickPlot2d(alpha_pix2[0],out_dir+"alpha_pixx2.png")
# io.quickPlot2d(alpha_pix2[1],out_dir+"alpha_pixy2.png")
TCMB = 2.7255e6
ps = powspec.read_spectrum("../alhazen/data/cl_lensinput.dat")
cmb_map = old_div(enmap.rand_map(shape, wcs, ps), TCMB)
lensed = lensing.lens_map_flat_pix(cmb_map, alpha_pix, order=5)
#lensed = lensing.lens_map_flat(cmb_map, phi)
io.quickPlot2d(cmb_map, out_dir + "unlensed.png")
io.quickPlot2d(lensed, out_dir + "lensed.png")
io.quickPlot2d(lensed - cmb_map, out_dir + "diff.png")
alpha = enmap.gradf(fphi)
io.quickPlot2d(alpha[0], out_dir + "alphax.png")
io.quickPlot2d(alpha[1], out_dir + "alphay.png")
io.quickPlot2d(np.sum(alpha**2, 0)**0.5, out_dir + "alpha.png")
kappa_inverted = -0.5 * enmap.div(alpha, normalize=False)
io.quickPlot2d(kappa_inverted, out_dir + "kappainv.png")
def get_scans(area, signal, bore, dets, noise, seed=0, real=None, noise_override=None):
scans = []
# Get real scan information if necessary
L.debug("real")
if real:
real_scans = []
filedb.init()
db = filedb.data
ids = fileb.scans[real].ids
for id in ids:
try:
real_scans.append(actscan.ACTScan(db[id]))
except errors.DataMissing as e:
L.debug("Skipped %s (%s)" % (id, e.message))
# Dets
L.debug("dets")
sim_dets = []
toks = dets.split(":")
if toks[0] == "scattered":
ngroup, nper, rad = int(toks[1]), int(toks[2]), float(toks[3])
sim_dets = [scansim.dets_scattered(ngroup, nper,rad=rad*np.pi/180/60)]
margin = rad*np.pi/180/60
elif toks[0] == "real":
ndet = int(toks[1])
dslice = slice(0,ndet) if ndet > 0 else slice(None)
sim_dets = [bunch.Bunch(comps=s.comps[dslice], offsets=s.offsets[dslice]) for s in real_scans]
margin = np.max([np.sum(s.offsets**2,1)**0.5 for s in sim_dets])
else: raise ValueError
# Boresight. Determines our number of scans
L.debug("bore")
sim_bore = []
toks = bore.split(":")
if toks[0] == "grid":
nscan, density, short = int(toks[1]), float(toks[2]), float(toks[3])
for i in range(nscan):
tbox = shorten(area.box(),i%2,short)
sim_bore.append(scansim.scan_grid(tbox, density*np.pi/180/60, dir=i, margin=margin))
elif toks[0] == "ces":
nscan = int(toks[1])
azs = [float(w)*utils.degree for w in toks[2].split(",")]
els = [float(w)*utils.degree for w in toks[3].split(",")]
mjd0 = float(toks[4])
dur = float(toks[5])
azrate= float(toks[6]) if len(toks) > 6 else 1.5*utils.degree
srate = float(toks[7]) if len(toks) > 7 else 400
nsamp = utils.nint(dur*srate)
for i in range(nscan):
mjd = mjd0 + dur*(i//(2*len(els)))/(24*3600)
el = els[(i//2)%len(els)]
az1, az2 = azs
if i%2 == 1: az1, az2 = -az2, -az1
box = np.array([[az1,el],[az2,el]])
sim_bore.append(scansim.scan_ceslike(nsamp, box, mjd0=mjd, srate=srate, azrate=azrate))
elif toks[0] == "real":
sim_bore = [bunch.Bunch(boresight=s.boresight, hwp_phase=s.hwp_phase, sys=s.sys, site=s.site, mjd0=s.mjd0) for s in real_scans]
else: raise ValueError
nsim = len(sim_bore)
# Make one det info per scan
sim_dets = sim_dets*(nsim/len(sim_dets))+sim_dets[:nsim%len(sim_dets)]
# Noise
L.debug("noise")
sim_nmat = []
toks = noise.split(":")
nonoise = False
if toks[0] == "1/f":
sigma, alpha, fknee = [float(v) for v in toks[1:4]]
nonoise = sigma < 0
for i in range(nsim):
sim_nmat.append(scansim.oneoverf_noise(sim_dets[i].comps.shape[0], sim_bore[i].boresight.shape[0], sigma=np.abs(sigma), alpha=alpha, fknee=fknee))
elif toks[0] == "detcorr":
sigma, alpha, fknee = [float(v) for v in toks[1:4]]
nonoise = sigma < 0
for i in range(nsim):
sim_nmat.append(scansim.oneoverf_detcorr_noise(sim_dets[i].comps.shape[0], sim_bore[i].boresight.shape[0], sigma=np.abs(sigma), alpha=alpha, fknee=fknee))
elif toks[0] == "real":
scale = 1.0 if len(toks) < 2 else float(toks[1])
for i,s in enumerate(real_scans):
ndet = len(sim_dets[i].offsets)
nmat = s.noise[:ndet]*scale**-2
sim_nmat.append(nmat)
else: raise ValueError
noise_scale = not nonoise if noise_override is None else noise_override
sim_nmat = sim_nmat*(nsim/len(sim_nmat))+sim_nmat[:nsim%len(sim_nmat)]
# Signal
L.debug("signal")
toks = signal.split(":")
if toks[0] == "none":
for i in range(nsim):
scans.append(scansim.SimPlain(sim_bore[i], sim_dets[i], sim_nmat[i], seed=seed+i, noise_scale=noise_scale))
elif toks[0] == "ptsrc":
# This one always operates in the same coordinates as
nsrc, amp, fwhm = int(toks[1]), float(toks[2]), float(toks[3])
np.random.seed(seed)
sim_srcs = scansim.rand_srcs(area.box(), nsrc, amp, abs(fwhm)*np.pi/180/60, rand_fwhm=fwhm<0)
for i in range(nsim):
scans.append(scansim.SimSrcs(sim_bore[i], sim_dets[i], sim_srcs, sim_nmat[i], seed=seed+i, noise_scale=noise_scale))
elif toks[0] == "vsrc":
# Create a single variable source
ra, dec, fwhm = float(toks[1])*np.pi/180, float(toks[2])*np.pi/180, float(toks[3])*np.pi/180/60
amps = [float(t) for t in toks[4].split(",")]
for i in range(nsim):
sim_srcs = bunch.Bunch(pos=np.array([[dec,ra]]),amps=np.array([[amps[i],0,0,0]]), beam=np.array([fwhm/(8*np.log(2)**0.5)]))
scans.append(scansim.SimSrcs(sim_bore[i], sim_dets[i], sim_srcs, sim_nmat[i], seed=seed+i, noise_scale=noise_scale, nsigma=20))
elif toks[0] == "cmb":
np.random.seed(seed)
ps = powspec.read_spectrum(toks[1])
sim_map = enmap.rand_map(area.shape, area.wcs, ps)
for i in range(nsim):
scans.append(scansim.SimMap(sim_bore[i], sim_dets[i], sim_map, sim_nmat[i], seed=seed+i, noise_scale=noise_scale))
else: raise ValueError
return scans
def get_scans(area, signal, bore, dets, noise, seed=0, real=None):
scans = []
# Get real scan information if necessary
L.debug("real")
if real:
real_scans = []
toks = real.split(":")
filelist, fslice = toks[0], ":".join(toks[1:])
filelist = [
line.split()[0] for line in open(filelist, "r") if line[0] != "#"
]
filelist = eval("filelist" + fslice)
db = filedb.ACTdb(config.get("filedb"))
for id in filelist:
try:
real_scans.append(data.ACTScan(db[id]))
except errors.DataMissing as e:
L.debug("Skipped %s (%s)" % (filelist[ind], e.message))
# Dets
L.debug("dets")
sim_dets = []
toks = dets.split(":")
if toks[0] == "scattered":
ngroup, nper, rad = int(toks[1]), int(toks[2]), float(toks[3])
sim_dets = [
scansim.dets_scattered(ngroup, nper, rad=rad * np.pi / 180 / 60)
]
margin = rad * np.pi / 180 / 60
elif toks[0] == "real":
ndet = int(toks[1])
dslice = slice(0, ndet) if ndet > 0 else slice(None)
sim_dets = [
bunch.Bunch(comps=s.comps[dslice], offsets=s.offsets[dslice])
for s in real_scans
]
margin = np.max([np.sum(s.offsets**2, 1)**0.5 for s in sim_dets])
else:
raise ValueError
# Boresight. Determines our number of scans
L.debug("bore")
sim_bore = []
toks = bore.split(":")
if toks[0] == "grid":
nscan, density, short = int(toks[1]), float(toks[2]), float(toks[3])
for i in range(nscan):
tbox = shorten(area.box(), i % 2, short)
sim_bore.append(
scansim.scan_grid(tbox,
density * np.pi / 180 / 60,
dir=i,
margin=margin))
elif toks[0] == "real":
sim_bore = [
bunch.Bunch(boresight=s.boresight,
sys=s.sys,
site=s.site,
mjd0=s.mjd0) for s in real_scans
]
else:
raise ValueError
nsim = len(sim_bore)
# Make one det info per scan
sim_dets = sim_dets * (nsim / len(sim_dets)) + sim_dets[:nsim %
len(sim_dets)]
# Noise
L.debug("noise")
sim_nmat = []
toks = noise.split(":")
noiseless = False
if toks[0] == "1/f":
sigma, alpha, fknee = [float(v) for v in toks[1:4]]
noiseless = sigma < 0
for i in range(nsim):
sim_nmat.append(
scansim.oneoverf_noise(sim_dets[i].comps.shape[0],
sim_bore[i].boresight.shape[0],
sigma=np.abs(sigma),
alpha=alpha,
fknee=fknee))
elif toks[0] == "detcorr":
sigma, alpha, fknee = [float(v) for v in toks[1:4]]
noiseless = sigma < 0
for i in range(nsim):
sim_nmat.append(
scansim.oneoverf_detcorr_noise(sim_dets[i].comps.shape[0],
sim_bore[i].boresight.shape[0],
sigma=np.abs(sigma),
alpha=alpha,
fknee=fknee))
elif toks[0] == "real":
scale = 1.0 if len(toks) < 2 else float(toks[1])
for i, s in enumerate(real_scans):
ndet = len(sim_dets[i].offsets)
nmat = s.noise[:ndet] * scale**-2
sim_nmat.append(nmat)
else:
raise ValueError
sim_nmat = sim_nmat * (nsim / len(sim_nmat)) + sim_nmat[:nsim %
len(sim_nmat)]
# Signal
L.debug("signal")
toks = signal.split(":")
if toks[0] == "ptsrc":
# This one always operates in the same coordinates as
nsrc, amp, fwhm = int(toks[1]), float(toks[2]), float(toks[3])
sim_srcs = scansim.rand_srcs(area.box(),
nsrc,
amp,
abs(fwhm) * np.pi / 180 / 60,
rand_fwhm=fwhm < 0)
for i in range(nsim):
scans.append(
scansim.SimSrcs(sim_bore[i],
sim_dets[i],
sim_srcs,
sim_nmat[i],
seed=seed + i,
nonoise=noiseless))
elif toks[0] == "cmb":
np.random.seed(seed)
ps = powspec.read_spectrum(toks[1])
sim_map = enmap.rand_map(area.shape, area.wcs, ps)
for i in range(nsim):
scans.append(
scansim.SimMap(sim_bore[i],
sim_dets[i],
sim_map,
sim_nmat[i],
seed=seed + i,
nonoise=noiseless))
else:
raise ValueError
return scans
