dr_logger.py

#!/usr/bin/python

# Copyright (C) 2014 Peter O'Malley
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""
### BEGIN NODE INFO
[info]
name = DR Logger
version = 0.1
description = Log the DR temperatures, pressures, etc. 

[startup]
cmdline = %PYTHON% %FILE%
timeout = 20

[shutdown]
message = 987654321
timeout = 20
### END NODE INFO
"""

import time

from twisted.internet.defer import inlineCallbacks, returnValue
from twisted.internet.task import LoopingCall

from labrad import types as T
from labrad.server import setting
from labrad.gpib import DeviceWrapper, DeviceServer
from labrad.errors import NoSuchDeviceError, Error
from labrad.units import Unit, Value

CONFIG_PATH = ['', 'Servers', 'DR Logger']
DIODE_LIST = ["4Kin", "4Kout", "77K", "Ret", "Mix", "Xchg", "Still", "Pot"]


class NoMKSDataError(Error):
    pass


class ServerNotFoundError(Error):
    pass


class WatchedServer(object):
    """Proxy for another server from which we pull data

    Attributes:
        name (str): Name of proxied server.
        cxn (labrad.client.Client): Connection to LabRAD.
        ctx (tuple of int): Context for requests to the proxied servers.
        device (str or int): Specific hardware device to access through the
            proxied server. If None (the default) we select the first available
            device, which is the pylabrad default.
    """
    server_name = 'none'

    def __init__(self, name, cxn, ctx, options):
        self.name = name
        self.cxn = cxn
        self.ctx = ctx
        self.options = dict(options)
        self.server = None
        self.active = False

    def get_variables(self):
        """ Get the variables (for the data vault) logged by this server.

        This is called on dataset creation to figure out how to define the dataset.
        :return: list of strings, one per variable, of the form "label (legend) [unit]"
        :rtype: list[str]
        """
        raise NotImplementedError()

    def _take_point(self):
        """ Get data from the device.

        This is called once per cycle to record the data.
        The return values must correspond with those of get_variables.
        :return: list of values, one per variable.
        :rtype: list[Value]
        """
        raise NotImplementedError()

    @inlineCallbacks
    def select_device(self):
        deviceName = self.options.get('device', None)
        print("deviceName: {}".format(deviceName))
        devs = yield self.server.list_devices(context=self.ctx)
        print "looking for device %s" % deviceName
        if deviceName is None:
            yield self.server.select_device(context=self.ctx)
        elif deviceName in [x[1] for x in devs]:
            yield self.server.select_device(deviceName, context=self.ctx)
        else:
            for i, n in devs:
                if deviceName in n:
                    print "selecting device: %s" % n
                    yield self.server.select_device(n, context=self.ctx)
                    break
            else:
                raise NoSuchDeviceError("No such device: %s" % self.device)

    @inlineCallbacks
    def take_point(self):
        """ Take a single data point.

        Call self._take_point, and handle server selection and device selection.
        """
        try:
            self.server = self.cxn[self.name]
            r = yield self._take_point()
            self.active = True
            returnValue(r)
        except KeyError as err:
            raise ServerNotFoundError(
                "'{}' server not found".format(self.name), payload=err
            )
        except T.Error as err:
            self.active = False
            if 'DeviceNotSelectedError' in err.msg:
                yield self.select_device()
                r = yield self._take_point()
                self.active = True
                returnValue(r)
            else:
                raise err


# noinspection PyAttributeOutsideInit
class MKS(WatchedServer):
    """ for MKS servers, we have an optional "device" argument in the form of
    (reading_name, multiplier), which tells us which reading to convert into
    a He flow.
    """
    server_name = 'mks_gauge_server'

    @inlineCallbacks
    def _take_point(self):
        r = yield self.server.get_readings(context=self.ctx)
        r = list(r)
        if not hasattr(self, 'channel'):
            yield self.setup_he_flow()
        if not r:
            raise NoMKSDataError("MKS server did not return data.")
        if self.channel is not None:
            r.append(self.multiplier * r[self.channel])
        returnValue(r)

    @inlineCallbacks
    def get_variables(self):
        point = yield self.take_point()
        names = yield self.server.get_gauge_list(context=self.ctx)
        rv = []
        for p, n in zip(point, names):
            rv.append('%s (Pressure) [%s]' % (n, str(p.unit)))
        if self.channel is not None:
            rv.append('He Flow (LHe) [L/h]')
        returnValue(rv)

    @inlineCallbacks
    def setup_he_flow(self):
        if 'he_flow_rate' in self.options and 'channel' in self.options:
            names = yield self.server.get_gauge_list(context=self.ctx)
            for i, name in enumerate(names):
                if name == self.options['channel']:
                    self.channel = i
                    self.multiplier = self.options['he_flow_rate']
                    print "Using gauge reading %s (%s) for He flow with multiplier %s" % (str(i), name, self.multiplier)
                    break
            else:
                self.channel = None
                print "ERROR: could not find gauge reading named '%s'" % self.device[0]
        else:
            self.channel = None


class MKSHack(MKS):
    server_name = 'mks_gauge_server_testhack'


class Diodes(WatchedServer):
    server_name = 'lakeshore_diodes'

    @inlineCallbacks
    def _take_point(self):
        r = yield self.server.temperatures(context=self.ctx)
        returnValue(r)

    def get_variables(self):
        return ['%s (Diode) [K]' % x for x in DIODE_LIST]


class Ruox(WatchedServer):
    server_name = 'lakeshore_ruox'

    @inlineCallbacks
    def _take_point(self):
        p = self.server.packet(context=self.ctx)
        p.temperatures()
        p.resistances()
        result = yield p.send()
        temps = [x[0] for x in result.temperatures]
        res = [x[0] for x in result.resistances]
        returnValue(temps + res)

    @inlineCallbacks
    def get_variables(self):
        yield self.take_point()  # make sure we're connected
        t = yield self.server.named_temperatures(context=self.ctx)
        temp_vars = ['%s (Ruox) [%s]' % (x[0], str(x[1][0].unit)) for x in t]
        r = yield self.server.named_resistances(context=self.ctx)
        res_vars = ['%s (Ruox Res) [%s]' % (x[0], str(x[1][0].unit)) for x in r]
        returnValue(temp_vars + res_vars)


# some tomfoolery to pull together all our watchers
WATCHERS = []
for obj in vars().values():
    try:
        if issubclass(obj, WatchedServer) and obj is not WatchedServer:
            WATCHERS.append(obj)
    except TypeError:
        pass
print "Found these watchers: ", WATCHERS


# noinspection PyAttributeOutsideInit
class DRLogger(DeviceWrapper):
    """

    Attributes:
        name (str): Name of this DR setup. Assigned by pylabrad's device server
            code.
        watchers (list of WatchedServer): Server proxies we watch.
    """
    @inlineCallbacks
    def connect(self, *args, **kwargs):
        """Connect to a DR device

        Args:
            args (tuple of (cxn,)): A tuple with a single element, which is a
                LabRAD connection.
        kwargs (dict):
            Maps hardware types (e.g. 'ruox') to configuration data. See
            DRLoggerServer.findDevices for format.
        """
        print "Creating DR Logger for %s" % self.name
        self.cxn = args[0]
        self.ctx = self.cxn.context()
        self.watchers = []
        self.data_vault = None
        self.errors = []
        self.dvPath = kwargs.pop('dvPath', ['', 'DR', self.name])
        self.datasetName = kwargs.pop('datasetName', '%s log - [t]' % self.name)
        self.timeInterval = kwargs.pop('timeInterval', 1.0)
        self.currentDay = ''
        # now make our watchers
        for k, v in kwargs.iteritems():
            server_name = v[0]
            nodeName = v[1]
            if len(v) > 2:
                options = v[2]
            else:
                options = {}
            for cls in WATCHERS:
                if cls.server_name == server_name:
                    break
            else:
                cls = None
            if cls is not None:
                print "Found watcher for %s" % server_name
                self.watchers.append(cls(server_name, self.cxn, self.ctx, options=options))
            else:
                raise ValueError("ERROR: No watcher class found for:", server_name)

        self.isLogging = False
        yield self.logging(True)  # start logging

    @inlineCallbacks
    def logging(self, start):
        if not self.isLogging and start:
            # start the loop
            self.isLogging = True
            self.loop = LoopingCall(self.take_point)
            self.loopDone = self.loop.start(self.timeInterval, now=True)
            print 'loop started'
        elif self.isLogging and not start:
            # stop the loop
            try:
                self.loop.stop()
                yield self.loopDone
            except AssertionError:
                pass
            print 'loop stopped'
            self.isLogging = False

    @inlineCallbacks
    def shutdown(self):
        yield self.logging(False)

    def new_dataset(self):
        self.data_vault = None

    @inlineCallbacks
    def make_dataset(self):
        self.data_vault = self.cxn['data_vault']
        self.data_vault.cd(self.dvPath, True, context=self.ctx)
        name = self.datasetName.replace('[t]', time.strftime("%Y-%m-%d %H:%M"))
        self.currentDay = time.strftime("%d")
        indeps = ['time [s]']
        deps = []
        for w in self.watchers:
            r = yield w.get_variables()
            deps.extend(r)
        print "Indep vars: %s" % str(indeps)
        print "Dependent vars: %s" % str(deps)

        yield self.data_vault.new(name, indeps, deps, context=self.ctx)

    @inlineCallbacks
    def take_point(self):
        try:
            # gather data
            data = [time.time() * Unit('s')]
            errors = []
            for w in self.watchers:
                try:
                    r = yield w.take_point()
                    data.extend(r)
                except T.Error as err:
                    errors.append((w.server_name, err.msg))
            if errors:
                self.errors = errors
                returnValue(None)
            # strip units
            data = [x[x.unit] for x in data]
            # did the day roll over?
            if self.currentDay != time.strftime("%d"):
                self.new_dataset()
            try:
                # make dataset if first time
                if self.data_vault is None:
                    print("Making new dataset")
                    yield self.make_dataset()
                # add data
                yield self.data_vault.add(data, context=self.ctx)
            except T.Error as err:
                print("Error when writing data to data vault: {}".format(err))
                if 'NoDatasetError' in err.msg:
                    try:
                        yield self.make_dataset()
                        yield self.data_vault.add(data, context=self.ctx)
                    except T.Error as err:
                        errors.append(("Data Vault", str(err)))
                else:
                    errors.append(("General", str(err)))
            self.errors = errors
        except Exception as e:
            import traceback
            traceback.print_exc()


class DRLoggerServer(DeviceServer):
    """Log DR temperatures and pressures

    Registry format:
        >> Servers >> DR Logger >> <DR name> (e.g. 'Ivan')
            <thing to measure> -> (<server>, <node>, <options>):
                <thing to measure> (s): Either 'diodes', 'mks', or 'ruox'.
                <server> (s): pylabrad name of the server servicing the thing
                    being measure. For example, for the diodes <server name> is
                    'lakeshore_diodes'.
                <node> (s): Name of node running <server>.
                <options> ((s, ?),...): Tuple of (key, value) tuples. Provides
                    additional data to configure measurements.
    """
    name = 'DR Logger'
    deviceName = 'DR'
    deviceWrapper = DRLogger

    @inlineCallbacks
    def findDevices(self):
        """Get device configurations from registry

        all configurations in CONFIG_PATH and returns

        Returns list of (drName, (cxn,), serverDict).
            serverDict is a mapping from a device type (i.e. 'mks', 'ruox', or
            'diodes') to a tuple of either
            (server name, node name, options) or
            (server name, node name).
            For example, for the Jules DR, we would have entries mapping
            'ruox' -> ('lakeshore_ruox', 'DR') and
            'mks' -> ('mks_gauge_server', 'DR', (('He Flow', 24.7 L/h/Torr)))
        """
        deviceList = []
        reg = self.client.registry
        yield reg.cd(CONFIG_PATH)
        resp = yield reg.dir()
        drNames = resp[0].aslist
        for drName in drNames:
            # all required nodes must be present to create this device
            yield reg.cd(drName)
            devs = yield reg.dir()
            devs = devs[1].aslist  # e.g. 'diodes', 'mks'
            missingNodes = []
            serverDict = {}
            for dev in devs:
                config = yield reg.get(dev)
                print("config: {}".format(config))
                # config is a tuple of (server name, node name) or
                #                      (server name, node name, options)
                serverDict[dev] = config
                node = config[1]
                if "node_" + node.lower() not in self.client.servers:
                    missingNodes.append(node)
            if not missingNodes:
                deviceList.append((drName, (self.client,), serverDict))
            else:
                print "device %s missing nodes %s" % (drName, str(list(set(missingNodes))))
            yield reg.cd(1)
        returnValue(deviceList)

    @setting(10, "Take Point")
    def take_point(self, c):
        """ Take a single data point. """
        self.selectedDevice(c).take_point()

    @setting(11, "New Dataset")
    def new_dataset(self, c):
        """ Start a new dataset. """
        self.selectedDevice(c).new_dataset()

    @setting(12, 'Logging', start='b', returns='b')
    def logging(self, c, start=None):
        """ Get/set whether we are currently logging. """
        dev = self.selectedDevice(c)
        if start is not None:
            yield dev.logging(start)
        returnValue(dev.isLogging)

    @setting(13, 'Time Interval', ti='v[s]', returns='v[s]')
    def time_interval(self, c, ti=None):
        """ Get/set the logging time interval. """
        dev = self.selectedDevice(c)
        if ti is not None:
            dev.timeInterval = ti['s']
            if dev.isLogging:
                yield dev.logging(False)
                yield dev.logging(True)
        returnValue(Value(dev.timeInterval, 's'))

    @setting(14, 'Errors', returns='*(s, s)')
    def errors(self, c):
        """ Retrieve outstanding errors.

        Each error is given as a pair of strings:
        (source or type, error message)
        """
        dev = self.selectedDevice(c)
        return dev.errors

    @setting(15, 'Current Time', returns='v['']')
    def current_time(self, c):
        """ Return the current time, in seconds (i.e. time.time()).
        """
        return time.time()


__server__ = DRLoggerServer()

if __name__ == '__main__':
    from labrad import util

    util.runServer(__server__)