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: