class TX():
"""
TX process ( not used for now)
Each agent use the TX process for querying LDP/information/message passing data
to other agent
"""
def __init__(self,**args):
defaults={'sim':None,
'net': Network(),
#'gcom': Gcom(),
'gcom': [], # Temporary
'ID': 0,
'dec':{},
'devt': {},
'lcst': []
}
## initialize attributes
for key, value in defaults.items():
if key in args:
setattr(self, key, args[key])
else:
setattr(self, key, value)
args[key]=value
self.args = args
self.gcom = self.args['gcom']
if sys.version_info.major==2:
self.cmdrq =SimEvent('RQ'+str(self.ID),sim=self.sim) # command request
else:
pass
# Python3 implementation not done
try:
self.PN = self.net.node[self.ID]['PN']
except:
self.PN = Network()
# self.create_evt()
# self.c_init()
if sys.version_info.major==2:
Process.__init__(self,name='Tx'+str(self.ID),sim=self.sim)
else:
pass
#Process.__init__(self,env,generator)
# Python3 implementation not done
Cf = ConfigParser.ConfigParser(inline_comment_prefixes=(';',),comment_prefixes=('#',';'))
Cf.read(pyu.getlong('agent.ini','ini'))
for s in Cf.sections():
try:
d= dict(Cf.items(s))
if d['id']==self.ID:
self.refreshTOA=eval(d['refreshtoa'])
break
except:
pass
def run(self):
while True:
self.levt=[]
for d in self.dcond.keys():
if self.c_interpret(self.dcond[d]):
self.levt.append(self.dcste[c])
print('Tx ', self.ID,' @',self.sim.now())
yield hold, self, self.refresh
def create_evt(self):
"""
Create simpy events from communication gaph
The available reception event for the given id are pickup into the
communication graph to fill self.devt.
Examples
--------
>>> from pylayers.network.communication import *
>>> T = TX()
>>> T.create_evt()
"""
for e in self.PN.edges(self.ID,keys=True):
self.devt[e]=self.gcom.devt[e]
# def request_TOA(self):
# """
# Request TOA
# Every self.refreshTOA time interval, send a devent signal to nodes
# in visibility torefresh the TOA information
# """
# self.create_evt()
# while 1:
# if self.sim.verbose:
# print('request TOA', self.ID)
# for wstd in self.PN.SubNet.keys():
# for n in self.PN.SubNet[wstd].edge[self.ID].keys():
# # check nodes in visibility
# if self.net.edge[self.ID][n][wstd]['vis']:
# key='(\''+self.ID+'\', \''+n+'\', \''+wstd+'\')'
# self.devt[eval(key)].signal()
# yield hold, self, self.refreshTOA
## devt[]
## [self.PN.edge[self.ID][n][wstd].update(
## {'TOA':self.net.edge[self.ID][n][wstd]['TOA'],'tTOA':self.sim.now()})
## for n in self.PN.SubNet[wstd].edge[self.ID].keys() if self.net.edge[self.ID][n][wstd]['vis']]
## print('refresh TOA node', self.ID, ' @',self.sim.now())
def interpret_dec(self):
""" interpret decision rule from self.dec
"""
# n dict{wstd:np.array([node ids])}
n={}
# loop on wstd
for wstd in self.dec['wstd']:
try:
# get all nodes connecteed to self.ID on subnetwork wstd
n[wstd]=np.array(self.PN.SubNet[wstd].edges())[:,1]
# initialize remained nodes to True
rn = [True]*len(n[wstd])
# loop on condition
for r in self.dec['rule']:
if r == 'always':
pass
# mettre boolean dans variable pour condition a plus d41 regle
if 'rssth' in r:
# rssth<100
rntmp = np.array(nx.get_edge_attributes(self.PN.SubNet[wstd],'Pr').values())
if len(r.split('<')) > 1:
rn = rn and ( rntmp < eval(r.split('<')[1]) )
elif len(r.split('>')) > 1:
rn = rn and ( rntmp > eval(r.split('>')[1]) )
# elif 'distance' in r :
# # distance < 10
# rntmp = np.array(nx.get_edge_attributes(self.net.SubNet[wstd],'d').values())
# if len(r.split('<')) > 1:
# rn = rn and ( rntmp < eval(r.split('<')[1]) )
# elif len(r.split('>')) > 1:
# rn = rn and ( rntmp > eval(r.split('<')[1]) )
n[wstd][np.where(rn)]
except:
n[wstd]=np.array(())
# retrun only node id which are compliant with rules
return (n)
def request(self):
""" request a transmission initiated by localization
"""
self.dec = self.gcom.dec[self.ID]
self.create_evt()
while 1:
# wait request localization from localization layer
yield waitevent,self,self.cmdrq
if self.sim.verbose:
print("communication requested by node ",self.ID)
# n = nodes compliant with the rules given in communication.py
# and in self.gcom.dec[self.ID]
rn = self.interpret_dec()
# send a signal (a.k.a. request transmission) to nodes in n
for wstd in rn.keys():
for n in rn[wstd]:
# check if nodes in visibility
if self.net.edge[self.ID][n][wstd]['vis']:
key='(\''+self.ID+'\', \''+n+'\', \''+wstd+'\')'
# WARNING : PLEASE LEAVE THE 2 FOLLOWING LINES
# this is not a bad copy paste. It is required
# to force signalization ( probably a SimPy bug)
self.devt[eval(key)].signal()
self.devt[eval(key)].signal()
class TX(Process):
"""
TX process ( not used for now)
Each agent use the TX process for querying LDP/information/message passing data
to other agent
"""
def __init__(self, **args):
defaults = {
'sim': None,
'net': Network(),
'gcom': Gcom(),
'ID': 0,
'dcond': {},
'devt': {},
'lcst': []
}
## initialize attributes
for key, value in defaults.items():
if args.has_key(key):
setattr(self, key, args[key])
else:
setattr(self, key, value)
args[key] = value
self.args = args
try:
self.PN = self.net.node[self.ID]['PN']
except:
self.PN = Network()
self.create_evt()
# self.c_init()
Process.__init__(self, name='Tx' + str(self.ID), sim=self.sim)
Cf = ConfigParser.ConfigParser()
Cf.read(pyu.getlong('agent.ini', 'ini'))
for s in Cf.sections():
try:
d = dict(Cf.items(s))
if d['id'] == self.ID:
self.refreshTOA = eval(d['refreshtoa'])
break
except:
pass
def run(self):
while True:
self.levt = []
for d in self.dcond.keys():
if self.c_interpret(self.dcond[d]):
self.levt.append(self.dcste[c])
print 'Tx ', self.ID, ' @', self.sim.now()
yield hold, self, self.refresh
def create_evt(self):
"""
Create simpy events from communication gaph
The available reception event for the given id are pickup into the
communication graph to fill self.devt.
Examples
--------
>>> from pylayers.network.communication import *
>>> T = TX()
>>> T.create_evt()
"""
for e in self.PN.edges(self.ID, keys=True):
self.devt[e] = self.gcom.devt[e]
def request_TOA(self):
"""
Request TOA
Every self.refreshTOA time interval, send a devent signal to nodes
in visibility torefresh the TOA information
"""
self.create_evt()
while 1:
if self.sim.verbose:
print 'request TOA', self.ID
for rat in self.PN.SubNet.keys():
for n in self.PN.SubNet[rat].edge[self.ID].keys():
# check nodes in visibility
if self.net.edge[self.ID][n][rat]['vis']:
key = '(\'' + self.ID + '\', \'' + n + '\', \'' + rat + '\')'
self.devt[eval(key)].signal()
yield hold, self, self.refreshTOA
class RX(Process):
"""
RX process
Each agent has a RX process to receive information asynchronously.
Attributes
----------
sim : SimPy.SimulationRT()
ID : string
id of the agent
net : pylayers.network.network()
gcom : pylayers.network.communication()
a graph a communication
devt : dictionary
dictionnary of event
refreshRSS : float
time interval where RSS are refreshed
refreshTOA : float
time interval where TOA are refresh (if agent.comm_mode =='syncho')
mp : bool
message passing [Not yet implemented]
"""
def __init__(self, **args):
defaults = {
'sim': None,
'ID': '1',
'net': Network(),
'gcom': Gcom(),
'devt': {},
'refreshRSS': 0.3,
'refreshTOA': 0.3,
'mp': False
}
## initialize attributes
for key, value in defaults.items():
if args.has_key(key):
setattr(self, key, args[key])
else:
setattr(self, key, value)
args[key] = value
self.args = args
try:
self.PN = self.net.node[self.ID]['PN']
except:
self.PN = Network()
self.create_evt()
Process.__init__(self, name='Rx-' + str(self.ID), sim=self.sim)
Cf = ConfigParser.ConfigParser()
Cf.read(pyu.getlong('agent.ini', 'ini'))
for s in Cf.sections():
try:
d = dict(Cf.items(s))
if d['id'] == self.ID:
self.refreshRSS = eval(d['refreshrss'])
self.refreshTOA = eval(d['refreshtoa'])
break
except:
pass
def swap_lt(self, lt):
"""
For a list of tuple if the first element is self.ID,
it is swapped with the second element
Examples
--------
>>> from pylayers.network.communication import *
>>> R = RX()
>>> R.ID
'1'
>>> lt= [('1','0','tuple1'),('10','5','tuple2')]
>>> R.swap_lt(lt) # only first tuple is swapped because R.ID='1'
[('0', '1', 'tuple1'), ('10', '5', 'tuple2')]
"""
lto = []
for t in lt:
if t[0] == self.ID:
lto.append((t[1], t[0], t[2]))
else:
lto.append((t[0], t[1], t[2]))
return lto
def create_evt(self):
"""
Create simpy events from communication gaph
The available reception event for the given id are pickup into the
communication graph to fill self.devt.
Examples
--------
>>> from pylayers.network.communication import *
>>> R = RX()
>>> R.create_evt()
"""
rPNe = self.swap_lt(self.PN.edges(keys=True))
for e in rPNe:
self.devt[e] = self.gcom.devt[e]
if self.mp:
for e in rPNe:
self.devt[e] = self.gcom.devt[e + str(mp)]
def refresh_RSS(self):
"""
Refresh RSS process
The RSS values on the edges of the Personnal Network of node self.ID
are refreshed every self.refreshRSS
"""
self.create_evt()
while 1:
for rat in self.PN.SubNet.keys():
# 2 approach to determine visibility
## 1) test visibility during the refresh
# [self.PN.edge[self.ID][n][rat].update(
# {'Pr':self.net.edge[self.ID][n][rat]['Pr'],
# 'tPr':self.sim.now(),
# 'vis':self.net.edge[self.ID][n][rat]['Pr'][0]>self.net.node[self.ID]['sens'][rat]})
# for n in self.PN.SubNet[rat].edge[self.ID].keys()]
# 2) copy the visibility information from network layer
[
self.PN.edge[self.ID][n][rat].update({
'Pr':
self.net.edge[self.ID][n][rat]['Pr'],
'tPr':
self.sim.now(),
'vis':
self.net.edge[self.ID][n][rat]['vis']
}) for n in self.PN.SubNet[rat].edge[self.ID].keys()
]
if self.sim.verbose:
print 'refresh RSS node', self.ID, ' @', self.sim.now()
yield hold, self, self.refreshRSS
def refresh_TOA(self):
"""
Refresh TOA process
The TOA values on the edges of the Personnal Network of node self.ID
are refreshed every self.refreshTOA
"""
self.create_evt()
while 1:
for rat in self.PN.SubNet.keys():
# 2 approaches :
## 1) that commented code allow refresh TOA only when visibility
# [self.PN.edge[self.ID][n][rat].update(
# {'TOA':self.net.edge[self.ID][n][rat]['TOA'],'tTOA':self.sim.now()})
# for n in self.PN.SubNet[rat].edge[self.ID].keys() if self.net.edge[self.ID][n][rat]['vis']]
# 2 refresj TOa whatever visibility or not
[
self.PN.edge[self.ID][n][rat].update({
'TOA':
self.net.edge[self.ID][n][rat]['TOA'],
'tTOA':
self.sim.now()
}) for n in self.PN.SubNet[rat].edge[self.ID].keys()
]
if self.sim.verbose:
print 'refresh TOA node', self.ID, ' @', self.sim.now()
yield hold, self, self.refreshTOA
def wait_TOArq(self):
"""
Wait TOA request
The self.ID node wait a TOA request from another node of its Personal network.
Once the request is received, self.ID reply to the requester node
and fill the PN edge with the measured TOA.
"""
self.create_evt()
while 1:
yield waitevent, self, self.devt.values()
for evt in self.devt.values():
if evt.occurred:
# evt.name[0] = requester
# evt.name[1] = requested ( = self.ID)
# evt.name[2] = rat
# update personal network TOA value
self.PN.edge[evt.name[1]][evt.name[0]][evt.name[2]].update(
{
'TOA':
self.net.edge[evt.name[1]][evt.name[0]][
evt.name[2]]['TOA'],
'tTOA':
self.sim.now()
})
if self.sim.verbose:
print 'TOA requested by', evt.name[0], 'to', evt.name[
1], 'has been updated'
break
class TX(Process):
"""
TX process ( not used for now)
Each agent use the TX process for querying LDP/information/message passing data
to other agent
"""
def __init__(self,**args):
defaults={'sim':None,
'net': Network(),
'gcom': Gcom(),
'ID': 0,
'dec':{},
'devt': {},
'lcst': []
}
## initialize attributes
for key, value in defaults.items():
if args.has_key(key):
setattr(self, key, args[key])
else:
setattr(self, key, value)
args[key]=value
self.args=args
self.gcom=self.args['gcom']
self.cmdrq=SimEvent('RQ'+str(self.ID),sim=self.sim) # command request
try:
self.PN=self.net.node[self.ID]['PN']
except:
self.PN=Network()
# self.create_evt()
# self.c_init()
Process.__init__(self,name='Tx'+str(self.ID),sim=self.sim)
Cf = ConfigParser.ConfigParser()
Cf.read(pyu.getlong('agent.ini','ini'))
for s in Cf.sections():
try:
d= dict(Cf.items(s))
if d['id']==self.ID:
self.refreshTOA=eval(d['refreshtoa'])
break
except:
pass
def run(self):
while True:
self.levt=[]
for d in self.dcond.keys():
if self.c_interpret(self.dcond[d]):
self.levt.append(self.dcste[c])
print 'Tx ', self.ID,' @',self.sim.now()
yield hold, self, self.refresh
def create_evt(self):
"""
Create simpy events from communication gaph
The available reception event for the given id are pickup into the
communication graph to fill self.devt.
Examples
--------
>>> from pylayers.network.communication import *
>>> T = TX()
>>> T.create_evt()
"""
for e in self.PN.edges(self.ID,keys=True):
self.devt[e]=self.gcom.devt[e]
# def request_TOA(self):
# """
# Request TOA
# Every self.refreshTOA time interval, send a devent signal to nodes
# in visibility torefresh the TOA information
# """
# self.create_evt()
# while 1:
# if self.sim.verbose:
# print 'request TOA', self.ID
# for wstd in self.PN.SubNet.keys():
# for n in self.PN.SubNet[wstd].edge[self.ID].keys():
# # check nodes in visibility
# if self.net.edge[self.ID][n][wstd]['vis']:
# key='(\''+self.ID+'\', \''+n+'\', \''+wstd+'\')'
# self.devt[eval(key)].signal()
# yield hold, self, self.refreshTOA
## devt[]
## [self.PN.edge[self.ID][n][wstd].update(
## {'TOA':self.net.edge[self.ID][n][wstd]['TOA'],'tTOA':self.sim.now()})
## for n in self.PN.SubNet[wstd].edge[self.ID].keys() if self.net.edge[self.ID][n][wstd]['vis']]
## print 'refresh TOA node', self.ID, ' @',self.sim.now()
def interpret_dec(self):
""" interpret decision rule from self.dec
"""
# n dict{wstd:np.array([node ids])}
n={}
# loop on wstd
for wstd in self.dec['wstd']:
try:
# get all nodes connecteed to self.ID on subnetwork wstd
n[wstd]=np.array(self.PN.SubNet[wstd].edges())[:,1]
# initialize remained nodes to True
rn = [True]*len(n[wstd])
# loop on condition
for r in self.dec['rule']:
if r == 'always':
pass
# mettre boolean dans variable pour condition a plus d41 regle
if 'rssth' in r:
# rssth<100
rntmp = np.array(nx.get_edge_attributes(self.PN.SubNet[wstd],'Pr').values())
if len(r.split('<')) > 1:
rn = rn and ( rntmp < eval(r.split('<')[1]) )
elif len(r.split('>')) > 1:
rn = rn and ( rntmp > eval(r.split('>')[1]) )
# elif 'distance' in r :
# # distance < 10
# rntmp = np.array(nx.get_edge_attributes(self.net.SubNet[wstd],'d').values())
# if len(r.split('<')) > 1:
# rn = rn and ( rntmp < eval(r.split('<')[1]) )
# elif len(r.split('>')) > 1:
# rn = rn and ( rntmp > eval(r.split('<')[1]) )
n[wstd][np.where(rn)]
except:
n[wstd]=np.array(())
# retrun only node id which are compliant with rules
return (n)
def request(self):
""" request a transmission commanded by localizaiton
"""
self.dec = self.gcom.dec[self.ID]
self.create_evt()
while 1:
# wait request localization from localization layer
yield waitevent,self,self.cmdrq
if self.sim.verbose:
print "communication requested by node ",self.ID
# n = nodes compliant with the rules given in communication.py
# and in self.gcom.dec[self.ID]
rn = self.interpret_dec()
# send a signal (a.k.a. request transmission) to nodes in n
for wstd in rn.keys():
for n in rn[wstd]:
# check if nodes in visibility
if self.net.edge[self.ID][n][wstd]['vis']:
key='(\''+self.ID+'\', \''+n+'\', \''+wstd+'\')'
# WARNING : PLEASE LEAVE THE 2 FOLLOWING LINES
# this is not a bad copy paste. It is required
# to force signalization ( probably a SimPy bug)
self.devt[eval(key)].signal()
self.devt[eval(key)].signal()
class TX(Process):
"""
TX process ( not used for now)
Each agent use the TX process for querying LDP/information/message passing data
to other agent
"""
def __init__(self,**args):
defaults={'sim':None,
'net': Network(),
'gcom': Gcom(),
'ID': 0,
'dcond':{},
'devt': {},
'lcst': []
}
## initialize attributes
for key, value in defaults.items():
if args.has_key(key):
setattr(self, key, args[key])
else:
setattr(self, key, value)
args[key]=value
self.args=args
try:
self.PN=self.net.node[self.ID]['PN']
except:
self.PN=Network()
self.create_evt()
# self.c_init()
Process.__init__(self,name='Tx'+str(self.ID),sim=self.sim)
Cf = ConfigParser.ConfigParser()
Cf.read(pyu.getlong('agent.ini','ini'))
for s in Cf.sections():
try:
d= dict(Cf.items(s))
if d['id']==self.ID:
self.refreshTOA=eval(d['refreshtoa'])
break
except:
pass
def run(self):
while True:
self.levt=[]
for d in self.dcond.keys():
if self.c_interpret(self.dcond[d]):
self.levt.append(self.dcste[c])
print 'Tx ', self.ID,' @',self.sim.now()
yield hold, self, self.refresh
def create_evt(self):
"""
Create simpy events from communication gaph
The available reception event for the given id are pickup into the
communication graph to fill self.devt.
Examples
--------
>>> from pylayers.network.communication import *
>>> T = TX()
>>> T.create_evt()
"""
for e in self.PN.edges(self.ID,keys=True):
self.devt[e]=self.gcom.devt[e]
def request_TOA(self):
"""
Request TOA
Every self.refreshTOA time interval, send a devent signal to nodes
in visibility torefresh the TOA information
"""
self.create_evt()
while 1:
if self.sim.verbose:
print 'request TOA', self.ID
for rat in self.PN.SubNet.keys():
for n in self.PN.SubNet[rat].edge[self.ID].keys():
# check nodes in visibility
if self.net.edge[self.ID][n][rat]['vis']:
key='(\''+self.ID+'\', \''+n+'\', \''+rat+'\')'
self.devt[eval(key)].signal()
yield hold, self, self.refreshTOA
class RX(Process):
"""
RX process
Each agent has a RX process to receive information asynchronously.
Attributes
----------
sim : SimPy.SimulationRT()
ID : string
id of the agent
net : pylayers.network.network()
gcom : pylayers.network.communication()
a graph a communication
devt : dictionary
dictionnary of event
refreshRSS : float
time interval where RSS are refreshed
refreshTOA : float
time interval where TOA are refresh (if agent.comm_mode =='syncho')
mp : bool
message passing [Not yet implemented]
"""
def __init__(self,**args):
defaults={'sim':None,
'ID':'1',
'net':Network(),
'gcom': Gcom(),
'devt': {},
'refreshRSS':0.3,
'refreshTOA':0.3,
'mp':False
}
## initialize attributes
for key, value in defaults.items():
if args.has_key(key):
setattr(self, key, args[key])
else:
setattr(self, key, value)
args[key]=value
self.args=args
try:
self.PN = self.net.node[self.ID]['PN']
except:
self.PN = Network()
self.create_evt()
Process.__init__(self,name='Rx-'+str(self.ID),sim=self.sim)
Cf = ConfigParser.ConfigParser()
Cf.read(pyu.getlong('agent.ini','ini'))
for s in Cf.sections():
try:
d= dict(Cf.items(s))
if d['id']==self.ID:
self.refreshRSS=eval(d['refreshrss'])
self.refreshTOA=eval(d['refreshtoa'])
break
except:
pass
def swap_lt(self,lt):
"""
For a list of tuple if the first element is self.ID,
it is swapped with the second element
Examples
--------
>>> from pylayers.network.communication import *
>>> R = RX()
>>> R.ID
'1'
>>> lt= [('1','0','tuple1'),('10','5','tuple2')]
>>> R.swap_lt(lt) # only first tuple is swapped because R.ID='1'
[('0', '1', 'tuple1'), ('10', '5', 'tuple2')]
"""
lto=[]
for t in lt :
if t[0] == self.ID:
lto.append((t[1],t[0],t[2]))
else :
lto.append((t[0],t[1],t[2]))
return lto
def create_evt(self):
"""
Create simpy events from communication gaph
The available reception event for the given id are pickup into the
communication graph to fill self.devt.
Examples
--------
>>> from pylayers.network.communication import *
>>> R = RX()
>>> R.create_evt()
"""
rPNe = self.swap_lt(self.PN.edges(keys=True))
for e in rPNe:
self.devt[e]=self.gcom.devt[e]
if self.mp :
for e in rPNe:
self.devt[e]=self.gcom.devt[e+str(mp)]
def refresh_RSS(self):
"""
Refresh RSS process
The RSS values on the edges of the Personnal Network of node self.ID
are refreshed every self.refreshRSS
"""
self.create_evt()
while 1:
for rat in self.PN.SubNet.keys():
# 2 approach to determine visibility
## 1) test visibility during the refresh
# [self.PN.edge[self.ID][n][rat].update(
# {'Pr':self.net.edge[self.ID][n][rat]['Pr'],
# 'tPr':self.sim.now(),
# 'vis':self.net.edge[self.ID][n][rat]['Pr'][0]>self.net.node[self.ID]['sens'][rat]})
# for n in self.PN.SubNet[rat].edge[self.ID].keys()]
# 2) copy the visibility information from network layer
[self.PN.edge[self.ID][n][rat].update(
{'Pr':self.net.edge[self.ID][n][rat]['Pr'],'tPr':self.sim.now(),'vis':self.net.edge[self.ID][n][rat]['vis']})
for n in self.PN.SubNet[rat].edge[self.ID].keys() ]
if self.sim.verbose:
print 'refresh RSS node', self.ID, ' @',self.sim.now()
yield hold, self, self.refreshRSS
def refresh_TOA(self):
"""
Refresh TOA process
The TOA values on the edges of the Personnal Network of node self.ID
are refreshed every self.refreshTOA
"""
self.create_evt()
while 1:
for rat in self.PN.SubNet.keys():
# 2 approaches :
## 1) that commented code allow refresh TOA only when visibility
# [self.PN.edge[self.ID][n][rat].update(
# {'TOA':self.net.edge[self.ID][n][rat]['TOA'],'tTOA':self.sim.now()})
# for n in self.PN.SubNet[rat].edge[self.ID].keys() if self.net.edge[self.ID][n][rat]['vis']]
# 2 refresj TOa whatever visibility or not
[self.PN.edge[self.ID][n][rat].update(
{'TOA':self.net.edge[self.ID][n][rat]['TOA'],'tTOA':self.sim.now()})
for n in self.PN.SubNet[rat].edge[self.ID].keys() ]
if self.sim.verbose:
print 'refresh TOA node', self.ID, ' @',self.sim.now()
yield hold, self, self.refreshTOA
def wait_TOArq(self):
"""
Wait TOA request
The self.ID node wait a TOA request from another node of its Personal network.
Once the request is received, self.ID reply to the requester node
and fill the PN edge with the measured TOA.
"""
self.create_evt()
while 1:
yield waitevent,self,self.devt.values()
for evt in self.devt.values():
if evt.occurred:
# evt.name[0] = requester
# evt.name[1] = requested ( = self.ID)
# evt.name[2] = rat
# update personal network TOA value
self.PN.edge[evt.name[1]][evt.name[0]][evt.name[2]].update(
{'TOA':self.net.edge[evt.name[1]][evt.name[0]][evt.name[2]]['TOA'],'tTOA':self.sim.now()})
if self.sim.verbose:
print 'TOA requested by',evt.name[0],'to',evt.name[1],'has been updated'
break
