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)