teamwork.dynamics.pwlDynamics

17 """Class of objects that represent the dynamics of a specific 18 state/belief feature in the simulation 19 @ivar effects: table of roles affected, containing keys 'actor','object','other'. If the value is C{True}, then the dynamics object affects that role 20 @type effects: strS{->}bool 21 """ 22

23 - def __init__(self,args=None):

24 arbitraryDynamics.BaseDynamics.__init__(self,args) 25 self.effects = {}

26

27 - def extractTable(self,entity,action):

28 """Helper function that extracts the context used in instantiating dynamics 29 @rtype: dict 30 """ 31 table = dict(action) 32 table['self'] = entity 33 for relationship,entities in entity.relationships.items(): 34 if len(entities) == 1: 35 table[relationship] = entities[0] 36 return table

37

38 - def instantiate(self,entity,action):

39 """Returns a new L{PWLDynamics} instance that has been specialized to apply to only the specified entity in response to the specified instantiated action. This produces a more compact decision tree where branches irrelevant to the given entity and action have been pruned away. 40 @type action: dict 41 @rtype: L{PWLDynamics} 42 """ 43 table = self.extractTable(entity,action) 44 args = copy.copy(self.args) 45 args['tree'] = self.getTree().instantiate(table) 46 args['tree'].prune() 47 return self.__class__(args)

48

49 - def instantiateAndApply(self,state,entity=None,action=None, 50 table={},tree=None):

51 """Performs both L{instantiate} and L{apply} in a single call, but does a minimal instantiation, by ignoring branches that are irrelevant in the given state 52 @param entity: the entity performing the update 53 @type entity: L{Agent<teamwork.agent.Agent.Agent>} 54 @param action: the action being applied 55 @type action: L{Action<teamwork.action.PsychActions.Action>} 56 @param state: the current state of the world 57 @type state: L{Distribution}(L{KeyedVector}) 58 @rtype: L{Distribution}(L{KeyedMatrix}) 59 """ 60 if not table: 61 table = self.extractTable(entity,action) 62 if tree is None: 63 tree = self.getTree() 64 if tree.isLeaf(): 65 return tree.getValue().instantiate(table) 66 else: 67 falseTree,trueTree = tree.getValue() 68 value = True 69 for plane in tree.split: 70 result = plane.instantiate(table) 71 if isinstance(result,plane.__class__): 72 value = result.test(state) 73 elif result < 0: 74 value = False 75 if not value: 76 break 77 if value: 78 return self.instantiateAndApply(state,table=table, 79 tree=trueTree) 80 else: 81 return self.instantiateAndApply(state,table=table, 82 tree=falseTree)

83

84 - def getTree(self):

85 """ 86 @return: the decision tree for this dynamics object 87 @rtype: L{ProbabilityTree}""" 88 return self.args['tree']

89

90 - def apply(self,state,debug=0):

91 """Applies this dynamics function to the given state 92 @rtype: L{Distribution}(L{KeyedMatrix}) 93 """ 94 tree = self.getTree() 95 dynamics = tree[state] 96 return dynamics

97

98 - def merge(self,other):

99 """Merges the new dynamics into this one by calling L{KeyedMatrix.merge} on the leaves of the decision trees 100 @type other: L{PWLDynamics} 101 """ 102 myTree = self.getTree() 103 yrTree = other.getTree() 104 newTree = myTree.merge(yrTree,KeyedMatrix.merge) 105 return self.__class__({'tree':newTree})

106

107 - def renameEntity(self,old,new,tree=None):

108 """ 109 @param old: the current name of the entity 110 @param new: the new name of the entity 111 @type old,new: str 112 """ 113 if tree is None: 114 tree = self.getTree() 115 if not tree.isLeaf(): 116 for index in range(len(tree.split)): 117 # Update any refs to the old name in branches 118 plane = tree.split[index] 119 newKeys = [] 120 for key in plane.weights.specialKeys: 121 newKey = {} 122 newKey.update(key) 123 if isinstance(key,StateKey) and key['entity'] == old: 124 newKey['entity'] = new 125 elif isinstance(key,ClassKey) and key['value'] == old: 126 newKey['value'] = new 127 newKeys.append(newKey) 128 newPlane = plane.weights.__class__(keys=newKeys) 129 tree.split[index] = KeyedPlane(newPlane,plane.threshold) 130 # Recurse 131 for child in tree.children(): 132 self.renameEntity(old,new,child)

133

134 - def __add__(self,other):

135 myTree = self.getTree() 136 yrTree = other.getTree() 137 newTree = myTree + yrTree 138 return self.__class__({'tree':newTree})

139

140 - def __sub__(self,other):

141 myTree = self.getTree() 142 yrTree = other.getTree() 143 newTree = myTree - yrTree 144 return self.__class__({'tree':newTree})

145

146 - def __xml__(self):

147 doc = Document() 148 root = doc.createElement('dynamic') 149 doc.appendChild(root) 150 tree = self.getTree() 151 root.appendChild(tree.__xml__().documentElement) 152 return doc

153

154 - def parse(self,element):

155 self.args['tree'] = ProbabilityTree() 156 child = element.firstChild 157 while child and child.nodeType != child.ELEMENT_NODE: 158 child = child.nextSibling 159 if child: 160 self.args['tree'].parse(child) 161 else: 162 print element.toxml() 163 raise UserWarning,'Dynamics element missing tree!'

164

165 - def __str__(self):

166 return self.getTree().simpleText()

Source Code for Module teamwork.dynamics.pwlDynamics