detectors.py 18.7 KB
Newer Older
Daniel Brown's avatar
Daniel Brown committed
1
2
# -*- coding: utf-8 -*-
"""
Daniel Brown's avatar
Daniel Brown committed
3
Created on Fri Feb 01 0split()9:09:10 2013
Daniel Brown's avatar
Daniel Brown committed
4
5
6
7
8
9
10
11
12

@author: Daniel
"""
import exceptions
import pykat.gui.resources

from pykat.utils import *
from pykat.gui.graphics import *
from pykat.node_network import *
13
from pykat.param import Param
14

15
16
import pykat.exceptions as pkex
import warnings
Daniel Brown's avatar
Daniel Brown committed
17
18
19
20
21
22
23
24
25
26
27

class Detector(object) :
    def __init__(self, name,node):
        self.__name = name
        self._svgItem = None
        self._kat = None
        self.noplot = False
        self.enabled = True
        self.tag = None
        self.__node = None
        self._params = []
28
        self._mask = {}
29
        self.__scale = None
30

31
32
33
34
        if node != None:
            if node[-1]=='*':
                self._alternate_beam = True
                node=node[:-1]
35
            
36
            self.__requested_node = node
Daniel Brown's avatar
Daniel Brown committed
37
38
39
40
41
    
    def _register_param(self, param):
        self._params.append(param)
        
    def _on_kat_add(self, kat):
42
43
        if self.__requested_node != None:
            self.__node = kat.nodes.createNode(self.__requested_node)
Daniel Brown's avatar
Daniel Brown committed
44
45
46
47
48
49
50
51
52
53
54
    
    @staticmethod
    def parseFinesseText(text):    
        raise NotImplementedError("This function is not implemented")
        
    def getFinesseText(self):
        """ Base class for individual finesse optical components """    
        raise NotImplementedError("This function is not implemented")
        
    def getQGraphicsItem(self):    
        return None
55
56
57
58

    @property 
    def scale(self): return self.__scale
    @scale.setter
59
60
    def scale(self, value):
        self.__scale = value
61

Daniel Brown's avatar
Daniel Brown committed
62
63
64
65
66
67
68
69
70
71
72
73
74
75
    @property 
    def node(self): return self.__node
    @node.setter
    def node(self, value):
        if value in self._kat.nodes:
            self.__node = self._kat.nodes[value]
        else:
            raise pkex.BasePyKatException("There is no node called " + value)
    
    @property
    def name(self): return self.__name        

    def __str__(self): return self.name

76
77
78
79
80
81
82
83
84
    def mask(self, n, m, factor):
        id = str(n)+"_"+str(m)
        
        # if the mask is 1 then remove this so it doesn't get 
        # printed as by default the value is 1.0
        if id in self._mask and factor == 1.0:
            del self._mask[id]
                
        self._mask[id] = factor
Daniel Brown's avatar
Daniel Brown committed
85
86
87
88
89
90
91
92

class ad(Detector):
    
    def __init__(self, name, frequency, node_name, mode=None, alternate_beam=False):
        Detector.__init__(self, name, node_name)
        self.mode = mode
        self.alternate_beam = alternate_beam
        self.__f = Param("f", self, frequency)
Daniel Brown's avatar
Daniel Brown committed
93
    
Daniel Brown's avatar
Daniel Brown committed
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
    @property
    def mode(self): return self.__mode
    @mode.setter
    def mode(self, value):
        if value != None and len(value) != 2:
            raise pkex.BasePyKatException('Mode must be a container of length 2, first element the x mode and second the y mode')
    
        self.__mode = value
        
    @property
    def f(self): return self.__f
    @f.setter
    def f(self, value): 
        self.__f.value = value
        
    @staticmethod
    def parseFinesseText(text): 
        values = text.split()
112
113
114

        node=values[-1]
        alt_beam = node[-1] == '*'
Daniel Brown's avatar
Daniel Brown committed
115
116
117
        if len(values) == 6:
            return ad(values[1], values[4], values[5], mode = [int(values[2]), int(values[3])], alternate_beam=alt_beam)
        elif len(values) == 4:
118
            return ad(values[1], values[2], values[3], alternate_beam=alt_beam)
