commands.py 6.12 KB
Newer Older
Daniel Brown's avatar
Daniel Brown committed
1
2
3
4
5
6
7
8
9
10
11
12
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 28 11:58:09 2013

@author: Daniel
"""
import numpy
from numpy import min,max
import exceptions
from components import *
from structs import *
from pykat.param import Param, putter
13
import pykat.exceptions as pkex
Daniel Brown's avatar
Daniel Brown committed
14
from collections import namedtuple
Daniel Brown's avatar
Daniel Brown committed
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class Command(object):
    def __init__(self):
        self.tag = None

    def getFinesseText(self):
        """ Base class for individual finesse optical components """
        raise NotImplementedError("This function is not implemented")

    @staticmethod
    def parseFinesseText(text):
        raise NotImplementedError("This function is not implemented")

    def _on_kat_add(self, kat):
        """
        Called when this component has been added to a kat object
        """
        self._kat = kat

class cavity(Command):
    def __init__(self, name, c1, n1, c2, n2):
        self.__name = name
        self.__c1 = c1
        self.__c2 = c2
        self.__n1 = n1
        self.__n2 = n2

    def getFinesseText(self):
        return 'cav {0} {1} {2} {3} {4}'.format(self.__name, self.__c1, self.__n1, self.__c2, self.__n2);

class gauss(object):
    @staticmethod
    def parseFinesseText(text, kat):
48
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
49

50
        if not values[0].startswith("gauss") or (len(values) != 6 and len(values != 8)):
51
52
            raise exceptions.RuntimeError("'{0}' not a valid Finesse gauss command".format(text))        
        
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
        name = values[1]
        component = values[2]
        node = values[3]
        
        
        
        if values[0].endswith("**"):
            if len(values) == 6:
                print ""
            elif len(values) == 8:
                print ""
        elif values[0].endswith("*"):
            if len(values) == 6:
                print ""
            elif len(values) == 8:
                print ""
        else:
            if len(values) == 6:
                print ""
            elif len(values) == 8:
                print ""
            
Daniel Brown's avatar
Daniel Brown committed
75
76
77
78
79
80
class tf(Command):
    fQ = namedtuple('fQ', 'f', 'Q')
    
    def __init__(self, name, poles, zeros):
        pass
      
Daniel Brown's avatar
Daniel Brown committed
81
class xaxis(Command):
82
83
84
85
86
    """
    The xaxis object is a unique object to each pykat.finesse.kat instance. It provides
    and interface to the xaxis command in FINESSE.
    """
    
87
    def __init__(self, scale, limits, param, steps, comp=None, axis_type="xaxis"):
88
89
90
91
92
93
94
95
96
        """
        Typical usage:
            xaxis(["lin" or "log"], [upper, lower], param, steps)
            
        param must be an object of the type pykat.param.Param whose
        isPutable() member returns true.
        
        steps is the number of points to compute between upper and lower limits.
        """
Daniel Brown's avatar
Daniel Brown committed
97
98
99
100
101
102
        self._axis_type = axis_type

        self.x = putter("x1")
        self.mx = putter("mx1")

        if scale == "lin":
103
            scale = Scale.linear
Daniel Brown's avatar
Daniel Brown committed
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
        elif scale == "log":
            scale = Scale.logarithmic
        elif isinstance(scale, str):
            # else we have a string but not a recognisable one
            raise exceptions.ValueError("scale argument '{0}' is not valid, must be 'lin' or 'log'".format(scale))

        if scale != Scale.linear and scale != Scale.logarithmic:
            raise exceptions.ValueError("scale is not Scale.linear or Scale.logarithmic")

        self.scale = scale

        if numpy.size(limits) != 2 :
            raise exceptions.ValueError("limits input should be a 2x1 vector of limits for the xaxis")

        self.limits = numpy.array(SIfloat(limits)).astype(float)

        if steps <= 0 :
            raise exceptions.ValueError("steps value should be > 0")

        self.steps = int(steps)

        if isinstance(param, str):
            self.__param = param
127
128
129
130
            if comp == None:
                raise pkex.BasePyKatException("If parameter is set with a string, the comp argument must set the component name")
                
            self.__comp = comp
Daniel Brown's avatar
Daniel Brown committed
131
        elif not isinstance(param, Param) :
132
            raise pkex.BasePyKatException("param argument is not of type Param")
Daniel Brown's avatar
Daniel Brown committed
133
134
        else:
            self.__param = param
135
            self.__comp = param._owner.name
Daniel Brown's avatar
Daniel Brown committed
136

137
138
139
140
141
142
143
144
145
146
    @property
    def param(self): return self.__param
    @param.setter
    def param(self, value):
	if not isinstance(value, Param):
		raise pkex.BasePyKatException("param argument is not of type Param")
	else:
		self.__param = value
		self.__comp = value._owner.name

Daniel Brown's avatar
Daniel Brown committed
147
148
    @staticmethod
    def parseFinesseText(text):
149
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
150
151
152
153
154
155
156
157
158
159
160

        if values[0] != "xaxis" and values[0] != "xaxis*":
            raise exceptions.RuntimeError("'{0}' not a valid Finesse xaxis command".format(text))

        axis_type = values[0]

        values.pop(0) # remove initial value

        if len(values) != 6:
            raise exceptions.RuntimeError("xaxis Finesse code format incorrect '{0}'".format(text))

161
        return xaxis(values[2], [values[3], values[4]], values[1], values[5], comp=values[0], axis_type=axis_type)
Daniel Brown's avatar
Daniel Brown committed
162
163
164
165
166
167
168
169
170
171
172

    def getFinesseText(self):
        # store either the component name of the string provided
        comp_name = self.__comp.name if isinstance(self.__comp, Component) else self.__comp
        param_name = self.__param.name if isinstance(self.__param, Param) else self.__param

        return '{axis_type} {0} {1} {2} {3} {4} {5}'.format(
                comp_name, param_name, self.scale,
                min(self.limits), max(self.limits), self.steps, axis_type=self._axis_type);

class x2axis(xaxis):
173
174
    def __init__(self, scale, limits, param, steps, comp=None):
        xaxis.__init__(self, scale, limits, param, steps, comp=comp, axis_type="x2axis")
Daniel Brown's avatar
Daniel Brown committed
175
176
177
178
179
        self.x = putter("x2")
        self.mx = putter("mx2")

    @staticmethod
    def parseFinesseText(text):
180
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
181
182
183
184
185
186
187
188
189
190
191

        if values[0] != "x2axis" and values[0] != "x2axis*":
            raise exceptions.RuntimeError("'{0}' not a valid Finesse xaxis command".format(text))

        axis_type = values[0]

        values.pop(0) # remove initial value

        if len(values) != 6:
            raise exceptions.RuntimeError("xaxis Finesse code format incorrect '{0}'".format(text))

192
        return x2axis(values[2], [values[3], values[4]], values[1], values[5], comp=values[0])