detectors.py 19.3 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
        self.__removed = False
        
32
33
34
35
        if node != None:
            if node[-1]=='*':
                self._alternate_beam = True
                node=node[:-1]
36
            
37
            self.__requested_node = node
Daniel Brown's avatar
Daniel Brown committed
38
39
40
41
42
    
    def _register_param(self, param):
        self._params.append(param)
        
    def _on_kat_add(self, kat):
43
44
        self._kat = kat
        
45
46
        if self.__requested_node != None:
            self.__node = kat.nodes.createNode(self.__requested_node)
Daniel Brown's avatar
Daniel Brown committed
47
    
48
49
50
51
52
53
54
55
    def remove(self):
        if self.__removed:
            raise pkex.BasePyKatException("{0} has already been marked as removed".format(self.name))
        else:
            self._kat.remove(self)
    
        self.__removed = True
        
Daniel Brown's avatar
Daniel Brown committed
56
57
58
59
60
61
62
63
64
65
    @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
66

67
68
69
70
        
    @property
    def removed(self): return self.__removed
    
71
72
73
    @property 
    def scale(self): return self.__scale
    @scale.setter
74
75
    def scale(self, value):
        self.__scale = value
76

Daniel Brown's avatar
Daniel Brown committed
77
78
79
80
81
82
83
84
85
86
87
88
89
90
    @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

91
92
93
94
95
96
97
98
99
    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
100
101
102
103
104
105
106
107

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
108
    
Daniel Brown's avatar
Daniel Brown committed
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
    @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()
127
128
129

        node=values[-1]
        alt_beam = node[-1] == '*'
Daniel Brown's avatar
Daniel Brown committed
130
131
132
        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:
133
            return ad(values[1], values[2], values[3], alternate_beam=alt_beam)
Daniel Brown's avatar
Daniel Brown committed
134
135
136
137
138
139
140
141
142
143
144
145
146
147
        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:
148
            rtn.append("ad {name} {n} {m} {f} {node}{alt}".format(name=self.name, n=str(self.mode[0]), m=str(self.mode[1]), f=str(self.f.value), node=self.node.name, alt=alt))
Daniel Brown's avatar
Daniel Brown committed
149
150
151
152
153
154
            
        for p in self._params:
            rtn.extend(p.getFinesseText())
        
        return rtn
        
155
156
class pd(Detector):

157
    def __init__(self, name, num_demods, node_name, senstype=None, alternate_beam=False, pdtype=None, **kwargs):
Daniel Brown's avatar
Daniel Brown committed
158
159
160
161
        Detector.__init__(self, name, node_name)
        
        self.__num_demods = num_demods
        self.__senstype = senstype
Daniel Brown's avatar
Daniel Brown committed
162
        self.alternate_beam = alternate_beam
163
164
        self.__pdtype = pdtype

Daniel Brown's avatar
Daniel Brown committed
165
166
167
168
        # 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
        
169
170
171
172
173
        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
174
175
176
177
178
179
180
        
        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)
        
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
        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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
        # 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
        
219
    @property
Daniel Brown's avatar
Daniel Brown committed
220
221
222
223
224
225
226
227
    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()
228
229
230
231
232

    @property
    def pdtype(self): return self.__pdtype
    @pdtype.setter
    def pdtype(self, value): self.__pdtype = value
Daniel Brown's avatar
Daniel Brown committed
233
234
    
    def __get_fphi(self, name):
Daniel Brown's avatar
Daniel Brown committed
235
        return getattr(self, '_pd__' + name)
Daniel Brown's avatar
Daniel Brown committed
236
237
    
    def __set_f(self, num, value):
Daniel Brown's avatar
Daniel Brown committed
238
        setattr(self, '_pd__f' + num, float(value))
Daniel Brown's avatar
Daniel Brown committed
239
240
241
242
243
244
245
246
247
    
    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
248
        setattr(self, '_'+ self.__class__.__name__ +'__phi' + num, value)
Daniel Brown's avatar
Daniel Brown committed
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
        
    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
    
276
277
    @staticmethod
    def parseFinesseText(text): 
Daniel Brown's avatar
Daniel Brown committed
278
        values = text.split()
279
280
281
282
283
284
285
286
        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
287
        elif len(values[0]) != 2:
288
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (1)".format(text))
289
290
        
        if len(values) <= 3 and demods > 0:
291
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (2)".format(text))
Daniel Brown's avatar
Daniel Brown committed
292
        elif len(values) > 3 and demods == 0:
293
            raise pkex.BasePyKatException("Photodiode code format incorrect '{0}' (3)".format(text))
294
295
296
297
            
        num_f_phs = len(values) - 3
        expected_f_phs = demods * 2
        
298
299
        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))
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
        
        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
320
321
322
323
324
325
326
    def getFinesseText(self) :
        rtn = []
        
        if self.enabled:
            alt_str = ""
            fphi_str = ""
            
Daniel Brown's avatar
Daniel Brown committed
327
            if self.alternate_beam:
Daniel Brown's avatar
Daniel Brown committed
328
329
330
                alt_str = "*"
                
            for n in range(1, 1+self.num_demods):
Sean Leavey's avatar
Sean Leavey committed
331
                fphi_str += " " + str(self.__getattribute__("f"+str(n)))
Daniel Brown's avatar
Daniel Brown committed
332
333
334
335
336
337
338
339
340
                phi_val = self.__getattribute__("phi"+str(n))
                
                if phi_val != None:
                    fphi_str += " " + str(phi_val)
            
            senstype = self.senstype
            
            if senstype == None:
                senstype = ""
