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()
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()
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)
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)
print("page:", npages, np.sum(data))
reader.disconnect()
if n_candidates_remaining != 10000:
for i in range(n_candidates_remaining - 1):
print("receiving")
dat = queue.receive()
print("received")
candidates.append(unpack_message(dat))
print(unpack_message(dat))
print(1)
dy_norm = read_buffer(reader)
for i in range(
len(candidates)
): # for each candidate, calculate what part of data to save and put it
# in an h5 file
s1 = int(candidates[i][2]) - int(candidates[i][0]) - 1000
s1 = s1 * (s1 > 0)
s2 = min(
s1 + int(disp_delay(float(candidates[i][6]), dt, 1.53, 1.28) + 1) +
2**int(candidates[i][4]) + 1000, 200000)
save_cand = np.array([dy_norm[:, s1:s2], candidates[i]])
save_cand[1][-1] = np.string_(save_cand[1][-1])
save_cand[1][-5] = np.string_(save_cand[1][-5])
adict = dict(data=save_cand[0], metadata=save_cand[1])
with h5py.File('/home/user/candidates_train/candidates.h5', 'a') as hf:
grp = hf.create_group('candidate_%s_%s' %
(int(candidates[i][2]), i))
for k, v in adict.items():
grp.create_dataset(k, data=v)
print("Saving candidate %s" % candidates[i][2])
count += 1
reader.disconnect() # disconnect from the buffer