def setUp(self):
"""Test setup."""
os.system("dada_db -d 2> /dev/null ; dada_db -k dada")
self.writer = Writer()
self.writer.connect(0xdada)
self.reader = Reader()
self.reader.connect(0xdada)
def read_untill_end():
"""Connect, read all pages, and disconnect from a ringbuffer."""
# Create a reader instace and connect to a running ringbuffer
reader = Reader(0xdada)
# loop over the pages
for page in reader:
# read the page as numpy array
data = np.asarray(page)
print(np.sum(data))
reader.disconnect()
class TestReadWriteHeader(unittest.TestCase):
"""
Test for reading and writing header data.
Start a ringbuffer instance and write some data to the header block,
then read it back.
"""
def setUp(self):
"""Test setup."""
os.system("dada_db -d 2> /dev/null ; dada_db -k dada")
self.writer = Writer()
self.writer.connect(0xdada)
self.reader = Reader()
self.reader.connect(0xdada)
def tearDown(self):
"""Test teardown."""
self.writer.disconnect()
self.reader.disconnect()
os.system("dada_db -d -k dada 2> /dev/null")
def test_writing_header(self):
"""
Header reading and writing test.
Read a previously written header from the ringbuffer,
and test if the headers are equal.
"""
self.writer.setHeader(HEADER_TEST_DATA)
header = self.reader.getHeader()
del header['__RAW_HEADER__']
self.assertDictEqual(header, HEADER_TEST_DATA)
def read_untill_end():
"""Connect, read all pages, and disconnect from a ringbuffer."""
# Create a reader instace and connect to a running ringbuffer
reader = Reader(0xdada)
# loop over the pages until EOD is encountered
while not reader.isEndOfData:
# read the page as numpy array
page = reader.getNextPage()
data = np.asarray(page)
print(np.sum(data))
reader.markCleared()
reader.disconnect()
def run_fringestopping(param_file=None, header_file=None, output_dir=None):
"""Read in data, fringestop on zenith, and write to hdf5 file.
Parameters
----------
param_file : str
The full path to the json parameter file. Defaults to the file
meridian_fringestopping_parameters.py in the package directory.
"""
# Read in parameter file
test, key_string, nant, nchan, npol, fobs, samples_per_frame, \
samples_per_frame_out, nint, nfreq_int, antenna_order, pt_dec, \
tsamp, fringestop, filelength_minutes, outrigger_delays, refmjd = \
pu.parse_params(param_file)
nbls = (nant * (nant + 1)) // 2
key = int(f"0x{key_string}", 16)
# Update outrigger delays and refmjd in etcd
pu.put_outrigger_delays(outrigger_delays)
pu.put_refmjd(refmjd)
# Generate fringestopping table and load visibility model
fs_table = (
f"fringestopping_table_dec{(pt_dec*u.rad).to_value(u.deg):.1f}deg_"
f"{len(antenna_order)}ant.npz")
if output_dir is not None:
fs_table = f"{output_dir}/{fs_table}"
bname, blen, uvw = pu.baseline_uvw(antenna_order,
pt_dec,
refmjd,
casa_order=False)
vis_model = pu.load_visibility_model(fs_table, blen, nint, fobs, pt_dec,
tsamp, antenna_order,
outrigger_delays, bname, refmjd)
if not fringestop:
vis_model = np.ones(vis_model.shape, vis_model.dtype)
logger.info(
f"Started fringestopping of dada buffer {key_string} with {nint} "
f"integrations and {len(blen)} baselines.")
if test:
# Setup the dada buffer for testing
sample_rate = 1 / 0.134217728
header_size = 4096
buffer_size = int(4 * nbls * npol * nchan * samples_per_frame * 2)
data_rate = buffer_size * (sample_rate / samples_per_frame) / 1e6
with subprocess.Popen([
"dada_db", "-a",
str(header_size), "-b",
str(buffer_size), "-k", key_string
],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE) as p_create:
outs, errs = p_create.communicate(timeout=15)
if p_create.returncode != 0:
print(errs.decode("utf-8"))
logger.info(errs.decode("utf-8"))
raise RuntimeError("Dada buffer could not be created.")
print(outs.decode("utf-8"))
print(f"Initializing reader: {key_string}")
reader = Reader(key)
if test:
p_write = subprocess.Popen([
"dada_junkdb", "-r",
str(data_rate), "-t", "60", "-k", key_string, header_file
],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# Get the start time and the sample time from the reader
sample_rate_out = 1 / (tsamp * nint)
# Read in psrdada buffer, fringestop, and write to uvh5
dada_to_uvh5(reader, output_dir, nbls, nchan, npol, nint, nfreq_int,
samples_per_frame_out, sample_rate_out, pt_dec, antenna_order,
fs_table, tsamp, bname, uvw, fobs, vis_model, test,
filelength_minutes)
if test:
outs, errs = p_write.communicate(timeout=15)
if p_write.returncode != 0:
logger.info(errs.decode("utf-8"))
print(errs.decode("utf-8"))
raise RuntimeError("Error in writing to dada buffer.")
print(outs.decode("utf-8"))
print(errs.decode("utf-8"))
with subprocess.Popen(["dada_db", "-d", "-k", key_string],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE) as p_kill:
outs, errs = p_kill.communicate(timeout=15)
if p_kill.returncode != 0:
logger.info(errs.decode("utf-8"))
print(errs.decode("utf-8"))
else:
print(outs.decode("utf-8"))
logger.info(f"Disconnected from psrdada buffer {key_string}")
#!/usr/bin/env python
"""
Show how to read multiple datasets, separated by EODs.
Version with iterors.
"""
import numpy as np
from psrdada import Reader
reader = Reader(0xdbda)
nheader = 0
done = False
while not done:
nheader += 1
header = reader.getHeader()
del header['__RAW_HEADER__'] # prettier output
print(nheader, header)
if 'QUIT' in header.keys():
print('Header contains the QUIT key, so we quit')
done = True
else:
# loop over the pages until EOD is encountered
# the EOD flag is (like mark_cleared etc.) automagically kept in sync
npages = 0
for page in reader:
npages += 1
data = np.asarray(page)
def disp_delay(DM, dt, ftop, fbottom):
"""
Calculates the dispersion delay for a given DM in pc/cm^3 and
frequencies in GHz
"""
return 0.00415 / dt * DM * (fbottom**-2 - ftop**-2)
key = sysv_ipc.ftok("/home/user/linux_64/heimdall_buffer/progfile",
65) # key of message queue to listen to
queue = sysv_ipc.MessageQueue(key) # creates message queue
for i in range(
queue.current_messages): # clears any lingering messages in the queue
queue.receive()
reader = Reader(0xfada) # defines a psrdada ring buffer to read
count = 0
n_candidates_remaining = 0
dt = 6.5536e-5
while reader.isConnected: # as long as the reader is connected...
candidates = []
dat = queue.receive()
n_candidates_remaining = dat[1]
if n_candidates_remaining != 10000:
candidates.append(unpack_message(dat))
print("mesg type ", dat[1])
print(unpack_message(dat))
if n_candidates_remaining != 10000:
for i in range(n_candidates_remaining - 1):
print("receiving")
dat = queue.receive()
ntime_plot = 64
ndm_plot = 64
dt = 8.192e-5
RtProc = realtime_tools.RealtimeProc()
model_freqtime = frbkeras.load_model(fn_model_freqtime)
model_dmtime = frbkeras.load_model(fn_model_dmtime)
# For some reason, the model's first prediction takes a long time.
# pre-empt this by classifying an array of zeros before looking
# at real data
model_freqtime.predict(np.zeros([1, nfreq_plot, ntime_plot, 1]))
model_dmtime.predict(np.zeros([1, ndm_plot, ntime_plot, 1]))
reader = Reader()
def dada_proc_trigger(reader, nbeam=12):
# Connect to a running ringbuffer with key=1200
reader.connect(0x1200)
counter = -1
for page in reader:
t0 = time.time()
counter += 1
data = np.asarray(page) #read only
print(counter)
if counter == 0 and triggermode == True:
header = reader.getHeader()
#!/usr/bin/env python
"""
Show how to read multiple datasets, separated by EODs.
Version with iterors.
"""
import numpy as np
from psrdada import Reader
reader = Reader(0xdbda)
nheader = 0
while True:
header = reader.getHeader()
nheader += 1
del header['__RAW_HEADER__'] # prettier output
print(nheader, header)
if 'QUIT' in reader.header.keys():
print('Header contains the QUIT key, so we quit')
break
# we iterate manually through the buffer,
# so we also need to manually reset the eod flag
reader.isEndOfData = False
# loop over the pages until EOD is encountered
npages = 0
while not reader.isEndOfData: