def __init__(self, GD, npix, cell_size_rad):
self._slvr_cfg = slvr_cfg = montblanc.rime_solver_cfg(
data_source=Options.DATA_SOURCE_DEFAULT,
tf_server_target=GD["Montblanc"]["TensorflowServerTarget"],
mem_budget=2 * 1024 * 1024 * 1024,
dtype='double',
auto_correlations=False,
version='tf')
self._solver = montblanc.rime_solver(slvr_cfg)
self._cell_size_rad = cell_size_rad
self._npix = npix
self._mgr = DataDictionaryManager()
# Configure the Beam upfront
if GD["Beam"]["Model"] == "FITS":
fits_file_spec = GD["Beam"]["FITSFile"]
l_axis = GD["Beam"]["FITSLAxis"]
m_axis = GD["Beam"]["FITSMAxis"]
self._beam_prov = FitsBeamSourceProvider(fits_file_spec,
l_axis=l_axis,
m_axis=m_axis)
else:
self._beam_prov = None
def simulate(src_provs, snk_provs, opts):
"""
Convenience function which creates and executes a Montblanc solver for the given source and
sink providers.
Args:
src_provs (list):
List of :obj:`~montblanc.impl.rime.tensorflow.sources.SourceProvider` objects. See
Montblanc's documentation.
snk_provs (list):
List of :obj:`~montblanc.impl.rime.tensorflow.sinks.SinkProvider` objects. See
Montblanc's documentation.
opts (dict):
Montblanc simulation options (see [montblanc] section in DefaultParset.cfg).
"""
global _mb_slvr
if _mb_slvr is None:
slvr_cfg = montblanc.rime_solver_cfg(
mem_budget=opts["mem-budget"] * 1024 * 1024,
dtype=opts["dtype"],
polarisation_type=opts["feed-type"],
device_type=opts["device-type"])
_mb_slvr = montblanc.rime_solver(slvr_cfg)
_mb_slvr.solve(source_providers=src_provs, sink_providers=snk_provs)
def get_v5_output(self, slvr_cfg, **kwargs):
# Get visibilities from the v5 solver
slvr_cfg = slvr_cfg.copy()
slvr_cfg.update(**kwargs)
slvr_cfg[Options.VERSION] = Options.VERSION_FIVE
with FitsBeam(base_beam_file) as fb:
beam_shape = fb.shape
slvr_cfg[Options.E_BEAM_WIDTH] = beam_shape[0]
slvr_cfg[Options.E_BEAM_HEIGHT] = beam_shape[1]
slvr_cfg[Options.E_BEAM_DEPTH] = beam_shape[2]
with montblanc.rime_solver(slvr_cfg) as slvr:
slvr.lm[:,0] = _L
slvr.lm[:,1] = _M
slvr.stokes[:,:,0] = _I
slvr.stokes[:,:,1] = _Q
slvr.stokes[:,:,2] = _U
slvr.stokes[:,:,3] = _V
slvr.alpha[:] = _ALPHA
slvr.ref_frequency[:] = _REF_FREQ
pa_sin = np.sin(slvr.parallactic_angles)[np.newaxis,:]
pa_cos = np.cos(slvr.parallactic_angles)[np.newaxis,:]
l = slvr.lm[:,0,np.newaxis]*pa_cos - slvr.lm[:,1,np.newaxis]*pa_sin;
m = slvr.lm[:,0,np.newaxis]*pa_sin + slvr.lm[:,1,np.newaxis]*pa_cos;
fb.reconfigure_frequency_axes(slvr.frequency)
# Configure the beam from the FITS file
slvr.E_beam.real[:] = fb.real()
slvr.E_beam.imag[:] = fb.imag()
# Configure the beam extents
ll, lm, lf, ul, um, uf = fb.beam_extents
slvr.set_beam_ll(ll)
slvr.set_beam_lm(lm)
slvr.set_beam_lfreq(lf)
slvr.set_beam_ul(ul)
slvr.set_beam_um(um)
slvr.set_beam_ufreq(uf)
slvr.solve()
import pyrap.tables as pt
query = " ".join(["FIELD_ID=0",
"" if slvr.is_autocorrelated() else "AND ANTENNA1 != ANTENNA2",
"ORDERBY TIME, ANTENNA1, ANTENNA2, "
"[SELECT SPECTRAL_WINDOW_ID FROM ::DATA_DESCRIPTION][DATA_DESC_ID]"])
# Dump visibilities in CORRECTED_DATA
with pt.table(msfile, ack=False, readonly=False).query(query) as ms:
ms.putcol('CORRECTED_DATA', slvr.model_vis.reshape(-1, slvr.dim_global_size('nchan'), 4))
return slvr.X2, slvr.model_vis.copy()
def get_v2_output(self, slvr_cfg, **kwargs):
# Get visibilities from the v2 solver
slvr_cfg = slvr_cfg.copy()
slvr_cfg.update(**kwargs)
slvr_cfg[Options.VERSION] = Options.VERSION_TWO
with montblanc.rime_solver(slvr_cfg) as slvr:
# Create and transfer lm to the solver
lm = np.empty(shape=slvr.lm.shape, dtype=slvr.lm.dtype)
l, m = lm[0,:], lm[1,:]
l[:] = _L
m[:] = _M
slvr.transfer_lm(lm)
# Create and transfer brightness to the solver
B = np.empty(shape=slvr.brightness.shape, dtype=slvr.brightness.dtype)
I, Q, U, V, alpha = B[0,:,:], B[1,:,:], B[2,:,:], B[3,:,:], B[4,:,:]
I[:] = _I
Q[:] = _Q
U[:] = _U
V[:] = _V
alpha[:] = _ALPHA
slvr.transfer_brightness(B)
# Set the reference wavelength
ref_wave = montblanc.constants.C / np.full(slvr.ref_wavelength.shape,
_REF_FREQ)
slvr.transfer_ref_wavelength(ref_wave.astype(slvr.ref_wavelength.dtype))
slvr.solve()
return slvr.X2, slvr.retrieve_model_vis().transpose(1,2,3,0)
def __init__(self, GD, npix, cell_size_rad, MS, pointing_sols):
shndlrs = filter(lambda x: isinstance(x, logging.StreamHandler),
montblanc.log.handlers)
montblanc.log.propagate = False
log_levels = {
"NOTSET": logging.NOTSET,
"DEBUG": logging.DEBUG,
"INFO": logging.INFO,
"WARNING": logging.WARNING,
"ERROR": logging.ERROR,
"CRITICAL": logging.CRITICAL
}
for s in shndlrs:
s.level = log_levels.get(GD["Montblanc"]["LogLevel"],
logging.WARNING)
apnd = "a" if GD["Log"]["Append"] else "w"
lgname = GD["Output"]["Name"] + ".montblanc.log" \
if GD["Montblanc"]["LogFile"] is None else GD["Montblanc"]["LogFile"]
fhndlr = logging.FileHandler(lgname, mode=apnd)
fhndlr.level = logging.DEBUG
montblanc.log.addHandler(fhndlr)
# configure solver
self._mgr = DataDictionaryManager(MS, pointing_sols)
self._slvr_cfg = slvr_cfg = montblanc.rime_solver_cfg(
data_source="default",
polarisation_type=self._mgr._solver_polarization_type,
mem_budget=int(
np.ceil(GD["Montblanc"]["MemoryBudget"] * 1024 * 1024 * 1024)),
dtype=GD["Montblanc"]["SolverDType"],
auto_correlations=True,
version=GD["Montblanc"]["DriverVersion"])
self._solver = montblanc.rime_solver(slvr_cfg)
self._cell_size_rad = cell_size_rad
self._npix = npix
# Configure the Beam upfront
if GD["Beam"]["Model"] == "FITS":
fits_file_spec = GD["Beam"]["FITSFile"]
l_axis = GD["Beam"]["FITSLAxis"]
m_axis = GD["Beam"]["FITSMAxis"]
self._beam_prov = FitsBeamSourceProvider(fits_file_spec,
l_axis=l_axis,
m_axis=m_axis)
else:
self._beam_prov = None
import argparse
parser = argparse.ArgumentParser(description='RIME MS test script')
parser.add_argument('msfile', help='Measurement Set File')
parser.add_argument('-v','--version',dest='version', type=str,
default=Options.VERSION_FOUR, choices=Options.VALID_VERSIONS,
help='RIME Pipeline Version.')
args = parser.parse_args(sys.argv[1:])
# Get the solver.
slvr_cfg = montblanc.rime_solver_cfg(msfile=args.msfile,
sources=montblanc.sources(point=1, gaussian=0, sersic=0),
dtype='double', version=args.version)
with montblanc.rime_solver(slvr_cfg) as slvr:
if args.version in [Options.VERSION_TWO]:
lm = np.empty(shape=slvr.lm.shape, dtype=slvr.lm.dtype)
l, m = lm[0,:], lm[1,:]
l[:] = 0.1
m[:] = 0.25
slvr.transfer_lm(lm)
B = np.empty(shape=slvr.brightness.shape, dtype=slvr.brightness.dtype)
I, Q, U, V, alpha = B[0,:,:], B[1,:,:], B[2,:,:], B[3,:,:], B[4,:,:]
I[:] = 2
Q[:] = 1
U[:] = 1
V[:] = 1
alpha[:] = 0.5
def get_v4_output(self, slvr_cfg, **kwargs):
# Get visibilities from the v4 solver
gpu_slvr_cfg = slvr_cfg.copy()
gpu_slvr_cfg.update(**kwargs)
gpu_slvr_cfg[Options.VERSION] = Options.VERSION_FOUR
with FitsBeam(base_beam_file) as fb:
beam_shape = fb.shape
gpu_slvr_cfg[Options.E_BEAM_WIDTH] = beam_shape[0]
gpu_slvr_cfg[Options.E_BEAM_HEIGHT] = beam_shape[1]
gpu_slvr_cfg[Options.E_BEAM_DEPTH] = beam_shape[2]
from montblanc.impl.rime.v4.cpu.CPUSolver import CPUSolver
with montblanc.rime_solver(gpu_slvr_cfg) as slvr:
cpu_slvr_cfg = slvr.config().copy()
cpu_slvr_cfg[Options.DATA_SOURCE] = Options.DATA_SOURCE_EMPTY
cpu_slvr = CPUSolver(cpu_slvr_cfg)
# Create and transfer lm to the solver
lm = np.empty(shape=slvr.lm.shape, dtype=slvr.lm.dtype)
l, m = lm[:,0], lm[:,1]
l[:] = _L
m[:] = _M
slvr.transfer_lm(lm)
# Create and transfer stoke and alpha to the solver
stokes = np.empty(shape=slvr.stokes.shape, dtype=slvr.stokes.dtype)
alpha = np.empty(shape=slvr.alpha.shape, dtype=slvr.alpha.dtype)
I, Q, U, V = stokes[:,:,0], stokes[:,:,1], stokes[:,:,2], stokes[:,:,3]
I[:] = _I
Q[:] = _Q
U[:] = _U
V[:] = _V
alpha[:] = _ALPHA
slvr.transfer_stokes(stokes)
slvr.transfer_alpha(alpha)
fb.reconfigure_frequency_axes(slvr.retrieve_frequency())
# Create the beam from FITS file
ebeam = np.zeros(shape=slvr.E_beam.shape, dtype=slvr.E_beam.dtype)
ebeam.real[:] = fb.real()
ebeam.imag[:] = fb.imag()
slvr.transfer_E_beam(ebeam)
# Configure the beam extents
ll, lm, lf, ul, um, uf = fb.beam_extents
slvr.set_beam_ll(ll)
slvr.set_beam_lm(lm)
slvr.set_beam_lfreq(lf)
slvr.set_beam_ul(ul)
slvr.set_beam_um(um)
slvr.set_beam_ufreq(uf)
# Set the reference frequency
ref_freq = np.full(slvr.ref_frequency.shape, _REF_FREQ, dtype=slvr.ref_frequency.dtype)
slvr.transfer_ref_frequency(ref_freq)
from montblanc.solvers import copy_solver
copy_solver(slvr, cpu_slvr)
cpu_slvr.compute_E_beam()
slvr.solve()
return slvr.X2, slvr.retrieve_model_vis()
def run_test(msfile, pol_type, **kwargs):
"""
Parameters
----------
msfile : str
Name of the Measurement Set
pol_type : str
'linear' or 'circular'
beam_file_schema (optional) : str
Beam filename schema. Defaults to 'test_beam_$(corr)_$(reim).fits'
overwrite_beams (optional) : bool
If ``True`` create new beams using the cos**3 beam
"""
#=========================================
# Directory and Script Configuration
#=========================================
# Directory in which we expect our measurement set to be located
meq_vis_column = 'MODEL_DATA'
mb_vis_column = 'CORRECTED_DATA'
# Directory in which meqtree-related files are read/written
meq_dir = 'meqtrees'
# Scripts
meqpipe = 'meqtree-pipeliner.py'
# Meqtree profile and script
cfg_file = os.path.join(meq_dir, 'tdlconf.profiles')
sim_script = os.path.join(meq_dir, 'turbo-sim.py')
tigger_sky_file = os.path.join(meq_dir, 'sky_model.txt')
# Is the beam enabled
beam_on = kwargs.get('beam_on', True)
beam_on = 1 if beam_on is True else 0
# Directory in which we expect our beams to be located
beam_file_schema = 'test_beam_$(corr)_$(reim).fits'
# Beam file pattern
beam_file_schema = kwargs.get("beam_file_schema", beam_file_schema)
l_axis = kwargs.get('l_axis', '-X')
m_axis = kwargs.get('m_axis', 'Y')
# Find the location of the meqtree pipeliner script
meqpipe_actual = subprocess.check_output(['which', meqpipe]).strip()
cfg_section = '-'.join(('montblanc', 'compare', pol_type))
#======================================================
# Configure the beam files with frequencies from the MS
#======================================================
from montblanc.impl.rime.tensorflow.sources.fits_beam_source_provider import (
_create_filenames, _open_fits_files)
# Zero the visibility data
with pt.table(msfile, ack=False, readonly=False) as T:
data_desc = T.getcoldesc('DATA')
try:
shape = data_desc['shape'].tolist()
except KeyError:
shape = list(T.getcol('DATA', startrow=0, nrow=1).shape[1:])
shape = [T.nrows()] + shape
T.putcol(mb_vis_column, np.zeros(shape, dtype=np.complex64))
T.putcol(meq_vis_column, np.zeros(shape, dtype=np.complex64))
# Extract frequencies from the MS
with pt.table(msfile + '::SPECTRAL_WINDOW', ack=False) as SW:
frequency = SW.getcol('CHAN_FREQ')[0]
bandwidth = frequency[-1] - frequency[0]
overwrite_beams = kwargs.get('overwrite_beams', False)
# Get filenames from pattern and open the files
filenames = beam_factory(polarisation_type=pol_type,
frequency=frequency,
schema=beam_file_schema,
overwrite=overwrite_beams)
#=========================================
# Source Configuration
#=========================================
np.random.seed(0)
dtype = np.float64
ctype = np.complex128 if dtype == np.float64 else np.complex64
def get_point_sources(nsrc):
source_coords = np.empty(shape=(nsrc, 2), dtype=dtype)
stokes = np.empty(shape=(nsrc, 4), dtype=dtype)
I, Q, U, V = stokes[:,0], stokes[:,1], stokes[:,2], stokes[:,3]
alphas = np.empty(shape=(nsrc,), dtype=dtype)
ref_freq = np.empty(shape=(nsrc,), dtype=dtype)
# Source coordinates between -45 and 45 degrees
source_coords[:] = (rf(size=source_coords.shape) - 0.5)*90.0
Q[:] = rf(size=Q.shape)*0.1
U[:] = rf(size=U.shape)*0.1
V[:] = rf(size=V.shape)*0.1
I[:] = np.sqrt(Q**2 + U**2 + V**2)*1.5 + rf(size=I.shape)*0.1
# Zero and invert selected stokes parameters
if nsrc > 0:
zero_srcs = np.random.randint(nsrc, size=(2,))
source_coords[zero_srcs,:] = 0
# Create sources with both positive and negative flux
sign = 2*np.random.randint(2, size=I.shape) - 1
I[:] *= sign
alphas[:] = 2*(np.random.random(size=alphas.size) - 0.5)
ref_freq[:] = 1.3e9 + np.random.random(ref_freq.size)*0.2e9
return (np.deg2rad(source_coords), np.asarray(stokes),
np.asarray(alphas), np.asarray(ref_freq))
def get_gaussian_sources(nsrc):
c, s, a, r= get_point_sources(nsrc)
gauss_shape = np.empty(shape=(3, nsrc), dtype=np.float64)
gauss_shape[:] = rf(size=gauss_shape.shape)
return c, s, a, r, gauss_shape
npsrc, ngsrc = 10, 10
pt_lm, pt_stokes, pt_alpha, pt_ref_freq = get_point_sources(npsrc)
assert pt_lm.shape == (npsrc, 2), pt_lm.shape
assert pt_stokes.shape == (npsrc, 4), pt_stokes.shape
assert pt_alpha.shape == (npsrc,), pt_alpha.shape
assert pt_ref_freq.shape == (npsrc,), pt_ref_freq.shape
g_lm, g_stokes, g_alpha, g_ref_freq, g_shape = get_gaussian_sources(ngsrc)
#=========================================
# Create Tigger ASCII sky model
#=========================================
from Tigger.Models.Formats.AIPSCCFITS import lm_to_radec
# Need the phase centre for lm_to_radec
with pt.table(msfile + '::FIELD', ack=False, readonly=True) as F:
ra0, dec0 = F.getcol('PHASE_DIR')[0][0]
# Create the tigger sky model
with open(tigger_sky_file, 'w') as f:
f.write('#format: ra_d dec_d i q u v spi freq0 emaj_s emin_s pa_d\n')
it = enumerate(itertools.izip(pt_lm, pt_stokes, pt_alpha, pt_ref_freq))
for i, ((l, m), (I, Q, U, V), alpha, ref_freq) in it:
ra, dec = lm_to_radec(l, m, ra0, dec0)
l, m = np.rad2deg([ra,dec])
f.write('{l:.20f} {m:.20f} {i} {q} {u} {v} {spi} {rf:.20f}\n'.format(
l=l, m=m, i=I, q=Q, u=U, v=V, spi=alpha, rf=ref_freq))
it = enumerate(itertools.izip(g_lm, g_stokes, g_alpha, g_ref_freq, g_shape.T))
for i, ((l, m), (I, Q, U, V), alpha, ref_freq, (emaj, emin, pa)) in it:
ra, dec = lm_to_radec(l, m, ra0, dec0)
l, m = np.rad2deg([ra,dec])
# Convert to seconds
emaj, emin = np.asarray([emaj, emin])*648000./np.pi
# Convert to degrees
pa *= 180.0/np.pi
f.write('{l:.20f} {m:.20f} {i} {q} {u} {v} {spi} {rf:.20f} '
'{emaj} {emin} {pa}\n'.format(
l=l, m=m, i=I, q=Q, u=U, v=V, spi=alpha, rf=ref_freq,
emaj=emaj, emin=emin, pa=pa))
#=========================================
# Call MeqTrees
#=========================================
cmd_list = ['python',
# Meqtree Pipeline script
meqpipe_actual,
# Configuration File
'-c', cfg_file,
# Configuration section
'[{section}]'.format(section=cfg_section),
# Enable the beam?
'me.e_enable = {e}'.format(e=beam_on),
# Measurement Set
'ms_sel.msname={ms}'.format(ms=msfile),
# Tigger sky file
'tiggerlsm.filename={sm}'.format(sm=tigger_sky_file),
# Output column
'ms_sel.output_column={c}'.format(c=meq_vis_column),
# Imaging Column
'img_sel.imaging_column={c}'.format(c=meq_vis_column),
# Beam FITS file pattern
'pybeams_fits.filename_pattern={p}'.format(p=beam_file_schema),
# FITS L and M AXIS
'pybeams_fits.l_axis={l}'.format(l=l_axis),
'pybeams_fits.m_axis={m}'.format(m=m_axis),
sim_script,
'=simulate'
]
import montblanc
from montblanc.impl.rime.tensorflow.ms import MeasurementSetManager
from montblanc.impl.rime.tensorflow.sources import (SourceProvider,
MSSourceProvider,
FitsBeamSourceProvider,
CachedSourceProvider)
from montblanc.impl.rime.tensorflow.sinks import MSSinkProvider
class RadioSourceProvider(SourceProvider):
def name(self):
return "RadioSourceProvider"
def point_lm(self, context):
lp, up = context.dim_extents('npsrc')
return pt_lm[lp:up, :]
def point_stokes(self, context):
(lp, up), (lt, ut) = context.dim_extents('npsrc', 'ntime')
return np.tile(pt_stokes[lp:up, np.newaxis, :], [1, ut-lt, 1])
def point_alpha(self, context):
(lp, up), (lt, ut) = context.dim_extents('npsrc', 'ntime')
return np.tile(pt_alpha[lp:up, np.newaxis], [1, ut-lt])
def point_ref_freq(self, context):
(lp, up) = context.dim_extents('npsrc')
return pt_ref_freq[lp:up]
def gaussian_lm(self, context):
lg, ug = context.dim_extents('ngsrc')
return g_lm[lg:ug, :]
def gaussian_stokes(self, context):
(lg, ug), (lt, ut) = context.dim_extents('ngsrc', 'ntime')
return np.tile(g_stokes[lg:ug, np.newaxis, :], [1, ut-lt, 1])
def gaussian_alpha(self, context):
(lg, ug), (lt, ut) = context.dim_extents('ngsrc', 'ntime')
return np.tile(g_alpha[lg:ug, np.newaxis], [1, ut-lt])
def gaussian_ref_freq(self, context):
(lg, ug) = context.dim_extents('ngsrc')
return g_ref_freq[lg:ug]
def gaussian_shape(self, context):
(lg, ug) = context.dim_extents('ngsrc')
gauss_shape = g_shape[:,lg:ug]
emaj = gauss_shape[0]
emin = gauss_shape[1]
pa = gauss_shape[2]
gauss = np.empty(context.shape, dtype=context.dtype)
gauss[0,:] = emaj * np.sin(pa)
gauss[1,:] = emaj * np.cos(pa)
emaj[emaj == 0.0] = 1.0
gauss[2,:] = emin / emaj
return gauss
def updated_dimensions(self):
return [('npsrc', pt_lm.shape[0]), ('ngsrc', g_lm.shape[0])]
slvr_cfg = montblanc.rime_solver_cfg(
mem_budget=1024*1024*1024,
data_source='default',
dtype='double' if dtype == np.float64 else 'float',
polarisation_type=pol_type,
auto_correlations=False,
version='tf')
slvr = montblanc.rime_solver(slvr_cfg)
ms_mgr = MeasurementSetManager(msfile, slvr_cfg)
source_providers = []
source_providers.append(MSSourceProvider(ms_mgr))
if beam_on == 1:
beam_prov = FitsBeamSourceProvider(beam_file_schema,
l_axis=l_axis, m_axis=m_axis)
source_providers.append(beam_prov)
source_providers.append(RadioSourceProvider())
cache_prov = CachedSourceProvider(source_providers)
source_providers = [cache_prov]
sink_providers = [MSSinkProvider(ms_mgr, mb_vis_column)]
slvr.solve(source_providers=source_providers,
sink_providers=sink_providers)
import time
time.sleep(1)
for obj in source_providers + sink_providers + [ms_mgr]:
obj.close()
# Call the meqtrees simulation script, dumping visibilities into MODEL_DATA
subprocess.call(cmd_list)
# Compare MeqTree and Montblanc visibilities
with pt.table(msfile, ack=False, readonly=True) as MS:
ntime, nbl, nchan = slvr.hypercube.dim_global_size('ntime', 'nbl', 'nchan')
shape = (ntime, nbl, nchan, 4)
meq_vis = MS.getcol(meq_vis_column).reshape(shape)
mb_vis = MS.getcol(mb_vis_column).reshape(shape)
# Compare
close = np.isclose(meq_vis, mb_vis)
not_close = np.invert(close)
problems = np.nonzero(not_close)
# Everything agrees, exit
if problems[0].size == 0:
print 'Montblanc and MeqTree visibilities agree'
sys.exit(1)
bad_vis_file = 'bad_visibilities.txt'
# Some visibilities differ, do some analysis
print ("Montblanc differs from MeqTrees by {nc}/{t} visibilities. "
"Writing them out to '{bvf}'").format(
nc=problems[0].size, t=not_close.size, bvf=bad_vis_file)
abs_diff = np.abs(meq_vis - mb_vis)
rmsd = np.sqrt(np.sum(abs_diff**2)/abs_diff.size)
nrmsd = rmsd / (np.max(abs_diff) - np.min(abs_diff))
print 'RMSD {rmsd} NRMSD {nrmsd}'.format(rmsd=rmsd, nrmsd=nrmsd)
# Plot a histogram of the difference
try:
import matplotlib
matplotlib.use('pdf')
import matplotlib.pyplot as plt
except:
print "Exception importing matplotlib %s" % sys.exc_info()[2]
else:
try:
nr_of_bins = 100
n, bins, patches = plt.hist(abs_diff.flatten(),
bins=np.logspace(np.log10(1e-10), np.log10(1.0), nr_of_bins))
plt.gca().set_xscale("log")
plt.xlabel('Magnitude Difference')
plt.ylabel('Counts')
plt.grid(True)
plt.savefig('histogram.pdf')
except:
print "Error plotting histogram %s" % sys.exc_info()[2]
mb_problems = mb_vis[problems]
meq_problems = meq_vis[problems]
difference = mb_problems - meq_problems
amplitude = np.abs(difference)
# Create an iterator over the first 100 problematic visibilities
t = (np.asarray(problems).T, mb_problems, meq_problems, difference, amplitude)
it = enumerate(itertools.izip(*t))
it = itertools.islice(it, 0, 1000, 1)
# Write out the problematic visibilities to file
with open(bad_vis_file, 'w') as f:
for i, (p, mb, meq, d, amp) in it:
f.write("{i} {t} Montblanc: {mb} MeqTrees: {meq} "
"Difference {d} Absolute Difference {ad} \n".format(
i=i, t=p, mb=mb, meq=meq, d=d, ad=amp))
# ----------------------------------------------------------------------------------------------------------------------
# Begin Montblanc configuration
global slvr, stokes
slvr_cfg = montblanc.rime_solver_cfg(msfile=args.msfile,
sources=montblanc.sources(point=0,
gaussian=0,
sersic=1),
init_weights=None,
weight_vector=False,
sersic_gradient=False,
dtype='double',
version='v4')
with montblanc.rime_solver(slvr_cfg) as slvr: # Read in observed visibilities
ntime = slvr.dim_local_size('ntime')
stokes = np.empty(shape=slvr.stokes.shape, dtype=slvr.stokes.dtype)
I = stokes[:, :, 0]
alpha = slvr.ft(np.ones(1 * ntime) * (-0.7)).reshape(1, ntime)
slvr.transfer_alpha(alpha)
# Let slvr know noise on visibilities, set visibility noise variance (muJy)
time_acc = 60
efficiency = 0.9
channel_bandwidth_hz = 240e6
SEFD = 400e6
sigma = (SEFD * SEFD) / (2. * time_acc * channel_bandwidth_hz *
efficiency * efficiency)
slvr.set_sigma_sqrd(sigma)
