node_network.py 23.6 KB
Newer Older
Daniel Brown's avatar
Daniel Brown committed
1
2
3
4
5
6
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 27 10:02:41 2013

@author: Daniel
"""
7
8
9
10
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
11

12
import pykat
Daniel Brown's avatar
Daniel Brown committed
13
14
15
16
17
from pykat import USE_GUI, NoGUIException

if USE_GUI:
    import pykat.gui.graphics
    
Daniel Brown's avatar
Daniel Brown committed
18
import pykat.exceptions as pkex
19
import pykat.external.six as six
Daniel Brown's avatar
Daniel Brown committed
20

21
from pykat.components import Component, NodeGaussSetter
22
from pykat.detectors import BaseDetector as Detector
23
from pykat.optics.gaussian_beams import BeamParam
24
from copy import deepcopy
Daniel Brown's avatar
Daniel Brown committed
25

26
27
id___ = 0
    
Daniel Brown's avatar
Daniel Brown committed
28
class NodeNetwork(object):
29
    
30
    def __new__(cls, *args, **kwargs):
31
32
33
34
35
36
37
38
39
        # This creates an instance specific class for the component
        # this enables us to add properties to instances rather than
        # all classes
        global id___
        id___ += 1
        cnew_name = str("%s.%s_%i" % (cls.__module__, cls.__name__, id___))
        
        cnew = type(cnew_name, (cls,), {})
        
40
41
        #return object.__new__(cnew, *args, **kwargs)
        return object.__new__(cnew)
42

Daniel Brown's avatar
Daniel Brown committed
43
44
45
46
47
48
49
    def __init__(self, kat):
        self.__nodes = {}
        self.__kat = kat
        self.__nodeComponents = {} # dictionary of tuples containing which components are connected to a node
        self.__componentNodes = {} # dictionary of tuples containing which nodes are connected to a given component
        self.__componentCallback = {}
        self.__node_id = 1
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    
    def __deepcopy__(self, memo):
        """
        When deep copying a kat object we need to take into account
        the instance specific properties.
        """
        
        # Here we create a copy of this object based of the base class
        # of this one, otherwise we're making a copy of a copy of a copy...
        result = self.__class__.__new__(self.__class__.__base__)
        result.__dict__ = deepcopy(self.__dict__, memo)
        
        return result
                
64
65
    @property
    def kat(self): return self.__kat
Daniel Brown's avatar
Daniel Brown committed
66
67
68
69
70
71
72
73
74
        
    def registerComponentNodes(self, comp, node_names, change_callback):
        """
        For a given component we create some nodes or get existing ones and 
        attach them to this component. Also specify a callback function that
        is called whenever the nodes attached to this component are changed
        , e.g. connected, disconnected, name change, etc.
        """
        if not isinstance(comp, Component):
75
            raise pkex.BasePyKatException("comp argument is not of type Component")
Daniel Brown's avatar
Daniel Brown committed
76
77
78
79
80
81
82
83
        
        if comp.id in self.__componentNodes:
            raise pkex.BasePyKatException("Component has already been registered")
        
        list = []
        
        for name in node_names:
            n = self.createNode(name)
84
            self.__connectNodeToComp(n, comp, do_callback=False)
Daniel Brown's avatar
Daniel Brown committed
85
86
87
88
89
90
91
92
            list.append(n)
        
        self.__componentNodes[comp.id] = tuple(list)
        self.__componentCallback[comp.id] = change_callback
        
        change_callback()
    
    def replaceNode(self, comp, node_old, node_new):
93
94
95
96
97
98
99
100
        """
        For a particular pykat component this will replace a node that is currently
        connected to it with another. This can be used to dynamically change layouts
        once components have been read into the pykat.finesse.kat object.
        
        node_old is the node that is attached to the component. This will accept
             str - name of a node
             pykat.node_network.Node - The direct node object
101
             NodeGaussSetter - the node object that is used to set gaussian parameters