Daniel Brown's avatar
Daniel Brown committed
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
        else:
            raise pkex.BasePyKatException('Amplitude detector code "{0}" is not a valid FINESSE command'.format(text))
            
    def getFinesseText(self) :
        rtn = []
        
        if self.alternate_beam:
            alt = '*'
        else:
            alt = ''
        
        if self.mode == None:
            rtn.append("ad {name} {f} {node}{alt}".format(name=self.name, f=str(self.f.value), node=self.node.name, alt=alt))
        else:
            rtn.append("ad {name} {n} {m} {f} {node}{alt}".fomat(name=self.name, n=str(self.mode[0]), m=str(self.mode[1]), f=str(self.f.value), node=self.node.name, alt=alt))
            
        for p in self._params:
            rtn.extend(p.getFinesseText())
        
        return rtn
        
140
141
class pd(Detector):

142
    def __init__(self, name, num_demods, node_name, senstype=None, alternate_beam=False, pdtype=None, **kwargs):
Daniel Brown's avatar
Daniel Brown committed
143
144
145
146
        Detector.__init__(self, name, node_name)
        
        self.__num_demods = num_demods
        self.__senstype = senstype
Daniel Brown's avatar
Daniel Brown committed
147
        self.alternate_beam = alternate_beam
148
149
        self.__pdtype = pdtype

Daniel Brown's avatar
Daniel Brown committed
150
151
152
153
        # create the parameters for all 5 demodulations regardless
        # of how many the user specifies. Later we add properties to
        # those which correspond to the number of demodulations
        
154
155
156
157
158
        self.__f1 = Param("f1", self, None)
        self.__f2 = Param("f2", self, None)
        self.__f3 = Param("f3", self, None)
        self.__f4 = Param("f4", self, None)
        self.__f5 = Param("f5", self, None)
Daniel Brown's avatar
Daniel Brown committed
159
160
161
162
163
164
165
        
        self.__phi1 = Param("phi1", self, None)
        self.__phi2 = Param("phi2", self, None)
        self.__phi3 = Param("phi3", self, None)
        self.__phi4 = Param("phi4", self, None)
        self.__phi5 = Param("phi5", self, None)
        
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
        fs = [self.__f1, self.__f2, self.__f3, self.__f4, self.__f5]
        ps = [self.__phi1, self.__phi2, self.__phi3, self.__phi4, self.__phi5]
        
        for i in range(num_demods):
            f = 'f{0}'.format(i+1)
            
            if f in kwargs:
                fs[i].value = kwargs[f]
            else:
                raise pkex.BasePyKatException("Missing demodulation frequency {0} (f{0})".format(i+1))    
        
            p = 'phi{0}'.format(i+1)
            
            if p in kwargs:
                if kwargs[p] == None and i<num_demods-1:
                    raise pkex.BasePyKatException("Missing demodulation phase {0} (phi{0})".format(i+1))
                    
                ps[i].value = kwargs[p]
            elif i<num_demods-1:
                raise pkex.BasePyKatException("Missing demodulation phase {0} (phi{0})".format(i+1))
        
Daniel Brown's avatar
Daniel Brown committed
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
        # define new class for assigning new attributes
        cls = type(self)
        self.__class__ = type(cls.__name__, (cls,), {})
    
        self.__set_demod_attrs()
        
    @property
    def senstype(self): return self.__senstype
    @senstype.setter
    def senstype(self,value):
        if value == "": value = None
        
        if value != "S" and value != "N" and value != None: 
            raise pkex.BasePyKatException("Photodiode sensitivity type can either be 'N', 'S' or None.")
            
        self.__senstype = value
        
204
    @property
Daniel Brown's avatar
Daniel Brown committed
205
206
207
208
209
210
211
212
    def num_demods(self): return self.__num_demods
    @num_demods.setter
    def num_demods(self, value): 
        if value < 0 or value > 5:
            raise pkex.BasePyKatException("Number of demodulations must be between 0 and 5")
        
        self.__num_demods = value
        self.__set_demod_attrs()
213
214
215
216
217

    @property
    def pdtype(self): return self.__pdtype
    @pdtype.setter
    def pdtype(self, value): self.__pdtype = value
Daniel Brown's avatar
Daniel Brown committed
218
219
    
    def __get_fphi(self, name):
Daniel Brown's avatar
Daniel Brown committed
220
        return getattr(self, '_pd__' + name)
Daniel Brown's avatar
Daniel Brown committed
221
222
    
    def __set_f(self, num, value):
Daniel Brown's avatar
Daniel Brown committed
223
        setattr(self, '_pd__f' + num, float(value))