341
            
Sean Leavey's avatar
Sean Leavey committed
342
            rtn.append("pd{0}{1} {2}{3} {4}{5}".format(senstype, self.num_demods, self.name, fphi_str, self.node.name, alt_str))
343
344
345
346
347
348

            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))
349
                
350
351
            for p in self._params:
                rtn.extend(p.getFinesseText())
Daniel Brown's avatar
Daniel Brown committed
352
353
            
        return rtn
354
  
Daniel Brown's avatar
Daniel Brown committed
355
class qnoised(pd):
356
357
    
    def __init__(self, name, num_demods, node_name, alternate_beam=False, pdtype=None, **kwargs):
Daniel Brown's avatar
Daniel Brown committed
358
        super(qnoised, self).__init__(name, num_demods, node_name, alternate_beam=alternate_beam, pdtype=pdtype, **kwargs)
359
360
361
362
363
364
365
366
367
    
        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
368
369
    def pdtype(self, value):
        raise pkex.BasePyKatException("Setting pdtype is not possible with qnoised detectors")
370
    
Daniel Brown's avatar
Daniel Brown committed
371
372
373
374
375
376
377
    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))
378
379
380
381
    
    @staticmethod
    def parseFinesseText(text): 
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
382

383
        if len(values) <= 3:
Daniel Brown's avatar
Daniel Brown committed
384
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (2)".format(text))
Daniel Brown's avatar
Daniel Brown committed
385
            
Daniel Brown's avatar
Daniel Brown committed
386
        demods = int(values[2])
387
        
388
        if len(values) <= 4 and demods > 0:
Daniel Brown's avatar
Daniel Brown committed
389
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (2)".format(text))
390
        elif len(values) > 4 and demods == 0:
Daniel Brown's avatar
Daniel Brown committed
391
            raise pkex.BasePyKatException("qnoised code format incorrect '{0}' (3)".format(text))
392
393
394
395
            
        num_f_phs = len(values) - 4
        expected_f_phs = demods * 2
        
Daniel Brown's avatar
Daniel Brown committed
396
397
        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))
398
399
400
401
402
        
        f = values[3:len(values)-1:2]    
        phs = values[4:len(values)-1:2]
        
        dict = {}
Daniel Brown's avatar
Daniel Brown committed
403
        
404
405
406
407
        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
408
            
409
410
411
412
413
414
        node = values[-1]
        alt_beam = node[-1] == '*'
        
        if alt_beam:
            node = node[0:-1]
        
415
416
417
418
419
420
421
422
        if values[0].endswith('S'):
            sens='S'
        elif values[0].endswith('N'):
            sens='N'
        else:
            sens=None
            
        return qnoised(values[1], demods, node, senstype=sens, alternate_beam=alt_beam, **dict)
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
    
    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 = ""
                
446
            rtn.append("qnoised{5} {0} {1} {2} {3}{4}".format(self.name, self.num_demods, fphi_str, self.node.name, alt_str, senstype))
Andreas Freise's avatar
Andreas Freise committed
447

448
449
450
451
452
453
454
            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
455

456
class qshot(pd):
Daniel Brown's avatar
Daniel Brown committed
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
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
    
    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]
504
505
506
507
508
509
510
            
        if values[0].endswith('S'):
            sens='S'
        elif values[0].endswith('N'):
            sens='N'
        else:
            sens=None
Daniel Brown's avatar
Daniel Brown committed
511
        
512
        return qshot(values[1], demods, node, senstype=sens, alternate_beam=alt_beam, **dict)
513
    
Daniel Brown's avatar
Daniel Brown committed
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
    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 = ""
                
536
            rtn.append("qshot{5} {0} {1} {2} {3}{4}".format(self.name, self.num_demods, fphi_str, self.node.name, alt_str,senstype))
Daniel Brown's avatar
Daniel Brown committed
537
538
539
540
541
542
543
544
545

            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
        
546
def xd(Detector):
Daniel Brown's avatar
Daniel Brown committed
547

548
549
    def __init__(self, name, node_name, component, motion):
        Detector.__init__(name, None)
Daniel Brown's avatar
Daniel Brown committed
550
        
551
552
        self.__motion = motion
        self.__component = component
Daniel Brown's avatar
Daniel Brown committed
553
        
554
555
556
557
558
559
    @property
    def motion(self): return self.__motion
    
    @property
    def component(self): return self.__component
    
Daniel Brown's avatar
Daniel Brown committed
560
561
    @staticmethod
    def parseFinesseText(text): 
Daniel Brown's avatar
Daniel Brown committed
562
        values = text.split()
Daniel Brown's avatar
Daniel Brown committed
563

564
565
566
567
568
        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
569
    def getFinesseText(self) :
570
571
        rtn = []
        
Daniel Brown's avatar
Daniel Brown committed
572
        if self.enabled:
573
            rtn.append("xd {0} {1} {2}".format(self.name, self.component, self.motion))
574

575
            if self.scale != None:
576
                rtn.append("scale {1} {0}".format(self.name, self.scale))
577
578
579
                
            for p in self._params:
                rtn.extend(p.getFinesseText())
Daniel Brown's avatar
Daniel Brown committed
580
            
581
        return rtn
Daniel Brown's avatar
Daniel Brown committed
582
    
583