def fill_cla(self):
"""
fill the constraint layer array
Notes
-----
loop on edges
loop on wstd
append cla with available LDP among (RSS,TOA)
Warning
-------
TDOA not implemented yet
"""
## loop on edges
for e in self.net.node[self.ID]['PN'].edge[self.ID].keys():
## loop on wstd
for wstd in self.net.node[self.ID]['PN'].edge[self.ID][e].keys():
try:
param = dict(self.config.items(wstd+'_PLM'))
self.cla.append(
RSS(id = wstd+'-Pr-'+self.ID+'-'+e,
value = self.net.node[self.ID]['PN'].edge[self.ID][e][wstd]['Pr'][0],
std = self.net.node[self.ID]['PN'].edge[self.ID][e][wstd]['Pr'][1],
model = PLSmodel(f = eval(param['f']),
rssnp = eval(param['rssnp']),
d0 = eval(param['d0']),
method = param['method']),
p = self.net.node[self.ID]['PN'].node[e]['pe'],
origin={'id':self.ID,'link':[e],'wstd':wstd,'ldp':'Pr'}
)
)
except:
param = dict(self.config.items(wstd+'_PLM'))
self.cla.append(
RSS(id = wstd+'-Pr-'+self.ID+'-'+e,
p = self.net.node[self.ID]['PN'].node[e]['pe'],
origin={'id':self.ID,'link':[e],'wstd':wstd,'ldp':'Pr'}
)
)
try:
self.cla.append(
TOA(id = wstd+'-TOA-'+self.ID+'-'+e,
value = self.net.node[self.ID]['PN'].edge[self.ID][e][wstd]['TOA'][0],
std = self.net.node[self.ID]['PN'].edge[self.ID][e][wstd]['TOA'][1],
p= self.net.node[self.ID]['PN'].node[e]['pe'],
origin={'id':self.ID,'link':[e],'wstd':wstd,'ldp':'TOA'}
)
)
except:
self.cla.append(
TOA(id = wstd+'-TOA-'+self.ID+'-'+e,
p= self.net.node[self.ID]['PN'].node[e]['pe'],
origin={'id':self.ID,'link':[e],'wstd':wstd,'ldp':'TOA'}
)
)
def load_model(self,RAT):
""" load a path loss shadowing model for a RAT
Parameters
----------
RAT : string
RAT name
"""
ratopt = dict(self.config.items(RAT+'_PLM'))
# Path Loss Shadowing model
self.model[RAT] = PLSmodel(f = eval(ratopt['f']),
rssnp = eval(ratopt['rssnp']),
d0 = eval(ratopt['d0']),
sigrss = eval(ratopt['sigrss']),
method = ratopt['method'])
def solve(self,p,e,LDP,RAT,epwr,sens):
""" computes and returns a LDP value
Parameters
----------
p : np.array
e : np.array
LDP : string
Type of LDP ( TOA, Pr, .... any other are to be add in teh todo list)
epwr : list
nodes transmitted power
sens : list
nodes sensitivity
Returns
-------
value : float
A LDP value : * A time in ns for LDP ='TOA'
* A received power in dBm for LDP ='Pr'
std : float
A LDP value standard deviation: * A time in ns for LDP ='TOA'
* A received power in dBm for LDP ='Pr'
LDP (Location Dependent Parameter)
"""
try:
model= self.model[RAT]
except:
try:
self.load_model(RAT)
model = self.model[RAT]
except:
self.model[RAT] = PLSmodel()
self.save_model(RAT,self.model[RAT])
model = self.model[RAT]
# if self.EMS_method == 'direct':
# dd={} # distance dictionnary
# if len(e) > 0:
# lp=np.array([np.array((p[e[i][0]],p[e[i][1]])) for i in range(len(e))])
# d=np.sqrt(np.sum((lp[:,0]-lp[:,1])**2,axis=1))
# if LDP == 'TOA':
# std = self.sigmaTOA*sp.randn(len(d))
# return ([[max(0.0,(d[i]+std[i])*0.3),self.sigmaTOA*0.3] for i in range(len(d))],d)
# elif LDP == 'Pr':
# std = self.model.sigrss*sp.randn(len(d))
# r=model.getPL(d,model.sigrss)
# return ([[- r[i]-model.PL0,model.sigrss] for i in range(len(d))],d)
#
#
# else :
# raise NameError('invalid LDP name')
# else :
# return ([[0.],[0.]])
if self.EMS_method == 'multiwall':
dd = {} # distance dictionnary
if len(e) > 0:
lp = np.array([np.array((p[e[i][0]],p[e[i][1]])) for i in range(len(e))])
# MW is 2D only now.
# This explain the following licenses
lp = lp[:,:,:2]
dim = lp.shape[2]
# d euclidian distance
d = np.sqrt(np.sum((lp[:,0]-lp[:,1])**2,axis=1))
slp = np.shape(lp)[1]
# evaluation of all LDPs
if LDP=='all':
pa = np.vstack(p.values())
lpa = len(pa)
Pr = []
TOA = []
lsens = np.array(())
loss = np.array(())
frees = np.array(())
lepwr = np.array(())
for i in range(lpa-1):
# excess time of flight + losses computation
#
# Losst returns 4 parameters
# Lo Lp Edo Edp
#
pdb.set_trace()
MW = lo.Losst(self.L,model.f,pa[i+1:lpa,:dim].T,pa[i,:dim])
# MW = lo.Loss0_v2(self.L,pa[i+1:lpa],model.f,pa[i])
# loss free space
frees=np.hstack((frees,
lo.PL(np.array([model.f]),
pa[i+1:lpa,:dim].T,
pa[i,:dim].reshape(2,1),
model.rssnp)[0] ))
# Pr.extend(lepwr - MW[0] - frees)
# WARNING : only one polarization is taken into
# account here
# save losses computation
loss = np.hstack((loss,MW[0][0]))
# save excess tof computation
TOA = np.hstack((TOA,MW[2][0]))
# emmited power for the first nodes of computed edges
lepwr1 = [epwr[i[0]][RAT] for i in e]
lepwr2 = [epwr[i[1]][RAT] for i in e]
Pr = lepwr1 - loss - frees
# concatenate reverse link
Pr = np.hstack((Pr, lepwr2 - loss - frees))
P = np.outer(Pr,[1,1])
P[:,1] = model.sigrss
lsens = [sens[i[0]][RAT] for i in e] + [sens[i[1]][RAT] for i in e]
# visibility or not
v = P[:,0] > lsens
# same toa for link and reverse link
T = np.hstack((TOA+d/0.3,TOA+d/0.3))
T=np.outer(T,[1,1])
T[:,1]=self.sigmaTOA*0.3
d=np.hstack((d,d))
return (P,T,d,v)
# elif LDP == 'Pr':
# pa = np.vstack(p.values())
# pn = p.keys()
# lpa = len(pa)
# Lwo = []
# frees=[]
# lepwr=[]
# for i in range(lpa-1):
# lo.append(Loss0_v2(self.L,pa[i+1:lpa],model.f,pa[i]))
# Lwo.extend(Loss0_v2(self.L,pa[i+1:lpa],model.f,pa[i])[0])
# frees.extend(PL(pa[i+1:lpa],model.f,pa[i],model.rssnp))
# lepwr.extend(epwr[i+1:lpa])
# return ([[lepwr[i] - Lwo[i]-frees[i],model.sigrss] for i in range(len(Lwo))],d)
#
# elif LDP == 'TOA': #### NOT CORRECT !
# std = self.sigmaTOA*sp.randn(len(d))
# return ([[max(0.0,(d[i]+std[i])*0.3),self.sigmaTOA*0.3] for i in range(len(d))],d)
else :
return (np.array((0.,0.)),np.array((0.,0.)),np.array((0.,0.)),np.array((0.,0.)))
elif self.method == 'raytracing':
print 'Okay, I think we\'ve got something to append in the TODO list'
else :
raise NameError('invalid method name')