Daniel Brown's avatar
Daniel Brown committed
224
225
226
227
228
229
230
231
232
    
    def __set_phi(self, num, value):
        if value == None and num != self.num_demods:
            # check if we are setting no phase that this is only on the last
            # demodulation phase.
            raise pkex.BasePyKatException("Only last demodulation phase can be set to None")
        elif isinstance(value, str) and not isinstance(value,float) and value.lower() != "max":
            raise pkex.BasePyKatException("Demodulation phase can only be set to a 'max' or a number (or None if the last demodulation phase)")
            
Sean Leavey's avatar
Sean Leavey committed
233
        setattr(self, '_'+ self.__class__.__name__ +'__phi' + num, value)
Daniel Brown's avatar
Daniel Brown committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
        
    def __set_demod_attrs(self):
        """
        For the set number of demodulations the correct number of 
        Parameters are created.
        """
        
        # if there are demodulations present then we want to add
        # the various parameters so they are available for users
        # to play with.
        if self.__num_demods > 0:
            for i in range(1,6):
                name = str(i)
                if i <= self.num_demods:
                    if not hasattr(self, "f"+name):
                        setattr(self.__class__, "f"+name, property(fget=lambda self, i=i: self.__get_fphi('f'+str(i)), fset=lambda self, value, i=i: self.__set_f(str(i), value)))
                    
                    if not hasattr(self, "phi"+name):
                        setattr(self.__class__, "phi"+name, property(fget=lambda self, i=i: self.__get_fphi('phi'+str(i)), fset=lambda self, value, i=i: self.__set_phi(str(i), value)))
                else:
                    if hasattr(self, "f"+name):
                        delattr(self.__class__, "f"+name)
                    if hasattr(self, "phi"+name):
                        delattr(self.__class__, "phi"+name)
        else:
            return
    
261
262
    @staticmethod
    def parseFinesseText(text): 
Daniel Brown's avatar
Daniel Brown committed
263
        values = text.split()
264
265
266
267
268
269
270
271
        demods = 0
        senstype = None

        if len(values[0]) == 4:
            senstype = values[0][2]
            demods = int(values[0][3])
        elif len(values[0]) == 3:
            demods = int(values[0][2])
Daniel Brown's avatar
Daniel Brown committed
272
        elif len(values[0]) != 2:
273
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (1)".format(text))
274
275
        
        if len(values) <= 3 and demods > 0:
276
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (2)".format(text))
Daniel Brown's avatar
Daniel Brown committed
277
        elif len(values) > 3 and demods == 0:
278
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (3)".format(text))
279
280
281
282
            
        num_f_phs = len(values) - 3
        expected_f_phs = demods * 2
        
283
284
        if not (num_f_phs == expected_f_phs or num_f_phs == expected_f_phs-1):
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (4)".format(text))
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
        
        f = values[2:len(values)-1:2]    
        phs = values[3:len(values)-1:2]
        
        dict = {}
        
        for i in range(len(f)):
            dict['f{0}'.format(i+1)] = f[i]
        for i in range(len(phs)):
            dict['phi{0}'.format(i+1)] = phs[i]
            
        node = values[-1]
        alt_beam = node[-1] == '*'
        
        if alt_beam:
            node = node[0:-1]
        
        return pd(values[1], demods, node, senstype=senstype, alternate_beam=alt_beam, **dict)

        
Daniel Brown's avatar
Daniel Brown committed
305
306
307
308
309
310
311
    def getFinesseText(self) :
        rtn = []
        
        if self.enabled:
            alt_str = ""
            fphi_str = ""
            
Daniel Brown's avatar
Daniel Brown committed
312
            if self.alternate_beam:
Daniel Brown's avatar
Daniel Brown committed
313
314
315
                alt_str = "*"
                
            for n in range(1, 1+self.num_demods):
Sean Leavey's avatar
Sean Leavey committed
316
                fphi_str += " " + str(self.__getattribute__("f"+str(n)))
Daniel Brown's avatar
Daniel Brown committed
317
318
319
320
321
322
323
324
325
                phi_val = self.__getattribute__("phi"+str(n))
                
                if phi_val != None:
                    fphi_str += " " + str(phi_val)
            
            senstype = self.senstype
            
            if senstype == None:
                senstype = ""
326
            
Sean Leavey's avatar
Sean Leavey committed
327
            rtn.append("pd{0}{1} {2}{3} {4}{5}".format(senstype, self.num_demods, self.name, fphi_str, self.node.name, alt_str))
