adding in fsig command (not parsing yet). See example test_fsig.py in bin...

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.

bin/test_fsig.py

+from pykat import finesse
+from pykat.detectors import *
+from pykat.components import *
+from pykat.commands import *
+from pykat.structs import *
+
+import numpy as np
+import pylab as pl
+
+code = """
+l l1 2 0 n1
+m m1 0.99 0.01 0 n1 n2
+s cav1 1200 n2 n3
+m m2 0.99 0.01 -0.1 n3 n4
+
+attr m2 m 1  # mech sus1
+
+ad up_refl 0 n1
+ad low_refl 0 n1
+
+qd refl_A 0 0 n1
+qd refl_Q 0 90 n1
+qd tran_A 0 0 n4
+qd tran_Q 0 90 n4
+
+put up_refl f $x1
+put low_refl f $mx1
+
+yaxis log re:im
+"""
+
+kat = finesse.kat(kat_code=code)
+
+kat.signals.apply(kat.l1.power, 1, 0)
+kat.signals.apply(kat.m1.phi, 1, 90)
+
+kat.add(xaxis('log', [1, 1000], kat.signals.f, 100))
+
+out = kat.run(printout=0, printerr=0)
+
+# using real and imag part compute the complex value of the upper and lower sidebands
+a_up = out.y[:,0] + out.y[:,1]*1j
+a_lo = out.y[:,2] + out.y[:,3]*-1j
+
+pl.figure(1)
+pl.loglog(out.x, np.abs(a_up + a_lo), out.x, np.abs((a_up - a_lo) / (1j)))
+pl.xlabel(out.xlabel)
+pl.title("Reflection quadratures with no relative carrier phase")
+pl.legend(["Amplitude","Phase"])
+pl.show()
\ No newline at end of file

pykat/commands.py

@@ -10,6 +10,7 @@ import exceptions
 from components import *
 from structs import *
 from pykat.param import Param, putter
+import pykat.exceptions as pkex
 
 class Command(object):
     def __init__(self):
@@ -50,7 +51,7 @@ class gauss(object):
         
 class xaxis(Command):
 
-    def __init__(self, scale, limits, comp, param, steps, axis_type="xaxis"):
+    def __init__(self, scale, limits, param, steps, comp=None, axis_type="xaxis"):
         self._axis_type = axis_type
 
         self.x = putter("x1")
@@ -79,20 +80,17 @@ class xaxis(Command):
 
         self.steps = int(steps)
 
-        # if entered component is a string then just store and use that
-        if isinstance(comp, str):
-            self.__comp = comp
-        elif not isinstance(comp, Component):
-            raise exceptions.ValueError("{0} has not been added".format(comp))
-        else:
-            self.__comp = comp
-
         if isinstance(param, str):
             self.__param = param
+            if comp == None:
+                raise pkex.BasePyKatException("If parameter is set with a string, the comp argument must set the component name")
+                
+            self.__comp = comp
         elif not isinstance(param, Param) :
-            raise exceptions.ValueError("param argument is not of type Param")
+            raise pkex.BasePyKatException("param argument is not of type Param")
         else:
             self.__param = param
+            self.__comp = param._owner.name
 
     @staticmethod
     def parseFinesseText(text):
@@ -108,7 +106,7 @@ class xaxis(Command):
         if len(values) != 6:
             raise exceptions.RuntimeError("xaxis Finesse code format incorrect '{0}'".format(text))
 
-        return xaxis(values[2], [values[3], values[4]], values[0], values[1], values[5], axis_type=axis_type)
+        return xaxis(values[2], [values[3], values[4]], values[1], values[5], comp=values[0], axis_type=axis_type)
 
     def getFinesseText(self):
         # store either the component name of the string provided
@@ -120,8 +118,8 @@ class xaxis(Command):
                 min(self.limits), max(self.limits), self.steps, axis_type=self._axis_type);
 
 class x2axis(xaxis):
-    def __init__(self, scale, limits, comp, param, steps):
-        xaxis.__init__(self, scale, limits, comp, param, steps, axis_type="x2axis")
+    def __init__(self, scale, limits, param, steps, comp=None):
+        xaxis.__init__(self, scale, limits, param, steps, comp=comp, axis_type="x2axis")
         self.x = putter("x2")
         self.mx = putter("mx2")
 

pykat/components.py

@@ -158,11 +158,11 @@ class AbstractMirrorComponent(Component):
 
         self.__R = Param("R", self, SIfloat(R))
         self.__T = Param("T", self, SIfloat(T))
-        self.__phi = Param("phi", self, SIfloat(phi))
+        self.__phi = Param("phi", self, SIfloat(phi), canFsig=True, fsig_name="phs")
         self.__Rcx = AttrParam("Rcx", self, SIfloat(Rcx))
         self.__Rcy = AttrParam("Rcy", self, SIfloat(Rcy))
-        self.__xbeta = AttrParam("xbeta", self, SIfloat(xbeta))
-        self.__ybeta = AttrParam("ybeta", self, SIfloat(ybeta))
+        self.__xbeta = AttrParam("xbeta", self, SIfloat(xbeta), canFsig=True, fsig_name="x")
+        self.__ybeta = AttrParam("ybeta", self, SIfloat(ybeta), canFsig=True, fsig_name="y")
         self.__mass = AttrParam("mass", self, SIfloat(mass))
         self.__r_ap = AttrParam("r_ap", self, SIfloat(r_ap))
         
