def get_full_obs(self, ant_sigs, utc_date, config, timebase):
num_radio_samples = len(timebase) // self.freq_mult
num_ant = len(ant_sigs)
sampled_signals = np.zeros((num_ant, num_radio_samples))
for i in range(num_ant):
sampled_signals[i, :] = self.sampled_signal(
ant_sigs[i], i, self.sample_duration)
sampled_signals = np.asarray((sampled_signals + 1) / 2,
dtype=bool) # turn into boolean array
obs = observation.Observation(utc_date,
config=config,
data=sampled_signals)
return obs
def run_acquire_raw(tart, runtime_config):
runtime_config['acquire'] = 1
tart.reset()
tart.debug(on=not runtime_config['acquire'], \
shift=runtime_config['shifter'], \
count=runtime_config['counter'], \
noisy=runtime_config['verbose'])
tart.capture(on=True, source=0, noisy=runtime_config['verbose'])
tart.set_sample_delay(runtime_config['sample_delay'])
tart.centre(runtime_config['centre'], noisy=runtime_config['verbose'])
t_stmp, path = create_timestamp_and_path(
runtime_config['raw']['base_path'])
tart.start_acquisition(1.1, True)
while not tart.data_ready():
tart.pause(duration=0.005, noisy=True)
print('\nAcquisition complete, beginning read-back.')
#tart.capture(on=False, noisy=runtime_config['verbose'])
data = tart.read_data(
num_words=np.power(2, runtime_config['raw']['N_samples_exp']))
d, d_json = get_status_json(tart)
runtime_config['status'] = d
tart.reset()
print('reshape antenna data')
data = np.asarray(data, dtype=np.uint8)
ant_data = np.flipud(np.unpackbits(data).reshape(-1, 24).T)
if runtime_config['raw']['save']:
config = settings.from_file(runtime_config['telescope_config_path'])
fname = "data_{}.hdf".format(t_stmp.strftime('%Y-%m-%d_%H_%M_%S.%f'))
filename = path + fname
obs = observation.Observation(t_stmp, config, savedata=ant_data)
obs.to_hdf5(filename)
print(('saved to: ', filename))
return {'filename': filename, 'sha256': sha256_checksum(filename)}
return {}
print('\nDone.')
def get_simplified_obs(self,
baseband_signals,
utc_date,
config,
seed=None):
np.random.seed(seed=seed)
s_signals = []
if_sig = baseband_signals * np.exp(
-2.0j * np.pi * self.int_freq * self.baseband_timebase)
num_ant = len(baseband_signals)
for i in range(num_ant):
if self.noise_level[i] > 0.0:
noise = np.random.normal(0.0, self.noise_level[i],
len(if_sig[i]))
if_sig[i] = if_sig[i] + noise
for ant_num in range(num_ant):
filt_sig1 = butter_filter.butter_bandpass_filter(
if_sig[ant_num],
self.int_freq - self.bandwidth / 2.0,
self.int_freq + self.bandwidth / 2.0,
self.ref_freq,
self.order,
)
s_signals.append(filt_sig1)
s_signals = np.array(s_signals).real
sampled_signals = np.sign(
s_signals) # -1 if negative, 0 if 0, +1 if positive
sampled_signals[s_signals == 0.0] = 1.0 # Replace 0 with 1 - true NRZ
sampled_signals = np.asarray((sampled_signals + 1) / 2,
dtype=bool) # turn into boolean array
obs = observation.Observation(utc_date,
config=config,
data=sampled_signals)
return obs
help='operate telescope with fake antenna data.')
parser.add_argument('--data-dir',
required=True,
help="The filesystem path for the telescope data.")
parser.add_argument('--config-file',
default='telescope_config.json',
help="The telescope configuration file.")
args = parser.parse_args()
base_path = args.data_dir
num_bytes = np.power(2, args.bramexp)
t_SPI = TartSPI(speed=args.speed * 1000000)
t_SPI.debug(args.debug)
t_stmp, path = create_timestamp_and_path(base_path)
t_SPI.start_acquisition(sleeptime=3) #wait for acquisition to finish
data = t_SPI.read_data(num_bytes=num_bytes, blocksize=1000)
t_SPI.reset()
print 'reshape antenna data'
ant_data = np.flipud(np.unpackbits(data).reshape(-1, 24).T)
print ant_data[:, :15]
config = settings.Settings(args.config_file)
filename = path + t_stmp.strftime('%H_%M_%S.%f') + '_data.pkl'
print 'create observation object'
obs = observation.Observation(t_stmp, config, savedata=ant_data)
obs.save(filename)
print 'saved to: ', filename
def test_correlator_simp(self):
from tart.operation import settings
from tart.simulation import simulation_source
from tart.util import angle
from tart.util import constants
from tart.simulation import radio
import datetime
import numpy as np
N = 20
a0 = np.random.randint(0, 2, 2**N)
a1 = np.random.randint(0, 2, 2**N)
self.assertAlmostEqual(corr_b(a0, a1, N), corr_b_pat(a0, a1))
from tart.operation import observation
from tart.operation import settings
import datetime
t = datetime.datetime.utcnow()
c = settings.from_file(TEST_SCOPE_CONFIG)
c.Dict["num_antenna"] = 2
d = [a0, a1]
o = observation.Observation(timestamp=t, config=c, data=d)
cor = Correlator(van_vleck_corr=True)
vis_a = cor.correlate(o, mode="roll")
# vis_b = cor.correlate_roll(o)
vis_c = cor.correlate(o, mode="fftw_hilbert")
# print(vis_a.vis(0,1), vis_b.vis(0,1), vis_c.vis(0,1))
sample_duration = 16.02e-1
sample_duration = 4e-1
config = settings.from_file(TEST_SCOPE_CONFIG)
rad = radio.Max2769B(noise_level=np.ones(config.get_num_antenna()))
src = simulation_source.SimulationSource(
amplitude=1.0,
azimuth=angle.from_dms(0.0),
elevation=angle.from_dms(5.0),
sample_duration=sample_duration,
)
fc0 = rad.int_freq
int_sig = np.exp(-2.0j * np.pi * fc0 * rad.baseband_timebase)
def add_noise(sig):
return sig + np.random.normal(0.0, 0.1, len(sig))
def sig2binary(signal):
return np.array([1.0 if (x >= 0) else 0.0 for x in signal])
antsig1 = src.s_baseband(rad.baseband_timebase) * int_sig
for fraction in np.random.uniform(-np.pi / 3, np.pi / 3, 10):
dt = ((2.0 * np.pi) / src.omega) * fraction
print("dt", dt)
antsig2 = (src.s_baseband(rad.baseband_timebase + dt) * int_sig *
np.exp(1.0j * src.omega * dt))
antsig1 = add_noise(antsig1.real)
antsig2 = add_noise(antsig2.real)
d = [sig2binary(antsig1), sig2binary(antsig2)]
obs = observation.Observation(timestamp=t, config=c, data=d)
vis_a = cor.correlate(o, mode="roll")
# vis_b = cor.correlate_roll(o)
vis_c = cor.correlate(o, mode="fftw_hilbert")
vis_d = cor.correlate(o, mode="fftw_hilbert_sign")
# print(vis_a.vis(0,1),vis_b.vis(0,1))
print(vis_a.vis(0, 1), vis_c.vis(0, 1))
print(vis_a.vis(0, 1), vis_d.vis(0, 1))
# print(vis_b.vis(0,1),vis_c.vis(0,1))
# print(vis_b.vis(0,1),vis_d.vis(0,1))
print(vis_c.vis(0, 1), vis_d.vis(0, 1))
# self.assertAlmostEqual(vis_a.vis(0,1),vis_b.vis(0,1),4)
self.assertAlmostEqual(vis_a.vis(0, 1), vis_c.vis(0, 1), 4)
self.assertAlmostEqual(vis_a.vis(0, 1), vis_d.vis(0, 1), 4)
# self.assertAlmostEqual(vis_b.vis(0,1),vis_c.vis(0,1),4)
# self.assertAlmostEqual(vis_b.vis(0,1),vis_d.vis(0,1),4)
self.assertAlmostEqual(vis_c.vis(0, 1), vis_d.vis(0, 1), 4)
vis = cor.correlate(obs, mode="roll")
cor_out = angle.from_dms(
angle.wrap_360(np.angle(vis.v[0], deg=True)))
input_angle = angle.from_dms(
angle.wrap_360(dt * src.omega * 180.0 /
np.pi)) # .to_degrees()
# print(cor_out, input_angle)
# print(type(cor_out), type(input_angle))
# print(cor_out - input_angle)
self.assertLess(np.abs((cor_out - input_angle).to_degrees()), 30.0)
def Visibility_From_Conf(config, timestamp, phase_el, phase_az):
obs = observation.Observation(timestamp=timestamp, config=config)
vis = Visibility(obs, phase_el, phase_az)
return vis