328
329
330
331
332
333

            if self.scale != None:
                rtn.append("scale {1} {0}".format(self.name, self.scale))

            if self.pdtype != None:
                rtn.append("pdtype {0} {1}".format(self.name, self.pdtype))
334
                
335
336
            for p in self._params:
                rtn.extend(p.getFinesseText())
Daniel Brown's avatar
Daniel Brown committed
337
338
            
        return rtn
339
  
Daniel Brown's avatar
Daniel Brown committed
340
class qnoised(pd):
341
342
    
    def __init__(self, name, num_demods, node_name, alternate_beam=False, pdtype=None, **kwargs):
Daniel Brown's avatar
Daniel Brown committed
343
        super(qnoised, self).__init__(name, num_demods, node_name, alternate_beam=alternate_beam, pdtype=pdtype, **kwargs)
344
345
346
347
348
349
350
351
352
    
        self.__homangle = AttrParam("homangle", self, None)
    
    @property
    def homangle(self): return self.__homangle
    @homangle.setter
    def homangle(self, value): self.__homangle.value = value
    
    @pd.pdtype.setter
Daniel Brown's avatar
Daniel Brown committed
353
354
    def pdtype(self, value):
        raise pkex.BasePyKatException("Setting pdtype is not possible with qnoised detectors")
355
356
    
    @pd.senstype.setter
Daniel Brown's avatar
Daniel Brown committed
357
358
    def senstype(self,value):
        raise pkex.BasePyKatException("qnoised detector has no sensitvity type")
359
    
Daniel Brown's avatar
Daniel Brown committed
360
361
362
363
364
365
366
    def parseAttributes(self, values):
        
        for key in values.keys():
            if key in ["homangle"]:
                self.__homangle.value = values[key]
            else:
                raise pkex.BasePyKatException("No attribute {0} for qnoised".format(key))
367
368
369
370
    
    @staticmethod
    def parseFinesseText(text): 
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
371

372
        if len(values) <= 3:
Daniel Brown's avatar
Daniel Brown committed
373
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (2)".format(text))
Daniel Brown's avatar
Daniel Brown committed
374
            
Daniel Brown's avatar
Daniel Brown committed
375
        demods = int(values[2])
376
        
377
        if len(values) <= 4 and demods > 0:
Daniel Brown's avatar
Daniel Brown committed
378
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (2)".format(text))
379
        elif len(values) > 4 and demods == 0:
Daniel Brown's avatar
Daniel Brown committed
380
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (3)".format(text))
381
382
383
384
            
        num_f_phs = len(values) - 4
        expected_f_phs = demods * 2
        
Daniel Brown's avatar
Daniel Brown committed
385
386
        if not (num_f_phs == expected_f_phs or num_f_phs == (expected_f_phs-1)):
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (4)".format(text))
387
388
389
390
391
        
        f = values[3:len(values)-1:2]    
        phs = values[4:len(values)-1:2]
        
        dict = {}
Daniel Brown's avatar
Daniel Brown committed
392
        
393
394
395
396
        for i in range(len(f)):
            dict['f{0}'.format(i+1)] = f[i]
        for i in range(len(phs)):
            dict['phi{0}'.format(i+1)] = phs[i]
Daniel Brown's avatar
Daniel Brown committed
397
            
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
        node = values[-1]
        alt_beam = node[-1] == '*'
        
        if alt_beam:
            node = node[0:-1]
        
        return qnoised(values[1], demods, node, alternate_beam=alt_beam, **dict)
    
    def getFinesseText(self) :
        rtn = []
        
        if self.enabled:
            alt_str = ""
            fphi_str = ""
            
            if self.alternate_beam:
                alt_str = "*"
                
            for n in range(1, 1+self.num_demods):
                fphi_str += " " + str(self.__getattribute__("f"+str(n)))
                phi_val = self.__getattribute__("phi"+str(n))
                
                if phi_val != None:
                    fphi_str += " " + str(phi_val)
            
            senstype = self.senstype
            
            if senstype == None:
                senstype = ""
                
            rtn.append("qnoised {0} {1} {2} {3}{4}".format(self.name, self.num_demods, fphi_str, self.node.name, alt_str))
Andreas Freise's avatar
Andreas Freise committed
429

430
431
432
433
434
435
436
            if self.scale != None:
                rtn.append("scale {1} {0}".format(self.name, self.scale))
                
            for p in self._params:
                rtn.extend(p.getFinesseText())
            
        return rtn
