ofile.write("#%29s %4s %9s\n" % ("id", "ndet", "nsamp"))
for id, ndet, nsamp in zip(read_ids, read_ndets, read_nsamp):
ofile.write("%30s %4d %9d\n" % (id, ndet, nsamp))
# Reuse our signal stuff from ML mapmaking to make working with both normal and distributed
# maps easier. This also sets up our pointing matrix.
if dist:
geo = dmap.geometry(shape,
wcs,
bbox=data.bbox,
tshape=(tsize, tsize),
dtype=dtype,
comm=comm)
signal = mapmaking.SignalDmap(data.scans,
data.subs,
dmap.zeros(geo),
sys=msys,
name="sky")
else:
signal = mapmaking.SignalMap(data.scans,
enmap.zeros(shape, wcs, dtype),
comm,
sys=msys,
name="sky")
# Set up our output maps
rhs = signal.zeros()
div = signal.zeros(mat=True)
hit = signal.zeros()
rhs_work = signal.prepare(rhs)
div_work = signal.prepare(div)
if not is_dmap: imap = enmap.read_map(args.imap)
else: imap = dmap.read_map(args.imap, bbox=mybbox, tshape=tshape, comm=comm)
dtype = "=f" if imap.dtype == np.float32 else "=d"
imap = imap.astype(dtype, copy=True)
L.info("Initializing signals")
signal_cut = mapmaking.SignalCut(myscans, imap.dtype, comm=comm)
if not is_dmap:
signal_map = mapmaking.SignalMap(myscans, imap, comm=comm)
precon = mapmaking.PreconMapBinned(signal_map,
signal_cut,
myscans, [],
noise=False,
hits=False)
else:
signal_map = mapmaking.SignalDmap(myscans, mysubs, imap, sys=args.sys)
precon = mapmaking.PreconDmapBinned(signal_map,
signal_cut,
myscans, [],
noise=False,
hits=False)
# We can now actually perform the postfilter
L.info("Postfiltering")
postfilter = mapmaking.PostPickup(myscans,
signal_map,
signal_cut,
precon,
daz=args.daz,
nt=args.nt,
weighted=args.weighted,
#### 3. Process our tods ####
apply_window = mapmaking.FilterWindow(config.get("tod_window"))
if not use_dmap: area = enmap.zeros(wshape, wcs, dtype)
else:
geo = dmap.DGeometry(wshape,
wcs,
dtype=dtype,
bbox=mybbox,
comm=comm)
area = dmap.zeros(geo)
# Set up our signal. We do this instead of building the pmat manually
# to make it easy to support both maps and dmaps
if not use_dmap: signal = mapmaking.SignalMap(myscans, area, comm)
else: signal = mapmaking.SignalDmap(myscans, mysubs, area, comm)
# Get the input sky map that we will subtract. We do this because the CMB+CIB
# are the same from tod to tod, but we can't support intra-tod correlated noise,
# so we have to get rid of it. This is not optimal, but it shouldn't be far off.
if args.mapsub:
sshape, swcs = enmap.read_map_geometry(args.mapsub)
pixbox = enmap.pixbox_of(swcs, shape, wcs)
if not use_dmap:
refmap = enmap.read_map(args.mapsub,
pixbox=pixbox).astype(dtype)
else:
refmap = dmap.read_map(args.mapsub,
pixbox=pixbox,
bbox=mybbox,
comm=comm).astype(dtype)
area,
comm=comm,
name=effname,
ofmt=param["ofmt"],
output=param["output"] == "yes",
sys=param["sys"])
elif param["type"] == "dmap":
area = dmap.read_map(param["value"],
bbox=mybbox,
tshape=tshape,
comm=comm)
area = dmap.zeros(area.geometry.aspre(args.ncomp).astype(dtype))
signal = mapmaking.SignalDmap(active_scans,
mysubs,
area,
name=effname,
ofmt=param["ofmt"],
output=param["output"] == "yes",
sys=param["sys"])
elif param["type"] == "fdmap":
area = dmap.read_map(param["value"],
bbox=mybbox,
tshape=tshape,
comm=comm)
area = dmap.zeros(area.geometry.aspre(args.ncomp).astype(dtype))
signal = mapmaking.SignalDmapFast(active_scans,
mysubs,
area,
name=effname,
ofmt=param["ofmt"],
output=param["output"] == "yes",
active_scans = apply_scan_limits(myscans, param)
if param["type"] == "cut":
signal = mapmaking.SignalCut(active_scans, dtype=dtype, comm=comm, name=effname, ofmt=param["ofmt"], output=param["output"]=="yes")
signal_cut = signal
elif param["type"] == "map":
area = enmap.read_map(get_map_path(param["value"]))
area = enmap.zeros((args.ncomp,)+area.shape[-2:], area.wcs, dtype)
signal = mapmaking.SignalMap(active_scans, area, comm=comm, name=effname, ofmt=param["ofmt"], output=param["output"]=="yes", sys=param["sys"], extra=setup_extra_transforms(param))
elif param["type"] == "fmap":
area = enmap.read_map(get_map_path(param["value"]))
area = enmap.zeros((args.ncomp,)+area.shape[-2:], area.wcs, dtype)
signal = mapmaking.SignalMapFast(active_scans, area, comm=comm, name=effname, ofmt=param["ofmt"], output=param["output"]=="yes", sys=param["sys"], extra=setup_extra_transforms(param))
elif param["type"] == "dmap":
area = dmap.read_map(get_map_path(param["value"]), bbox=mybbox, tshape=tshape, comm=comm)
area = dmap.zeros(area.geometry.aspre(args.ncomp).astype(dtype))
signal = mapmaking.SignalDmap(active_scans, mysubs, area, name=effname, ofmt=param["ofmt"], output=param["output"]=="yes", sys=param["sys"], extra=setup_extra_transforms(param))
elif param["type"] == "fdmap":
area = dmap.read_map(get_map_path(param["value"]), bbox=mybbox, tshape=tshape, comm=comm)
area = dmap.zeros(area.geometry.aspre(args.ncomp).astype(dtype))
signal = mapmaking.SignalDmapFast(active_scans, mysubs, area, name=effname, ofmt=param["ofmt"], output=param["output"]=="yes", sys=param["sys"], extra=setup_extra_transforms(param))
elif param["type"] == "bmap":
area = enmap.read_map(get_map_path(param["value"]))
area = enmap.zeros((args.ncomp,)+area.shape[-2:], area.wcs, dtype)
signal = mapmaking.SignalMapBuddies(active_scans, area, comm=comm, name=effname, ofmt=param["ofmt"], output=param["output"]=="yes", sys=param["sys"], extra=setup_extra_transforms(param))
elif param["type"] == "scan":
res = float(param["res"])*utils.arcmin
tol = float(param["tol"])*utils.degree
col_major = True
patterns, mypids = scanutils.classify_scanning_patterns(active_scans, comm=comm, tol=tol)
L.info("Found %d scanning patterns" % len(patterns))
if comm.rank == 0: