Skip to content
Snippets Groups Projects
Select Git revision
  • 4d1730297f07871bff09fc8e97a49c62b89da4c5
  • master default protected
2 results

param.py

Blame
  • Daniel Brown's avatar
    Daniel Brown authored
    adding in fsig command (not parsing yet). See example test_fsig.py in bin folder. Also made component variable an optional argument for xaxis and x2axis which will break previous scripts. Did this as when setting the parameter to tune, the Param object contains whatever component owns that parameter so no need to pass it twice. Also stops someone passing a parameter not for the component stated.
    4d173029
    History
    param.py 5.00 KiB
    import abc
    import pykat.exceptions as pkex
    
    class putable(object):
        """
        Objects that inherit this should be able to have something `put` to it.
        Essentially this means you could write Finesse commands like
        
        put this parameter value
        """
        __metaclass__ = abc.ABCMeta
        
        def __init__(self, component_name, parameter_name, isPutable=True):
            self._parameter_name = parameter_name
            self._component_name = component_name
            self._putter = None
            self._isPutable  = isPutable
        
        @property
        def isPutable(self): return self._isPutable
        
        def put(self, var):
        
            if not isinstance(var, putter):
                raise pkex.BasePyKatException("var was not something that can be `put` as a value")
            
            if self._putter != None:
                self._putter.put_count -= 1
            
            self._putter = var
            self._putter.put_count += 1
            
        def _getPutFinesseText(self):
            rtn = []
            # if something is being put to this 
            if self._putter != None:
                rtn.append("put {comp} {param} ${value}".format(comp=self._component_name, param=self._parameter_name, value=self._putter.put_name()))
            
            return rtn
                
    class putter(object):
        """
        If an object can be put to something that is putable it should inherit this
        object.
        """
        
        def __init__(self, put_name, isPutter=True):
            self._put_name = put_name
            self.put_count = 0
            self._isPutter = isPutter
        
        @property
        def isPutter(self): return self._isPutter
        
        def put_name(self): return self._put_name
        
            
    class Param(putable, putter):
    
        def __init__(self, name, owner, value, canFsig=False, fsig_name=None, isPutable=True, isPutter=True, isTunable=True, var_name=None):
            self._name = name
            self._owner = owner
            self._value = value
            self._isPutter = isPutter
            self._isTunable = isTunable
            self._owner._register_param(self)
            self._canFsig = False
            
            if canFsig:
                self._canFsig = True
    
                if fsig_name == None:
                    raise pkex.BasePyKatException("If parameter is a possible fsig target the fsig_name argument must be set")
    
                self.__fsig_name = fsig_name
            
            if isPutter:
                if var_name == None:
                    var_name = "var_{0}_{1}".format(owner.name, name)
                    
                putter.__init__(self, var_name, isPutter)
                
            if isPutable:
                putable.__init__(self, owner.name, name, isPutable)
        
        @property
        def canFsig(self): return self._canFsig
        
        @property
        def fsig_name(self): return self.__fsig_name
        
        @property
        def name(self): return self._name
        
        @property
        def isTuneable(self): return self._isTunable
        
        @property
        def value(self): return self._value
        @value.setter
        def value(self, value):
            self._value = value
        
        def __str__(self): return str(self.value)
        def __float__(self): return self.value
            
        def getFinesseText(self):
            rtn = []
            
            if self.isPutable: rtn.extend(self._getPutFinesseText())
            
            # if this parameter is being put somewhere then we need to
            # set it as a variable
            if self.isPutter and self.put_count > 0:
                rtn.append("set {put_name} {comp} {param}".format(put_name=self.put_name(), comp=self._owner.name, param=self.name))
            
            return rtn
            
        def __mul__(self, a):
            return self.value * a
        
        def __imul__(self, a):
            return self.value * (a)
            
        __rmul__ = __mul__
        
        def __add__(self, a):
            return self.value + (a)
        
        def __iadd__(self, a):
            return self.value + (a)
            
        __radd__ = __add__
        
        def __sub__(self, a):
            return self.value - (a)
        
        def __isub__(self, a):
            return self.value - (a)
            
        __rsub__ = __sub__
        
        def __div__(self, a):
            return self.value / (a)
        
        def __idiv__(self, a):
            return self.value / complex(a)
            
        def __pow__(self, q):
            return  self.value**q
    
        def __neg__(self):
            return -self.value
            
        def __eq__(self, q):
            return (q) == self.value
        def __ne__(self, q):
            return (q) != self.value
        def __lt__(self, q):
            return (q) > self.value
        def __gt__(self, q):
            return (q) < self.value        
            
    class AttrParam(Param):
        """
        Certain parameters of a component are set using the Finesse `attr` command.
        
        This inherits directly from a Param object so can be set whether this attribute
        is putable or a putter.
        
        If the value pf the parameter is not 0 the attr command will be printed.
        """
        def getFinesseText(self):
            rtn = []
            
            if self.value != 0:
                rtn.append("attr {0} {1} {2}".format(self._owner.name, self.name, self.value))
                
            rtn.extend(super(AttrParam, self).getFinesseText())
            
            return rtn