Daniel Brown's avatar
Daniel Brown committed
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487

class qnoised(pd):
    
    def __init__(self, name, num_demods, node_name, alternate_beam=False, **kwargs):
        super(qnoised, self).__init__(name, num_demods, node_name, alternate_beam=alternate_beam, pdtype=None, senstype=None, **kwargs)
    
    @pd.pdtype.setter
    def pdtype(self, value):
        raise pkex.BasePyKatException("Setting pdtype is not possible with qshot detectors")
    
    @pd.senstype.setter
    def senstype(self,value):
        raise pkex.BasePyKatException("qshot detector has no sensitvity type")
    
    @staticmethod
    def parseFinesseText(text): 
        values = text.split()

        if len(values) <= 3:
            raise pkex.BasePyKatException("qshot code format incorrect '{0}' (2)".format(text))
            
        demods = int(values[2])
        
        if len(values) <= 4 and demods > 0:
            raise pkex.BasePyKatException("qshot code format incorrect '{0}' (2)".format(text))
        elif len(values) > 4 and demods == 0:
            raise pkex.BasePyKatException("qshot code format incorrect '{0}' (3)".format(text))
            
        num_f_phs = len(values) - 4
        expected_f_phs = demods * 2
        
        if not (num_f_phs == expected_f_phs or num_f_phs == (expected_f_phs-1)):
            raise pkex.BasePyKatException("qshot code format incorrect '{0}' (4)".format(text))
        
        f = values[3:len(values)-1:2]    
        phs = values[4:len(values)-1:2]
        
        dict = {}
        
        for i in range(len(f)):
            dict['f{0}'.format(i+1)] = f[i]
        for i in range(len(phs)):
            dict['phi{0}'.format(i+1)] = phs[i]
            
        node = values[-1]
        alt_beam = node[-1] == '*'
        
        if alt_beam:
            node = node[0:-1]
        
        return qnoised(values[1], demods, node, alternate_beam=alt_beam, **dict)
488
    
Daniel Brown's avatar
Daniel Brown committed
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
    def getFinesseText(self) :
        rtn = []
        
        if self.enabled:
            alt_str = ""
            fphi_str = ""
            
            if self.alternate_beam:
                alt_str = "*"
                
            for n in range(1, 1+self.num_demods):
                fphi_str += " " + str(self.__getattribute__("f"+str(n)))
                phi_val = self.__getattribute__("phi"+str(n))
                
                if phi_val != None:
                    fphi_str += " " + str(phi_val)
            
            senstype = self.senstype
            
            if senstype == None:
                senstype = ""
                
            rtn.append("qshot {0} {1} {2} {3}{4}".format(self.name, self.num_demods, fphi_str, self.node.name, alt_str))

            if self.scale != None:
                rtn.append("scale {1} {0}".format(self.name, self.scale))
                
            for p in self._params:
                rtn.extend(p.getFinesseText())
            
        return rtn
        
521
def xd(Detector):
Daniel Brown's avatar
Daniel Brown committed
522

523
524
    def __init__(self, name, node_name, component, motion):
        Detector.__init__(name, None)
Daniel Brown's avatar
Daniel Brown committed
525
        
526
527
        self.__motion = motion
        self.__component = component
Daniel Brown's avatar
Daniel Brown committed
528
        
529
530
531
532
533
534
    @property
    def motion(self): return self.__motion
    
    @property
    def component(self): return self.__component
    
Daniel Brown's avatar
Daniel Brown committed
535
536
    @staticmethod
    def parseFinesseText(text): 
Daniel Brown's avatar
Daniel Brown committed
537
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
538

539
540
541
542
543
        if len(values) != 4:
            raise pkex.BasePyKatException("Motion detector command format incorrect '{0}' (2)".format(text))
            
        return xd(values[1], values[2], values[3])
    
Daniel Brown's avatar
Daniel Brown committed
544
    def getFinesseText(self) :
545
546
        rtn = []
        
Daniel Brown's avatar
Daniel Brown committed
547
        if self.enabled:
548
            rtn.append("xd {0} {1} {2}".format(self.name, self.component, self.motion))
549

550
            if self.scale != None:
551
                rtn.append("scale {1} {0}".format(self.name, self.scale))
552
553
554
                
            for p in self._params:
                rtn.extend(p.getFinesseText())
Daniel Brown's avatar
Daniel Brown committed
555
            
556
        return rtn
Daniel Brown's avatar
Daniel Brown committed
557
    
558