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)
hit_work = signal.prepare(hit)
# Input for div calculation
div_tmp = signal.work()
def filter_common_mean(scan, tod):
myinds,
actscan.ACTScan,
filedb.data,
dets=args.dets,
downsample=config.get("downsample"))
L.info("Reading input map")
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")
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(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"])
elif param["type"] == "fmap":
area = enmap.read_map(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"])
elif param["type"] == "dmap":
si, id = tasks[ti]
bid = id.replace(":", "_")
L.info("Processing src %3d id %s" % (si, id))
root = args.odir + "/src%03d_%s_" % (si, bid)
entry = filedb.data[id]
osys = "hor:%.6f_%.6f:cel/0_0:hor" % tuple(srcs[:2, si])
try:
scans = [actscan.ACTScan(entry)]
if scans[0].nsamp == 0 or scans[0].ndet == 0:
raise errors.DataMissing("no data in scan")
except errors.DataMissing as e:
print "Skipping %s: %s" % (id, str(e))
continue
# Signals
signal_cut = mapmaking.SignalCut(scans, dtype=dtype, comm=tcomm)
signal_map = mapmaking.SignalMap(scans, area, comm=tcomm, sys=osys)
# Weights
weights = [mapmaking.FilterWindow(config.get("tod_window"))]
# And equation system
eqsys = mapmaking.Eqsys(scans, [signal_cut, signal_map],
weights=weights,
dtype=dtype,
comm=tcomm)
eqsys.calc_b()
# Precons
signal_cut.precon = mapmaking.PreconCut(signal_cut, scans)
signal_map.precon = mapmaking.PreconMapBinned(signal_map, signal_cut,
scans, weights)
cg = CG(eqsys.A, eqsys.b, M=eqsys.M, dot=eqsys.dot)
while cg.i < nmax:
planet9.cut_asteroids_scan(scan, asteroids)
#### 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,
white_src_handler = mapmaking.SourceHandler(myscans, comm, dtype=dtype, **src_handling)
else: white_src_handler = None
# 1. Initialize signals
L.info("Initializing signals")
signals = []
for param in signal_params:
effname = get_effname(param)
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)