@@ -682,9 +682,9 @@ class laser(Component):
         
         self._requested_node_names.append(node)
         
-        self.__power = Param("P", self, SIfloat(P))
-        self.__f_offset = Param("f", self, SIfloat(f_offset))
-        self.__phase = Param("phase", self, SIfloat(phase))
+        self.__power = Param("P", self, SIfloat(P), canFsig=True, fsig_name="amp")
+        self.__f_offset = Param("f", self, SIfloat(f_offset), canFsig=True, fsig_name="f")
+        self.__phase = Param("phase", self, SIfloat(phase), canFsig=True, fsig_name="phs")
         self.__noise = AttrParam("noise", self, 0)
         
     @property

pykat/finesse.py

@@ -40,6 +40,7 @@ from pykat.components import Component
 from pykat.commands import Command, xaxis
 from pykat.gui.gui import pyKatGUI
 from pykat.SIfloat import *
+from pykat.param import Param, AttrParam
 
 import pykat.exceptions as pkex
 
@@ -128,6 +129,97 @@ class katRun2D(object):
         else:
             raise  pkex.BasePyKatException("No output by the name {0} found".format(str(value)))
     
+class Signals:
+    class fsig:
+        def __init__(self, param, name, amplitude, phase):
+            self._params = []
+            self.__target = param
+            self.__name = name
+            self.__amplitude = Param("amp", self, SIfloat(amplitude))
+            self.__phase = Param("phase", self, SIfloat(phase))
+            
+            # unfortunatenly the target names for fsig are not the same as the
+            # various parameter names of the components, e.g. mirror xbeta is x 
+            # for fsig. So we need to check here what type of component we are targetting
+            # and then based on the parameter specfied get the name
+            if not param.canFsig:
+                raise  pkex.BasePyKatException("Cannot fsig parameter {1} on component {0}".format(str(param._owner), param.name))
+            
+            
+        def _register_param(self, param):
+            self._params.append(param)
+  
+        @property
+        def name(self): return self.__name
+
+        @property
+        def amplitude(self): return self.__amplitude
+
+        @property
+        def phase(self): return self.__phase
+
+        @property
+        def target(self): return self.__target.fsig_name
+
+        @property
+        def owner(self): return self.__target._owner.name
+    
+        def getFinesseText(self):
+            rtn = []
+    
+            for p in self._params:
+                rtn.extend(p.getFinesseText())
+        
+            return rtn
+    
+    @property
+    def name(self):
+        # if we don't have any signals yet then use a dummy name
+        # however we need to always tune a real fsig command
+        # so need to get the name of at least one of them
+        # as if you tune one you tune them all
+        if len(self.targets) == 0:
+            return "signal"
+        else:
+            return self.targets[0].name
+
+    @property
+    def f(self): return self.__f
+    
+    def __init__(self):
+
+        self.targets = []
+        self._params = []
+        
+        self.__f = Param("f", self, 1)
+    
+    def _register_param(self, param):
+        self._params.append(param)
+        
+    def apply(self, target, amplitude, phase, name=None):
+        
+        if target == None:
+            raise  pkex.BasePyKatException("No target was specified for signal to be applied")
+        
+        if name == None:
+            name = "sig_" +target._owner.name + "_" + target.name
+        
+        self.targets.append(Signals.fsig(target, name, amplitude, phase))
+        
+        
+    def getFinesseText(self):
+        rtn = []
+        
+        for t in self.targets:
+            rtn.extend(t.getFinesseText())
+            rtn.append("fsig {name} {comp} {target} {frequency} {phase} {amplitude}".format(name = t.name, comp=t.owner, target=t.target, frequency=str(self.f), phase=str(t.phase), amplitude=str(t.amplitude)))
+        
+        for p in self._params:
+            rtn.extend(p.getFinesseText())
+        
+        return rtn
+        
+        
 class Block:
     def __init__(self, name):
         self.__name = name
@@ -154,6 +246,7 @@ class kat(object):
         self.__tempdir = tempdir
         self.__tempname = tempname
         self.pykatgui = None
+        self.__signals = Signals()
         
         # initialise default block
         self.__currentTag= NO_BLOCK
@@ -181,6 +274,9 @@ class kat(object):
         cls = type(self)
         self.__class__ = type(cls.__name__, (cls,), {})
         
+    @property
+    def signals(self): return self.__signals
+
     @property
     def maxtem(self): return self.__maxtem
     @maxtem.setter
@@ -689,6 +785,16 @@ class kat(object):
                     out.append(txt + "\n")
         
 
+        # now get any signal commands
+        txt = self.signals.getFinesseText()
+        
+        if txt != None:
+            if isinstance(txt,list):
+                for t in txt: out.append(t+ "\n")
+            else:
+                out.append(txt + "\n")
+                            
+
         if self.scale != None and self.scale !='': out.append("scale {0}\n".format(self.scale))
         if self.phase != None: out.append("phase {0}\n".format(self.phase))
         if self.maxtem != None: out.append("maxtem {0}\n".format(self.maxtem))            

pykat/param.py

@@ -57,13 +57,22 @@ class putter(object):
         
 class Param(putable, putter):
 
-    def __init__(self, name, owner, value, isPutable=True, isPutter=True, isTunable=True, var_name=None):
+    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:
@@ -74,6 +83,12 @@ class Param(putable, putter):
         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