def model_vis(self, context):
""" model visibility data sink """
column = self._vis_column
msshape = None
# Do we have a column descriptor for the supplied column?
try:
coldesc = self._manager.column_descriptors[column]
except KeyError as e:
coldesc = None
# Try to get the shape from the descriptor
if coldesc is not None:
try:
msshape = [-1] + coldesc['shape'].tolist()
except KeyError as e:
msshape = None
# Otherwise guess it and warn
if msshape is None:
guessed_shape = [self._manager._nchan, 4]
montblanc.log.warn("Could not obtain 'shape' from the '{c}' "
"column descriptor. Guessing it is '{gs}'.".format(
c=column, gs=guessed_shape))
msshape = [-1] + guessed_shape
lrow, urow = MS.row_extents(context)
self._manager.ordered_main_table.putcol(column,
context.data.reshape(msshape),
startrow=lrow, nrow=urow-lrow)
def model_vis(self, context):
""" Tells Montblanc how to handle the model visibility output. """
(lt, ut), (lbl,
ubl), (lc,
uc) = context.dim_extents('ntime', 'nbl', 'nchan')
lower, upper = MS.row_extents(context, ("ntime", "nbl"))
ntime, nbl, nchan = context.dim_global_size('ntime', 'nbl', 'nchan')
rows_per_ddid = ntime * nbl
chan_per_ddid = nchan / self._nddid
if self._ncorr == 1:
sel = 0
elif self._ncorr == 2:
sel = slice(None, None, 3)
else:
sel = slice(None)
for ddid_ind in xrange(self._nddid):
offset = ddid_ind * rows_per_ddid
lr = lower + offset
ur = upper + offset
lc = ddid_ind * chan_per_ddid
uc = (ddid_ind + 1) * chan_per_ddid
self._model[self._dir, 0, lr:ur, :, :] = \
context.data[:,:,lc:uc,sel].reshape(-1, chan_per_ddid, self._ncorr)
def flag(self, context):
""" Flag data source """
lrow, urow = MS.row_extents(context)
flag = self._manager.ordered_main_table.getcol(
MS.FLAG, startrow=lrow, nrow=urow-lrow)
return flag.reshape(context.shape).astype(context.dtype)
def observed_vis(self, context):
""" Observed visibility data source """
lrow, urow = MS.row_extents(context)
data = self._manager.ordered_main_table.getcol(
self._vis_column, startrow=lrow, nrow=urow-lrow)
return data.reshape(context.shape).astype(context.dtype)
def weight(self, context):
""" Weight data source """
lrow, urow = MS.row_extents(context)
weight = self._manager.ordered_main_table.getcol(
MS.WEIGHT, startrow=lrow, nrow=urow-lrow)
# WEIGHT is applied across all channels
weight = np.repeat(weight, self._manager.channels_per_band, 0)
return weight.reshape(context.shape).astype(context.dtype)
def uvw(self, context):
self.update_nchunks(context)
lrow, urow = MS.row_extents(context)
(lt, ut), (lb, ub) = context.dim_extents('ntime', 'nbl')
na = context.dim_global_size('na')
a1 = self._manager._padded_a1[lrow:urow]
a2 = self._manager._padded_a2[lrow:urow]
chunks = np.repeat(ub-lb, ut-lt).astype(a1.dtype)
return mbu.antenna_uvw(self._manager._padded_uvw[lrow:urow],
a1, a2, chunks, nr_of_antenna=na,
check_decomposition=False, check_missing=True)
def model_vis(self, context):
montblanc.log.debug("Model vis mean {m} sum {s}".format(
m=np.abs(context.data[:, :, :, 0]).mean(),
s=np.abs(context.data[:, :, :, 0]).sum()))
lrow, urow = MS.row_extents(context)
view = self._manager._residuals[lrow:urow, :, :]
montblanc.log.debug("Observed vis mean {m} sum {s}".format(
m=np.abs(view[:, :, 0]).mean(), s=np.abs(view[:, :, 0]).sum()))
# Compute residuals
view[:, :, :] -= context.data.reshape(view.shape)
montblanc.log.debug("Residual vis mean {m} sum {s}".format(
m=np.abs(view[:, :, 0]).mean(), s=np.abs(view[:, :, 0]).sum()))
def model_vis(self, context):
lrow, urow = MS.row_extents(context)
view = self._manager._residuals[lrow:urow,:,:]
view[:] = context.data.reshape(view.shape)
def model_vis(self, context):
lrow, urow = MS.row_extents(context)
# Get the sparce representation (sorted) selection for this chunk
datamask = self._manager._datamask[lrow:urow]
sparseindx = np.unique(self._manager._sparseindx[lrow:urow][datamask])
sort_indx = self._manager._sort_index[sparseindx]
nrow_sparce = sparseindx.size
nrow = urow - lrow
nchan = self._manager._nchan
ncorr_mb = 4 #montblanc always predict four correlations
sparce_flags = self._manager._flag[sort_indx, :, :]
# Compute residuals
chunk_nbl, chunk_ntime, chunk_nchan, chunk_ncorr = context.data.shape
chunk_nrow = chunk_nbl * chunk_ntime
datamask_tile = datamask.repeat(chunk_nchan * chunk_ncorr).reshape((chunk_nrow, chunk_nchan, chunk_ncorr))
mod = context.data.reshape((chunk_nrow, chunk_nchan, chunk_ncorr))
mod_sel = mod[datamask_tile].reshape(nrow_sparce, chunk_nchan, chunk_ncorr)
def __print_model_stats(mod_sel):
mod_sel_pow = np.abs(mod_sel)
montblanc.log.debug("\t MEAN: %s" % ",".join(
["%.3f" % x for x in np.nanmean(np.nanmean(mod_sel_pow,
axis=0),
axis=0)]))
montblanc.log.debug("\t MAX: %s" % ",".join(
["%.3f" % x for x in np.nanmax(np.nanmax(mod_sel_pow,
axis=0),
axis=0)]))
montblanc.log.debug("\t MIN: %s" % ",".join(
["%.3f" % x for x in np.nanmin(np.nanmin(mod_sel_pow,
axis=0),
axis=0)]))
montblanc.log.debug("\t STD: %s" % ",".join(
["%.3f" % x for x in np.nanstd(np.nanstd(mod_sel_pow,
axis=0),
axis=0)]))
if DEBUG:
montblanc.log.debug("Model stats:")
__print_model_stats(mod_sel)
def __print_residual_stats(prev, sparce_flags):
prev_fl = np.abs(prev)
prev_fl[sparce_flags] = np.nan
montblanc.log.debug("\t MEAN: %s" % ",".join(
["%.3f" % x for x in np.nanmean(np.nanmean(prev_fl,
axis=0),
axis=0)]))
montblanc.log.debug("\t MAX: %s" % ",".join(
["%.3f" % x for x in np.nanmax(np.nanmax(prev_fl,
axis=0),
axis=0)]))
montblanc.log.debug("\t MIN: %s" % ",".join(
["%.3f" % x for x in np.nanmin(np.nanmin(prev_fl,
axis=0),
axis=0)]))
montblanc.log.debug("\t STD: %s" % ",".join(
["%.3f" % x for x in np.nanstd(np.nanstd(prev_fl,
axis=0),
axis=0)]))
if DEBUG:
montblanc.log.debug("Old residual stats:")
__print_residual_stats(self._manager._residuals[sort_indx, :, :], sparce_flags)
if self._manager._data_feed_labels == self._manager._montblanc_feed_labels:
self._manager._residuals[sort_indx, :, :] -= mod_sel
else:
for ci, c in enumerate(self._manager._data_feed_labels):
self._manager._residuals[sort_indx, :, ci] -= mod_sel[:, :, self._manager._predict_feed_map[ci]]
if DEBUG:
montblanc.log.debug("New residual stats:")
__print_residual_stats(self._manager._residuals[sort_indx, :, :], sparce_flags)
# update progress
self._manager._numcomplete += nrow
self._manager.render_progressbar()
def antenna2(self, context):
self.update_nchunks(context)
lrow, urow = MS.row_extents(context)
view = self._manager._padded_a2[lrow:urow]
return view.reshape(context.shape).astype(context.dtype)
def antenna2(self, context):
lrow, urow = MS.row_extents(context)
view = self._manager._data['A1'][lrow:urow]
return view.reshape(context.shape).astype(context.dtype)