def rotate(self, sky_location):
from tart.simulation import antennas
stopped_vis = []
omega = self.config.get_operating_frequency() * 2.0 * np.pi
# Now we must do fringe stopping
loc = self.config.get_loc()
el, az = loc.equatorial_to_horizontal(self.timestamp, sky_location.ra,
sky_location.dec)
hsource = HorizontalSource(r=9.0e99, azimuth=az, elevation=el)
ant_pos = self.config.get_antenna_positions()
for v, b in zip(self.v, self.baselines):
a0 = antennas.Antenna(loc, ant_pos[b[0]])
a1 = antennas.Antenna(loc, ant_pos[b[1]])
tg = antennas.get_geo_delay_horizontal(a0, a1, hsource)
# tg is t_a1 - t_a0
# (negative if a1 is closer to source than a0)
# print(b, omega*tg)
v = v * np.exp(-1.0j * omega * tg)
stopped_vis.append(v)
self.phase_el = el
self.phase_az = az
self.v = stopped_vis
def setUp(self):
# rad = radio.Max2769B(noise_level=0.)
utc_date = datetime.datetime.utcnow()
self.config = settings.from_file(TEST_CONFIG)
self.config.load_antenna_positions(
cal_ant_positions_file=TEST_ANTENNA_POSITIONS)
rad = radio.Max2769B(
noise_level=[0.0 for _ in range(self.config.get_num_antenna())])
sources = [
simulation_source.SimulationSource(
r=1e9,
amplitude=1.0,
azimuth=angle.from_dms(2.0),
elevation=angle.from_dms(50.0),
sample_duration=rad.sample_duration,
)
]
ant_models = [
antenna_model.GpsPatchAntenna()
for i in range(self.config.get_num_antenna())
]
ants = [
antennas.Antenna(self.config.get_loc(), pos)
for pos in self.config.get_antenna_positions()
]
self.timebase = np.arange(0, rad.sample_duration,
1.0 / rad.sampling_rate)
ant_sigs = antennas.antennas_signal(ants, ant_models, sources,
self.timebase)
self.obs = rad.get_full_obs(ant_sigs, utc_date, self.config,
self.timebase)
def setUp(self):
self.utc_date = datetime.datetime.utcnow()
self.config = settings.from_file(TEST_CONFIG)
self.config.load_antenna_positions(
cal_ant_positions_file=TEST_ANTENNA_POSITIONS)
self.rad = radio.Max2769B(
noise_level=[0.0 for _ in range(self.config.get_num_antenna())])
self.sources = [
simulation_source.SimulationSource(
r=1e9,
amplitude=1.0,
azimuth=angle.from_dms(2.0),
elevation=angle.from_dms(50.0),
sample_duration=self.rad.sample_duration,
)
]
self.ants = [
antennas.Antenna(self.config.get_loc(), pos)
for pos in self.config.get_antenna_positions()
]
self.ant_models = [
antenna_model.GpsPatchAntenna()
for i in range(self.config.get_num_antenna())
]
self.cor = correlator.Correlator()
self.timebase = np.arange(0, self.rad.sample_duration,
1.0 / self.rad.sampling_rate)
ant_sigs_full = antennas.antennas_signal(self.ants, self.ant_models,
self.sources, self.timebase)
obs = self.rad.get_full_obs(ant_sigs_full, self.utc_date, self.config,
self.timebase)
vis = self.cor.correlate(obs)
self.full_vis = np.array(vis.v)
ant_sigs_simp = antennas.antennas_simplified_signal(
self.ants,
self.ant_models,
self.sources,
self.rad.baseband_timebase,
self.rad.int_freq,
)
obs = self.rad.get_simplified_obs(ant_sigs_simp,
self.utc_date,
config=self.config)
vis2 = self.cor.correlate(obs)
self.sim_vis = np.array(vis2.v)
plt.figure(figsize=(4, 4))
plt.scatter(self.full_vis.real, self.full_vis.imag, label="full")
plt.scatter(self.sim_vis.real,
self.sim_vis.imag,
color="red",
label="simpl")
plt.legend()
plt.show()
def setUp(self):
self.config = settings.from_file("./tart/test/test_telescope_config.json")
self.config.load_antenna_positions(
cal_ant_positions_file="./tart/test/test_calibrated_antenna_positions.json"
)
# noiselvls = 0.1.*np.ones(config.get_num_antenna())
num_ant = self.config.get_num_antenna()
noiselvls = 0.0 * np.ones(num_ant)
self.rad = Max2769B(noise_level=noiselvls)
self.sources = [
simulation_source.SimulationSource(
r=1e9,
amplitude=1.0,
azimuth=angle.from_dms(0.0),
elevation=angle.from_dms(90.0),
sample_duration=self.rad.sample_duration,
)
]
self.ants = [
antennas.Antenna(self.config.get_loc(), pos)
for pos in self.config.get_antenna_positions()
]
self.ant_models = [antenna_model.GpsPatchAntenna() for i in range(num_ant)]
self.utc_date = datetime.datetime.utcnow()
config = settings.Settings("../test/test_telescope_config.json")
num_ant = config.get_num_antenna()
noiselvls = 0.1 * np.ones(num_ant)
rad = Max2769B(n_samples=2**14, noise_level=noiselvls)
sources = [
simulation_source.SimulationSource(
amplitude=1.0,
azimuth=angle.from_dms(0.0),
elevation=angle.from_dms(90.0),
sample_duration=rad.sample_duration,
)
]
ants = [
antennas.Antenna(config.get_loc(), pos) for pos in config.ant_positions
]
ant_models = [antenna_model.GpsPatchAntenna() for i in range(num_ant)]
utc_date = datetime.datetime.utcnow()
plt.figure()
ant_sigs = antennas.antennas_signal(ants, ant_models, sources,
rad.timebase)
rad_sig_full = rad.sampled_signal(ant_sigs[0, :], 0, rad.sample_duration)
obs_full = rad.get_full_obs(ant_sigs, utc_date, config)
ant_sigs_simp = antennas.antennas_simplified_signal(
ants, ant_models, sources, rad.baseband_timebase, rad.int_freq)
obs_simp = rad.get_simplified_obs(ant_sigs_simp, utc_date, config)
from matplotlib import mlab
def calibrate_from_vis(cal_measurements, runtime_config):
MODE = 'mini'
#simp (use only when noise present)\
#mini, perfect visibilities.\
#full
SETTINGS = settings.from_file(runtime_config['telescope_config_path'])
loc = location.get_loc(SETTINGS)
ANTS = [
antennas.Antenna(loc, pos)
for pos in runtime_config['antenna_positions']
]
ANT_MODELS = [
antenna_model.GpsPatchAntenna()
for i in range(SETTINGS.get_num_antenna())
]
NOISE_LVLS = 0.0 * np.ones(SETTINGS.get_num_antenna())
RAD = radio.Max2769B(n_samples=2**12, noise_level=NOISE_LVLS)
COR = correlator.Correlator()
global msd_vis, sim_vis
sim_vis = {}
msd_vis = {}
sim_sky = {}
for m in cal_measurements:
timestamp = dateutil.parser.parse(m['data']['timestamp'])
key = '%f,%f,%s' % (m['el'], m['az'], timestamp)
# Generate model visibilities according to specified point source positions
sim_sky[key] = skymodel.Skymodel(0,
location=loc,
gps=0,
thesun=0,
known_cosmic=0)
sim_sky[key].add_src(
radio_source.ArtificialSource(loc,
timestamp,
r=100.0,
el=m['el'],
az=m['az']))
v_sim = get_vis(sim_sky[key],
COR,
RAD,
ANTS,
ANT_MODELS,
SETTINGS,
timestamp,
mode=MODE)
sim_vis[key] = calibration.CalibratedVisibility(v_sim)
# Construct (un)calibrated visibility objects from received measured visibilities
vis = vis_object_from_response(m['data']['vis']['data'], timestamp,
SETTINGS)
msd_vis[key] = calibration.CalibratedVisibility(vis)
# Define initial optimisation paramters
opt_param = np.ones(46)
opt_param[:23] = np.ones(23)
opt_param[23:] = np.zeros(23)
# Run optimisation
RES = minimize(optimize_phaseNgain, opt_param)
utc_date = datetime.datetime.utcnow()
phases = list(msd_vis.values())[0].get_phase_offset(np.arange(24))
gains = list(msd_vis.values())[0].get_gain(np.arange(24))
#content = msd_vis.values()[0].to_json(filename='/dev/null')
db.insert_gain(utc_date, gains, phases)
db.update_calibration_process_state('idle')
return {}
def get_uvplane(self,
num_bin=1600,
nw=36,
grid_kernel_r_pixels=0.5,
use_kernel=False):
for cal_vis in self.cal_vis_list:
if self.fixed_zenith:
uu_a, vv_a, ww_a = cal_vis.get_all_uvw()
vis_l, bls = cal_vis.get_all_visibility()
else:
uu_l = []
vv_l = []
ww_l = []
vis_l = []
ts = cal_vis.get_timestamp()
ra, dec = self.phase_center.radec(ts)
c = cal_vis.get_config()
ant_p = np.asarray(c.get_antenna_positions())
loc = location.get_loc(c)
bls = cal_vis.get_baselines()
for bl in bls:
ant_i, ant_j = bl
a0 = antennas.Antenna(loc, ant_p[ant_i])
a1 = antennas.Antenna(loc, ant_p[ant_j])
uu, vv, ww = antennas.get_UVW(a0, a1, ts, ra, dec)
uu_l.append(uu / constants.L1_WAVELENGTH)
vv_l.append(vv / constants.L1_WAVELENGTH)
ww_l.append(ww / constants.L1_WAVELENGTH)
vis_l.append(cal_vis.get_visibility(ant_i, ant_j))
uu_a = np.asarray(uu_l)
vv_a = np.asarray(vv_l)
ww_a = np.asarray(ww_l)
vis_l = np.asarray(vis_l)
uu_edges = np.linspace(-nw, nw, num_bin + 1)
vv_edges = np.linspace(-nw, nw, num_bin + 1)
if use_kernel == False:
n_arr = np.zeros((num_bin, num_bin), dtype=np.complex64)
uu_comb = np.concatenate((uu_a, -uu_a))
vv_comb = np.concatenate((vv_a, -vv_a))
all_v = np.concatenate((vis_l, np.conjugate(vis_l)))
h_real, _, _ = np.histogram2d(vv_comb,
uu_comb,
weights=all_v.real,
bins=[vv_edges, uu_edges])
h_imag, _, _ = np.histogram2d(vv_comb,
uu_comb,
weights=all_v.imag,
bins=[vv_edges, uu_edges])
num_entries, _, _ = np.histogram2d(vv_comb,
uu_comb,
bins=[vv_edges, uu_edges])
n_arr[:, :] = h_real + (1j * h_imag)
pos = np.where(num_entries.__gt__(1))
n_arr[pos] /= num_entries[pos]
else:
pixels_per_wavelength = num_bin / (nw * 2.0)
halfbin = float(nw) / (num_bin)
mid_points_uv = np.mgrid[-nw + halfbin:nw - halfbin:num_bin * 1j,
-nw + halfbin:nw - halfbin:num_bin * 1j, ]
n_arr = np.zeros((num_bin, num_bin), dtype=complex)
r_noise_wavelengths = 0.1
grid_kernel_r_wavelength = (
r_noise_wavelengths +
grid_kernel_r_pixels / pixels_per_wavelength)
offset_px = np.ceil(grid_kernel_r_wavelength *
pixels_per_wavelength)
offsets = np.arange(-offset_px, offset_px + 1)
vis_max_abs = np.max(np.abs(vis_l))
for uu, vv, v_l in zip(uu_a, vv_a, vis_l):
i = uu_edges.__lt__(uu).sum() - 1
j = vv_edges.__lt__(vv).sum() - 1
# print('u', mid_points_uv[0][i-1,0], mid_points_uv[0][i,0], mid_points_uv[0][i+1,0], uu)
# print('v', mid_points_uv[1][0,j], vv)
for i_offset in offsets:
for j_offset in offsets:
r = np.sqrt(
np.power(uu -
mid_points_uv[0][i + i_offset, 0], 2) +
np.power(vv -
mid_points_uv[1][0, j + j_offset], 2))
# print('u', uu- mid_points_uv[0][i+i_offset,0], r , grid_kernel_r_pixels/pixels_per_wavelength)
# print('v', vv- mid_points_uv[1][0,j+j_offset], r , grid_kernel_r_pixels/pixels_per_wavelength)
n_arr[j + j_offset, i + i_offset] += v_l * np.exp(
-(r**2.0 / (grid_kernel_r_wavelength)**2.0))
# print(i,j, i_offset, j_offset, r, v_l * np.exp(-(r**2. / (grid_kernel_r_pixels/pixels_per_wavelength)**2.)))
i = uu_edges.__lt__(-uu).sum() - 1
j = vv_edges.__lt__(-vv).sum() - 1
for i_offset in offsets:
for j_offset in offsets:
r = np.sqrt(
np.power(-uu -
mid_points_uv[0][i + i_offset, 0], 2) +
np.power(-vv -
mid_points_uv[1][0, j + j_offset], 2))
n_arr[j + j_offset,
i + i_offset] += np.conjugate(v_l) * np.exp(
-(r**2 / (grid_kernel_r_wavelength)**2))
# apply the masked array and divide by number of entries
mask = np.abs(n_arr).__gt__(0.0)
# mask = np.abs(n_arr).__gt__(vis_max_abs)
n_arr[mask] = n_arr[mask] / np.abs(n_arr[mask])
return (n_arr, uu_edges, vv_edges)