102
103
104
105
             
        This will call a components __on_node_change callback function to let it know that the nodes
        connected to it have changed.
        """
Daniel Brown's avatar
Daniel Brown committed
106
        
107
        if isinstance(node_old, six.string_types):
108
109
            node_old = self.__kat.nodes[node_old]
        
110
        if isinstance(node_new, six.string_types):
111
112
            node_new = self.__kat.nodes[node_new]
            
113
        if isinstance(node_old, NodeGaussSetter):
114
115
            node_old = node_old.node
        
116
        if isinstance(node_new, NodeGaussSetter):
117
118
119
            node_new = node_new.node
            
        if not node_new.isDump and node_new.components.count(None) == 0:
Daniel Brown's avatar
Daniel Brown committed
120
121
122
123
124
            raise pkex.BasePyKatException("New node already connected to two components")
            
        if comp not in node_old.components:
            raise pkex.BasePyKatException("Old node not attached to component")
        
125
        if not node_new.isDump and comp in node_new.components:
Daniel Brown's avatar
Daniel Brown committed
126
127
128
129
130
131
            raise pkex.BasePyKatException("New node already attached to component")
        
        # add component to new node component list
        new_node_comps = list(node_new.components)
        new_node_comps[new_node_comps.index(None)] = comp
        self.__nodeComponents[node_new.id] = tuple(new_node_comps)
132
        del new_node_comps
Daniel Brown's avatar
Daniel Brown committed
133
134
135
136
137
        
        # remove component from old node list
        old_node_comps = list(node_old.components)
        old_node_comps[old_node_comps.index(comp)] = None
        self.__nodeComponents[node_old.id] = tuple(old_node_comps)
138
        del old_node_comps
Daniel Brown's avatar
Daniel Brown committed
139
140
141
142
        
        comp_nodes = list(comp.nodes)
        comp_nodes[comp_nodes.index(node_old)] = node_new
        self.__componentNodes[comp.id] = tuple(comp_nodes)
143
        del comp_nodes
Daniel Brown's avatar
Daniel Brown committed
144
145
146
147
        
        # if old node is no longer connected to anything then delete it
        if node_old.components.count(None) == 2:
            self.removeNode(node_old)
148
149
150
        
        # Call component callback to let it know that we have changed the 
        # nodes attached to it
Daniel Brown's avatar
Daniel Brown committed
151
152
        self.__componentCallback[comp.id]()
            
153
154
155
156
    def __connectNodeToComp(self, node, comp, do_callback=True):
        """
        This is an internal function used to create connections between nodes
        """
Daniel Brown's avatar
Daniel Brown committed
157
158
159
160
161
162
        if node.id in self.__nodeComponents:
            comps = self.__nodeComponents[node.id]
        else:
            comps = (None,) * 2
        
        if len(comps) >= 2 and comps[0] != None and comps[1] != None:
163
            raise pkex.BasePyKatException("Node '{0}' is already connected to 2 components ({1}, {2})".format(node.name, comps[0], comps[1]))
Daniel Brown's avatar
Daniel Brown committed
164
165
166
        
        l = list(comps)
        
167
        if l[0] is None:
Daniel Brown's avatar
Daniel Brown committed
168
            l[0] = comp
169
        elif l[1] is None:
Daniel Brown's avatar
Daniel Brown committed
170
171
172
173
174
175
176
            l[1] = comp
        else:
            raise pkex.BasePyKatException("Connected to two coponents already")
        
        self.__nodeComponents[node.id] = tuple(l)
        
        if do_callback: self.__componentCallback[comp.id]()
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
    
    def __update_nodes_properties(self):
        # check if any node setters have already been added. If so we
        # need to remove them. This function should get called if the nodes
        # are updated, either by some function call or the GUI
        key_rm = [k for k in self.__dict__ if k.startswith("__node_", 0, 7)]

        # now we have a list of which to remove
        for key in key_rm:
            ns = self.__dict__[key]
            name = str(ns.name)
            
            if '__node_' + name in self.__dict__:
                delattr(self, '__node_' + name)
            
            if name in self.__class__.__dict__:
                delattr(self.__class__, name)
        
        # Now re-add them pointing to the recent nodes
        for node in self.__nodes:
            if not self.__nodes[node].isDump:
                self.__add_node_attr(self.__nodes[node])
         
Daniel Brown's avatar
Daniel Brown committed
200
    def createNode(self, node_name):
201
202
203
204
205
206
207
208
209
        """
        This creates a new node object. It won't be connected to anything or added to a
        pykat.finesse.kat object until it is specifically attached to a particular 
        component. This should be used in conjunction with kat.nodes.replaceNode to 
        add a new node into a system, as every component will already have the nodes
        setup, including dump nodes.
        
        This will return a dump node if the name of the node is "dump" (case senstive)
        """
Daniel Brown's avatar
Daniel Brown committed
210
            
211
        if node_name != 'dump' and node_name in self.__nodes:
Daniel Brown's avatar
Daniel Brown committed
212
213
214
            # then this node already exists
            return self.__nodes[node_name]
        else:
215
216
217
218
            if node_name == 'dump':
                n = DumpNode(self)
            else:
                n = Node(node_name, self, self.__node_id)
Daniel Brown's avatar
Daniel Brown committed
219
220
221
            
            self.__node_id += 1
            self.__nodeComponents[n.id] = (None, None)
222
223
224
225
226
227
            
            if not n.isDump:
                self.__add_node_attr(n) # add node as a member of this object, e.g. kat.nodes.n
                self.__nodes[node_name] = n
                
            
Daniel Brown's avatar
Daniel Brown committed
228
            return n
229
    
230
231
232
233
234
235
    def _removeComponent(self, comp):
        """
        This is an internal function that shouldn't be used directly. This removes
        a particular component from the node network. For this to work it has to be 
        detached from all other connections first.
        """
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
        C = self.__componentNodes[comp.id]
        
        for n in C:
           if comp in self.__nodeComponents[n.id]:
               l = list(self.__nodeComponents[n.id])
               l[l.index(comp)] = None
               self.__nodeComponents[n.id] = tuple(l)
               
               if l.count(None) == 2:
                   self.removeNode(n) 
               
               del l
               
        del self.__componentCallback[comp.id]
        del self.__componentNodes[comp.id]
Daniel Brown's avatar
Daniel Brown committed
251
252
        
    def removeNode(self, node):
253
254
255
256
257
258
259
260
261
        """
        This will remove a particular node object from the network. The node in question
        must be fully detached from all components and connections first. This function is 
        called by replaceNode directly so a replaced node, that is no longer connected to 
        anything, is removed automatically.
        
        node_old is the node that is attached to the component. This will accept
             str - name of a node
             pykat.node_network.Node - The direct node object
