コード例 #1
0
ファイル: data.py プロジェクト: sma-wideband/wideband_sw
    def __init__(self, swarm, listener):

        # Create initial member variables
        self.logger = logging.getLogger("SwarmDataHandler")
        self.xengine = SwarmXengine(swarm)
        self.stopper = Event()
        self.queue = Queue()
        self.callbacks = []
        self.rawbacks = []
        self.swarm = swarm

        # Print out receive side (i.e. listener) network information
        self.logger.info("Listening for data on %s:%d" % (listener.host, listener.port))

        # Start the listening queue
        self.catcher = SwarmDataCatcher(self.queue, self.stopper, listener.host, listener.port)
        self.catcher.setDaemon(True)
        self.catcher.start()
コード例 #2
0
ファイル: data.py プロジェクト: sma-wideband/wideband_sw
class SwarmDataHandler:
    def __init__(self, swarm, listener):

        # Create initial member variables
        self.logger = logging.getLogger("SwarmDataHandler")
        self.xengine = SwarmXengine(swarm)
        self.stopper = Event()
        self.queue = Queue()
        self.callbacks = []
        self.rawbacks = []
        self.swarm = swarm

        # Print out receive side (i.e. listener) network information
        self.logger.info("Listening for data on %s:%d" % (listener.host, listener.port))

        # Start the listening queue
        self.catcher = SwarmDataCatcher(self.queue, self.stopper, listener.host, listener.port)
        self.catcher.setDaemon(True)
        self.catcher.start()

    def add_rawback(self, func):
        self.rawbacks.append(func)

    def add_callback(self, func):
        self.callbacks.append(func)

    def _reorder_data(self, datas_list, int_time, int_length):

        # Get the xengine packet ordering
        order = list(self.xengine.packet_order())

        # Create data package to hold baseline data
        data_pkg = SwarmDataPackage(self.swarm, time=int_time, length=int_length)

        # Unpack and reorder each FID's data
        for fid, datas in enumerate(datas_list):

            # Unpack this FID's data
            data = array(unpack(">%di" % SWARM_VISIBS_ACC_SIZE, datas))

            # Reorder by Xengine word (per channel)
            for offset, word in enumerate(order):

                if word.baseline.is_valid():
                    sub_data = data[offset :: len(order)]
                    data_pkg.set_data(word, fid, sub_data)

        # Return the (hopefully) complete data packages
        return data_pkg

    def _handle_data(self, data):

        # Do user callbacks first
        for callback in self.callbacks:
            callback(data)

        # Send data to dataCatcher/corrSaver
        for baseline in data.baselines:

            # Get our data arrays
            baseline_data = data[baseline]

            # Send the appropriate chunk
            if baseline.is_valid():

                # Get baseline antennas
                ant_left = baseline.left._ant
                ant_right = baseline.right._ant

                # Get the chunk
                chunk = baseline.left._chk

                # Get baseline polarizations
                pol_left = baseline.left._pol
                pol_right = baseline.right._pol

                # Get each sidebands data
                usb_data = baseline_data[chunk]["USB"]
                if baseline.is_auto():
                    lsb_data = usb_data.copy()
                else:
                    lsb_data = baseline_data[chunk]["LSB"]

                # Send our integration
                send_integration(
                    data.int_time - (data.int_length / 2.0),
                    data.int_length,
                    chunk,
                    ant_left,
                    pol_left,
                    ant_right,
                    pol_right,
                    lsb_data,
                    usb_data,
                    0,
                )

            # Debug log this baseline
            self.logger.debug("processed baseline: {!s}".format(baseline))

        # Info log the set
        self.logger.info("processed all baselines")

    def loop(self):

        try:

            acc = {}

            # Loop until user quits
            while True:

                try:  # to check for data
                    addr, acc_n, last_acc, datas = self.queue.get_nowait()
                    sleep(0.1)
                except Empty:  # none available
                    continue

                # Get the member/fid this set is from
                recv_fid, recv_member = self.swarm.get_member(addr[0])

                # Get the host name from member
                recv_host = recv_member.roach2_host

                # Log this accumulation
                if not math.isnan(last_acc):
                    self.logger.info(
                        "Received full accumulation #{:<4} from fid #{}: {} ({:.4f} secs since last)".format(
                            acc_n, recv_fid, recv_member, last_acc
                        )
                    )
                else:
                    self.logger.info(
                        "Received full accumulation #{:<4} from fid #{}: {}".format(acc_n, recv_fid, recv_member)
                    )

                # New accumulation, track it
                if not acc.has_key(acc_n):
                    acc[acc_n] = [None] * self.swarm.fids_expected

                # Add this FID's data to accumulation
                acc[acc_n][recv_fid] = datas

                if acc[acc_n].count(None) == 0:

                    # Get integration time and length
                    int_time = time()

                    # We have all data for this accumulation, log it
                    self.logger.info("Received full accumulation #{:<4}".format(acc_n))

                    # Do user rawbacks first
                    rawdata = acc.pop(acc_n)
                    for rawback in self.rawbacks:
                        rawback(rawdata)

                    # Reorder the xengine data
                    data = self._reorder_data(rawdata, int_time, self.swarm.get_itime())

                    # Handle the baseline data
                    self._handle_data(data)

        except KeyboardInterrupt:

            # User wants to quit
            self.stopper.set()
            self.catcher.join()