262
             NodeGaussSetter - the node object that is used to set gaussian parameters
263
264
              
        """
265
        
266
        if isinstance(node, six.string_types):
267
268
            node = self.__kat.nodes[node]
            
269
        if isinstance(node, NodeGaussSetter):
270
271
            node = node.node
            
272
273
        if not isinstance(node, Node):
            raise pkex.BasePyKatException("node argument is not of type Node")
Daniel Brown's avatar
Daniel Brown committed
274
        
275
276
        if not isinstance(node, DumpNode) and node.name not in self.__nodes:
            raise pkex.BasePyKatException("Trying to remove node {0} when it has not been added".format(node.name))
Daniel Brown's avatar
Daniel Brown committed
277
278
279
280
        
        C = self.getNodeComponents(node)
        
        if C[0] is not None or C[1] is not None:
281
            raise pkex.BasePyKatException("Cannot remove a node which is attached to components still")
Daniel Brown's avatar
Daniel Brown committed
282
283
            
        if len(node.getDetectors()) > 0:
284
            raise pkex.BasePyKatException("Cannot remove a node which is attached to detectors still")
Daniel Brown's avatar
Daniel Brown committed
285
        
286
287
288
        if not isinstance(node, DumpNode):
            self.__remove_node_attr(node)
            del self.__nodes[node.name] 
289
290
            
        del self.__nodeComponents[node.id]
Daniel Brown's avatar
Daniel Brown committed
291
292
        
    def hasNode(self, name):
293
        ""
Daniel Brown's avatar
Daniel Brown committed
294
295
296
        return (name in self.__nodes)
    
    def getNodes(self):
297
298
299
300
        """
        Returns a copy of the node dictionary, this is for infomration purposes any edits won't make
        any changes to the node network.
        """
Daniel Brown's avatar
Daniel Brown committed
301
302
303
        return self.__nodes.copy()
    
    def getComponentNodes(self, comp):
304
305
306
307
        """
        This function returns a tuple of the nodes connected to the component specified.
        For information only, you cannot edit the connections using this function.
        """
Daniel Brown's avatar
Daniel Brown committed
308
309
310
        return self.__componentNodes[comp.id]
    
    def getNodeComponents(self, node):
311
312
313
314
        """
        This function returns a tuple of the components connected to the node specified.
        For information only, you cannot edit the connections using this function.
        """
Daniel Brown's avatar
Daniel Brown committed
315
316
317
318
319
        return self.__nodeComponents[node.id]
    
    def __add_node_attr(self, node):

        if not isinstance(node, Node):
320
            raise pkex.BasePyKatException("Argument is not of type Node")
Daniel Brown's avatar
Daniel Brown committed
321
322
323
324
325
326
327
328
329
        
        name = node.name
        fget = lambda self: self.__get_node_attr(name)
        
        setattr(self.__class__, name, property(fget))
        setattr(self, '__node_' + name, node)                   
    
    def __remove_node_attr(self, node):
        if not isinstance(node, Node):
330
            kat.nodes.replaceNode(kat.bs1, "n1", kat.nodes.createNode("test1"))
Daniel Brown's avatar
Daniel Brown committed
331
332
        
        name = node.name
333
        
Daniel Brown's avatar
Daniel Brown committed
334
335
336
337
338
339
340
        delattr(self, '__node_' + name)
        delattr(self.__class__, name)
        
    def __get_node_attr(self, name):
        return getattr(self, '__node_' + name)        
        
    def __getitem__(self, value):
341
342
343
344
        if str(value) in self.__nodes:
            return self.__nodes[str(value)]
        else:
            raise pkex.BasePyKatException("The node '%s' could not be found in the network." % str(value))
Daniel Brown's avatar
Daniel Brown committed
345
346
347
        
    def __contains__(self, value):
        return value in self.__nodes
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
    
    def __nodeSearch(self, fnode, currcomp, branches, tnode):
        
        if fnode == tnode:
            branches[-1][0] = True
            branches[-1][1] = True
            return True # Hurrah, we have found a path to the node
        elif fnode.isDump:
            branches[-1][0] = True
            return False # if the current node is a dump, we need to check another branch

        nextnode = None
        
        if isinstance(currcomp, pykat.components.beamSplitter):
            # if we get to a beamsplitter then we need to 
            # create new branches to search: the rfelected
            # and transmitted
            
            # set this branch as searched
            branches[-1][0] = True
            # add two new ones
            
            if fnode == currcomp.nodes[0]:
                rn = currcomp.nodes[1]
                tn = currcomp.nodes[2]
            elif fnode == currcomp.nodes[1]:
                rn = currcomp.nodes[0]
                tn = currcomp.nodes[3]
            elif fnode == currcomp.nodes[2]:
                rn = currcomp.nodes[3]
                tn = currcomp.nodes[0]
            elif fnode == currcomp.nodes[3]:
                rn = currcomp.nodes[2]
                tn = currcomp.nodes[1]
            else:
383
                raise pkex.BasePyKatException("Node not attached in path find to BS")
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
            
            nextcomp = None
            
            if tn.components[0] == currcomp:
                nextcomp = tn.components[1]
            elif tn.components[1] == currcomp:
                nextcomp = tn.components[0]
            
            if nextcomp != None:
                branches.append([False, False, tn, nextcomp, []])
            
            if rn.components[0] == currcomp:
                nextcomp = rn.components[1]
            elif rn.components[1] == currcomp:
                nextcomp = rn.components[0]
            
            if nextcomp != None:
                branches.append([False, False, rn, nextcomp, []])
            
            branches[-1][-1].append(currcomp)
            
            return False
            
        elif isinstance(currcomp, pykat.components.isolator):
408
            print ("isol")
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
        elif isinstance(currcomp, pykat.components.laser):
            # if we are at a laser then we can't go any further
            # and it isn;t this node as we checked before
            branches[-1][0] = True
            return False
        elif len(currcomp.nodes) == 2:
            if currcomp.nodes[0] == fnode:
                nextnode = currcomp.nodes[1]
            elif currcomp.nodes[1] == fnode:
                nextnode = currcomp.nodes[0]
            else:
                raise pkex.BasePyKatException("Unexpeceted condition")
        else:
            raise pkex.BasePyKatException("Did not handle component {0} correctly, has more or less than 2 nodes.".format(currcomp))
        
424
        if nextnode is None:
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
            branches[-1][0] = True
            return False
        elif nextnode == tnode:
            branches[-1][0] = True
            branches[-1][1] = True
            branches[-1][-1].append(currcomp)
            return True
        else:
            # Now we have the next node, we need the next component
            if nextnode.components[0] == currcomp:
                nextcomp = nextnode.components[1]
            elif nextnode.components[1] == currcomp:
                nextcomp = nextnode.components[0]
            else:
                raise pkex.BasePyKatException("Unexpeceted condition")

441
            if nextcomp is None:
442
443
444
445
446
447
448
449
                branches[-1][0] = True
                return False
            
            branches[-1][-1].append(currcomp)
            
            return self.__nodeSearch(nextnode, nextcomp, branches, tnode)
            
    def getComponentsBetween(self, from_node, to_node):
450
451
452
453
454
        """
        This function will trace the path between the two nodes specified and return a list
        of the components it finds between them.
        """
        
455
        if isinstance(from_node, six.string_types):
456
457
            from_node = self.__kat.nodes[from_node]
            
458
        if isinstance(from_node, NodeGaussSetter):
459
460
            from_node = from_node.node
            
461
        if isinstance(to_node, six.string_types):
462
463
            to_node = self.__kat.nodes[to_node]
            
464
        if isinstance(to_node, NodeGaussSetter):
465
466
467
468
            to_node = to_node.node
            
        if to_node == from_node:
            return []
469
470
    
        if from_node.name not in self.__nodes:
471
472
            raise pkex.BasePyKatException("Node {0} cannot be found in this kat object".format(from_node))

473
        if to_node.name not in self.__nodes:
474
475
476
477
            raise pkex.BasePyKatException("Node {0} cannot be found in this kat object".format(to_node))
        
        branches = []
        
478
479
        fn = self.__nodes[from_node.name]
        tn = self.__nodes[to_node.name]
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
        
        branches.append([False, False, fn, fn.components[1], []])
        branches.append([False, False, fn, fn.components[0], []])
        
        while len(branches) > 0 and branches[-1][1] != True:
            while branches[-1][0] == False:
                branch = branches[-1]
            
                if not self.__nodeSearch(branch[2], branch[3], branches, tn):
                    if len(branches) > 0 and branches[-1][0] != False:
                        branches.pop()
            
            if branches[-1][1] != True:
                while len(branches) > 0 and branches[-1][0] == True:
                    branches.pop()
            
            
        comps = []
        
        if len(branches) > 0  and branches[-1][0] == True and branches[-1][1] == True:
            # select the branches that form the path from node to node
            br = [b for b in branches if b[0] == True]
Daniel Brown's avatar
Daniel Brown committed
502
        
503
504
505
506
507
            for b in br:
                comps.extend(b[-1])
        
        return comps
    
Daniel Brown's avatar
Daniel Brown committed
508
509
510
511
512
513
514
515
516
517
518
519
    
class Node(object):

    def __init__(self, name, network, id):
        self._detectors = []
        self.__name = name
        self._item = None
        self._network = network
        self.__q_x = None
        self.__q_y = None
        self.__q_comp = None
        self.__id = id
520
521
        self._isDump = False
        
Daniel Brown's avatar
Daniel Brown committed
522
    def __str__(self): return self.__name
523
524
525
526

    @property
    def isDump(self): return self._isDump
        
Daniel Brown's avatar
Daniel Brown committed
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
    @property
    def id(self): return self.__id
    
    @property
    def network(self): return self._network
    
    @property
    def components(self): return self._network.getNodeComponents(self)
    
    @property
    def q(self):
        if self.__q_x == self.__q_y:
            return self.__q_x
        else:
            return (self.__q_x, self.__q_y)
            
    @property
    def qx(self): return self.__q_x
    @property
    def qy(self): return self.__q_y
    
548
    def removeGauss(self):
Daniel Brown's avatar
Daniel Brown committed
549
550
551
552
553
554
555
        self.__q_x = None
        self.__q_y = None
        self.__q_comp = None
    
    def setGauss(self, component, *args):
        self.__q_comp = component
        
556
        if len(args) == 1:  
557
558
            self.__q_x = BeamParam(self._network.kat.lambda0, q=args[0])
            self.__q_y = BeamParam(self._network.kat.lambda0, q=args[0])
Daniel Brown's avatar
Daniel Brown committed
559
        elif len(args) == 2:
560
561
            self.__q_x = BeamParam(self._network.kat.lambda0, q=args[0])
            self.__q_y = BeamParam(self._network.kat.lambda0, q=args[1])
Daniel Brown's avatar
Daniel Brown committed
562
563
        else:
            raise pkex.BasePyKatException("Must specify either 1 Gaussian beam parameter or 2 for astigmatic beams")
564
                
Daniel Brown's avatar
Daniel Brown committed
565
566
567
568
569
    def getFinesseText(self):    
        if self.__q_x is None or self.__q_y is None or self.__q_comp is None:
            return []
            
        rtn = []
Daniel Brown's avatar
Daniel Brown committed
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
        
        # to get the name of the gauss parameter is a bit convoluted...
        # firstly the name is set in the NodeGaussSetter object which is
        # connected to each component, so this has to be retrieved and 
        # then applied.
        if hasattr(self.__q_comp, self.name):
            ns = getattr(self.__q_comp, self.name)
            
            # if no name is present give it a default one
            if ns.name != None:
                name = ns.name
            else:
                name = "g_%s" % self.name
        else:
            raise pkex.BasePyKatException("Node {0} is not connected to {1}".format(self.name, self.__q_comp.name))
        
        
Daniel Brown's avatar
Daniel Brown committed
587
        if self.__q_x == self.__q_y:
Daniel Brown's avatar
Daniel Brown committed
588
            rtn.append("gauss {name} {comp} {node} {w0:.15g} {z:.15g}".format(name=name, node=self.name, comp=self.__q_comp.name, w0=self.__q_x.w0, z=self.__q_x.z))
Daniel Brown's avatar
Daniel Brown committed
589
        else:
Daniel Brown's avatar
Daniel Brown committed
590
            rtn.append("gauss {name} {comp} {node} {w0x:.15g} {zx:.15g} {w0y:.15g} {zy:.15g}".format(name=name, node=self.name, comp=self.__q_comp.name, w0x=self.__q_x.w0, zx=self.__q_x.z, w0y=self.__q_y.w0, zy=self.__q_y.z))
Daniel Brown's avatar
Daniel Brown committed
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
            
        return rtn
        
    def isConnected(self):
        if (self.components[0] is not None) and (self.components[1] is not None):
            return True
        else:
            return False
      
    def remove(self):
        self._network.removeNode(self)
        
        if self._item != None:
            self._item.scene().removeItem(self._item)
    
    def getQGraphicsItem(self,dx=0,dy=0,nsize=8,parent=None):
Daniel Brown's avatar
Daniel Brown committed
607
608
609
        if not USE_GUI:
            raise NoGUIException
            
610
        if self._item is None:
Daniel Brown's avatar
Daniel Brown committed
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
            self._item = pykat.gui.graphics.NodeQGraphicItem(self,
                                                             dx,dy,
                                                             -nsize/2,-nsize/2,
                                                             nsize, nsize, parent)
            
        return self._item
    
    def getDetectors(self):
        return self._detectors[:]
        
    def amIConnected(self, obj):
        """
        Checks if obj is connected to the node. Returns true or false in tuple
        with None or the other object and the node index which it is attached to
        """ 
        comps = self.components
        
        if obj == comps[0]:
629
            if comps[1] is None:
Daniel Brown's avatar
Daniel Brown committed
630
631
632
633
634
635
636
                ix = -1
            else:
                ix = comps[1].nodes.index(self)
                
            return [True, comps[1], ix]
            
        elif obj == comps[1]:
637
            if comps[0] is None:
Daniel Brown's avatar
Daniel Brown committed
638
639
640
641
642
643
644
645
646
647
                ix = -1
            else:
                ix = comps[0].nodes.index(self)
                
            return [True, comps[0], ix]
        else:
            return [False, None]
        
    @property
    def name(self): return self.__name      
648
649
        
        
Daniel Brown's avatar
Daniel Brown committed
650
class DumpNode(Node):
651
652
    __total_dump_node_id = 0
    
653
    def __init__(self, network):
654
        DumpNode.__total_dump_node_id -= 1
655
        Node.__init__(self, 'dump', network, DumpNode.__total_dump_node_id)
656
        self._isDump = True
Daniel Brown's avatar
Daniel Brown committed
657
        
658