def main(args):
import numpy as np
import CLA
#1) Path
path=args[0]
#2) Load data, set seed
headers=open(path,'r').readline().split(',')[:-1]
data=np.genfromtxt(path,delimiter=',',skip_header=1) # load as numpy array
mean=np.array(data[:1]).T
lB=np.array(data[1:2]).T
uB=np.array(data[2:3]).T
covar=np.array(data[3:])
#3) Invoke object
cla=CLA.CLA(mean,covar,lB,uB)
cla.solve()
print cla.w # print all turning points
#4) Plot frontier
mu,sigma,weights=cla.efFrontier(100)
plot2D(sigma, mu, 'Risk', 'Expected Excess Return', 'CLA-derived Efficient Frontier')
#5) Get Maximum Sharpe ratio portfolio
sr,w_sr = cla.getMaxSR()
print np.dot(np.dot(w_sr.T, cla.covar), w_sr)[0, 0]**.5, sr
print w_sr
#6) Get Minimum Variance portfolio
mv, w_mv = cla.getMinVar()
print mv
print w_mv
return
def getCLA(cov, **kargs):
#compute CLA's minimum variance portfolio
mean = np.arange(cov.shape[0]).reshape(-1, 1) # not used by c portf
lB = np.zeros(mean.shape)
uB = np.ones(mean.shape)
cla = CLA.CLA(mean, cov, lB, uB)
cla.solve()
return cla.w[-1].flatten()
def main():
import numpy as np
import CLA
# 1) Path
path = 'CLA_Data.csv'
# 2) Load data, set seed
headers = open(path, 'r').readline()[:-1].split(',')
data = np.genfromtxt(path, delimiter=',',
skip_header=1) # load as numpy array
mean = np.array(data[:1]).T
lB = np.array(data[1:2]).T
uB = np.array(data[2:3]).T
covar = np.array(data[3:])
# 3) Invoke object
cla = CLA.CLA(mean, covar, lB, uB)
cla.solve()
print('===============All Turning point====================')
for w in cla.w:
print(w)
# print(cla.w) # print all turning points
# 4) Plot frontier
mu, sigma, weights = cla.efFrontier(500)
# plot2D(sigma, mu, 'Risk', 'Expected Excess Return', 'CLA-derived Efficient Frontier', '../')
# 5) Get Maximum Sharpe ratio portfolio
print("==============Get Maximum Sharpe ratio portfolio===============")
sr, w_sr = cla.getMaxSR()
print(np.dot(np.dot(w_sr.T, cla.covar), w_sr)[0, 0]**.5, sr)
print(w_sr)
print(sum(w_sr))
# 6) Get Minimum Variance portfolio
print("==============Get Minimum Variance portfolio=================")
mv, w_mv = cla.getMinVar()
print(mv)
print(w_mv)
print(sum(w_mv))
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1) # one row, one column, first plot
ax.plot(sigma, mu, color='blue', label='Efficient Frontier')
ax.set_xlabel('Risk')
ax.set_ylabel('Expected Excess Return', rotation=90)
plt.xticks(rotation='vertical')
plt.title('CLA-derived Efficient Frontier')
sr = ax.scatter(
np.dot(np.dot(w_sr.T, cla.covar), w_sr)[0, 0]**.5,
np.dot(w_sr.T, cla.mean)[0, 0])
mv = ax.scatter(
np.dot(np.dot(w_mv.T, cla.covar), w_mv)[0, 0]**.5,
np.dot(w_mv.T, cla.mean)[0, 0])
plt.legend((sr, mv), ('maximum sharpe ratio', 'minimum variance'))
plt.show()
return
def run(self):
"""
run : run simulation of the scenario
"""
self.CRB=[]
Nbn = len(self.bn)
Nan = len(self.an)
if self.parmsc['save_pe']:
self.pe = []
self.p_LS = []
self.p_LSci = []
self.p_LScr = []
if self.parmsc['save_CLA']:
self.CLA = []
self.err1 = np.array([])
#self.err2 = np.array([])
self.errx = np.array([])
self.erry = np.array([])
self.errz = np.array([])
self.errLS = np.array([])
self.errLSci = np.array([])
self.errLScr = np.array([])
self.errxLS = np.array([])
self.erryLS = np.array([])
self.errzLS = np.array([])
# list for algebraic
atoabn = []
astdbn = []
P = []
if self.parmsc['Constrain_Type']=='TDOA':
lbcl=Nan-1
else :
lbcl=Nan
tdoa_idx = nonzero(np.array(l_connect)=='TDOA')[0]
if self.parmsc['Constrain_Type']=='hybrid' or self.parmsc['Constrain_Type']=='test':
algehyb=1
else :
algehyb=0
if len(tdoa_idx) != 0:
lbcl=Nan-1
self.rss_idx = nonzero(np.array(l_connect)=='RSS')[0]
self.toa_idx = nonzero(np.array(l_connect)=='TOA')[0]
self.tdoa_idx = nonzero(np.array(l_connect)=='TDOA')[0]
self.ERRSAVE=[]
self.trgpa=[]
self.talg=[]
for ibn in range(Nbn): # for each blind node
self.errRSS=zeros((1))
self.errTOA=zeros((1))
self.errTDOA=zeros((1))
self.ibn=ibn
errli = []
Constraint.C_Id = 0 # reset constraint Id for each BN
print " Blind Node N°",ibn+1,"/",Nbn
atv=[]
pbn = self.bn[ibn]
#print "Blind Node N° ",ibn,pbn
self.tic_ensemblist=time.time()
cla = CLA(self.parmsh)
cla.bn = self.bn[ibn]
clarss = CLA(self.parmsh)
clatoa = CLA(self.parmsh)
clatdoa = CLA(self.parmsh)
if parmsc['exclude_out'] != None :
E = Exclude(nodes=parmsc['exclude_out'])
cla.append(E)
for ian in range(lbcl): # for each AN or couple of AN (TDOA)
TC=0
try :
self.parmsc['Constrain_Type'] = self.parmsc['l_connect'][ian]
except :
pass
####################### TOA : Geometric description
if self.parmsc['Constrain_Type']=='TOA':
pan = self.an[ian]
# tvalue : true value (ns)
tvalue = np.sqrt(np.dot(pan-pbn,pan-pbn))/3e8
# err (ns)
err = (self.std_v[ibn,ian]*sp.randn())
while err + tvalue < 0:
err = (self.std_v[ibn,ian]*sp.randn())
self.ERRSAVE.append(err)
self.errTOA=np.vstack((self.errTOA,err))
# value (toa : ns )
value = max(0,tvalue+err)
TC1=time.time()
C = TOA(value=value*1e9,
std=self.std_v[ibn,ian]*1e9,
vcw=self.parmsc['vcw'],
p=pan)
cla.append(C)
TC2=time.time()
clatoa.append(C)
####################### TDOA : Geometric description
if self.parmsc['Constrain_Type']=='TDOA':
pan = vstack((self.an[tdoa_idx[0]],self.an[ian+1]))
# dan : delay between 2 AN (ns)
dan = np.sqrt(dot(pan[0]-pan[1],pan[0]-pan[1]))/3e8
minvalue = -dan
maxvalue = dan
toa1 = np.sqrt(np.dot(pan[0]-pbn,pan[0]-pbn))/3e8
toa2 = np.sqrt(np.dot(pan[1]-pbn,pan[1]-pbn))/3e8
tvalue = toa2-toa1
err = self.std_v[ibn,ian]*sp.randn()
while ((tvalue + err) < minvalue) or ((tvalue + err) > maxvalue):
err = self.std_v[ibn,ian]*sp.randn()
self.ERRSAVE.append(err)
self.errTDOA=np.vstack((self.errTDOA,err))
# tvalue : true value (ns)
# value = max(minvalue,tvalue + err)
# value = min(maxvalue,value)
# value (ns)
value = tvalue+err
TC1=time.time()
C = TDOA(value=-value*1e9,
std=(self.std_v[ibn,ian]*1e9),
vcw=self.parmsc['vcw'],
p = pan)
cla.append(C)
TC2=time.time()
#C = TDOA(p=pan,value=value,std=2)
clatdoa.append(C)
####################### RSS : Geometric description
if self.parmsc['Constrain_Type']=='RSS':
pan = self.an[ian]
d0 = self.parmsc['d0']
RSSnp = vstack((self.parmsc['pn'],self.parmsc['pn']))
PL0= vstack((self.parmsc['rss0'],self.parmsc['rss0']))
RSSStd= vstack((self.parmsc['sigma_max_RSS'],self.parmsc['sigma_max_RSS']))
PP= vstack((self.bn[ibn],self.bn[ibn]))
PA= vstack((pan,pan))
rssloc = RSSLocation(PP)
value = (rssloc.getPLmean(PA.T, PP.T, PL0, d0, RSSnp))
err = (RSSStd*randn(shape(value)[0],shape(value)[1]))[0][0]
self.ERRSAVE.append(err)
self.errRSS=np.vstack((self.errRSS,err))
value = value[0] + err
# value = rssloc.getPL(PA.T, PP.T, PL0, d0, RSSnp, RSSStd)
value = value
# value = self.parmsc['rss0']-10*self.parmsc['pn']*log10(dr/self.parmsc['d0'])+self.err_v[ibn,ian]
self.Model = {}
self.Model['PL0'] =self.parmsc['rss0']
self.Model['d0'] = self.parmsc['d0']
self.Model['RSSnp'] = self.parmsc['pn']
self.Model['RSSStd'] = self.parmsc['sigma_max_RSS']
self.Model['Rest'] = 'mode'
TC1=time.time()
C = RSS(value=value,
std=self.std_v[ibn,ian],
vcw=self.parmsc['vcw'],
model=self.Model,
p=pan )
cla.append(C)
TC2=time.time()
clarss.append(C)
TC=TC+(TC2-TC1)
if self.parmsc['algebraic']:
atv.append(value)
if len(self.rss_idx) != 0:
self.errRSS = delete(self.errRSS,0,0)
if len(self.toa_idx) != 0:
self.errTOA = delete(self.errTOA,0,0)
if len(self.tdoa_idx) != 0:
self.errTDOA = delete(self.errTDOA,0,0)
# version boite recursive
#
######################### CLA TOTALE
TR1=time.time()
cla.merge2()
cla.refine(cla.Nc)
self.cla = cla
### DoubleListRefine version
cla.estpos2()
pe1=cla.pe
TR2=time.time()
self.trgpa.append((TR2-TR1)+TC)
self.pe.append(pe1)
errli.append(np.sqrt(np.dot(pe1[:2]-pbn[:2],pe1[:2]-pbn[:2])))
err1=min(errli)
self.err1 = np.hstack((self.err1,err1))
if self.parmsc['algebraic']:
if algehyb==1:
self.parmsc['Constrain_Type']='hybrid'
p_LS = self.algebraic_compute(atv,None)
# p_LSci = self.algebraic_compute(atv,self.pe[-1])
# p_LScr = self.algebraic_compute(atv,self.bn[ibn])
if self.parmsc['save_pe']:
self.p_LS.append(p_LS)
# self.p_LSci.append(p_LSci)
# self.p_LScr.append(p_LScr)
if self.parmsc['Constrain_Type'] != 'hybrid':
errLS = np.sqrt(np.dot(p_LS[:2]-pbn[:2],p_LS[:2]-pbn[:2]))
# errLSci = np.sqrt(np.dot(p_LSci[:2]-pbn[:2],p_LSci[:2]-pbn[:2]))
# errLScr = np.sqrt(np.dot(p_LScr[:2]-pbn[:2],p_LScr[:2]-pbn[:2]))
else :
errLS = np.sqrt(np.dot(p_LS[:2]-pbn[:2],p_LS[:2]-pbn[:2]))
# errLSci = np.sqrt(np.dot(p_LSci[:2]-pbn[:2],p_LSci[:2]-pbn[:2]))
# errLScr = np.sqrt(np.dot(p_LScr[:2]-pbn[:2],p_LScr[:2]-pbn[:2]))
self.errLS = np.hstack((self.errLS,errLS))
# self.errLSci = np.hstack((self.errLSci,errLSci))
# self.errLScr = np.hstack((self.errLSci,errLScr))
if errli > errLS:
print 'NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNnn\n',errli,'\n',errLS
def run(self):
"""
run : run simulation of the scenario
"""
self.time_compute = {}
self.time_compute['RGPA'] = []
self.time_compute['algebraic'] = []
self.CRB = []
Nbn = len(self.bn)
Nan = len(self.an)
if self.parmsc['save_pe']:
self.pe = []
self.p_LS = []
if self.parmsc['save_CLA']:
self.CLA = []
self.err1 = np.array([])
#self.err2 = np.array([])
self.errx = np.array([])
self.erry = np.array([])
self.errz = np.array([])
self.errLS = np.array([])
self.errxLS = np.array([])
self.erryLS = np.array([])
self.errzLS = np.array([])
# list for algebraic
atoabn = []
astdbn = []
P = []
if self.parmsc['Constrain_Type'] == 'TDOA':
lbcl = Nan - 1
else:
lbcl = Nan
tdoa_idx = nonzero(np.array(l_connect) == 'TDOA')[0]
if self.parmsc['Constrain_Type'] == 'hybrid' or self.parmsc[
'Constrain_Type'] == 'test':
algehyb = 1
else:
algehyb = 0
if len(tdoa_idx) != 0:
lbcl = Nan - 1
#self.dan=[]
#for i in range(len(tdoa_idx)-1):
# self.dan.append(vstack((self.an[tdoa_idx[0]],self.an[i+1])))
self.rss_idx = nonzero(np.array(l_connect) == 'RSS')[0]
self.toa_idx = nonzero(np.array(l_connect) == 'TOA')[0]
self.tdoa_idx = nonzero(np.array(l_connect) == 'TDOA')[0]
self.ERRSAVE = []
for ibn in range(Nbn): # for each blind node
self.errRSS = zeros((1))
self.errTOA = zeros((1))
self.errTDOA = zeros((1))
self.ibn = ibn
errli = []
Constraint.C_Id = 0 # reset constraint Id for each BN
print " Blind Node N°", ibn + 1, "/", Nbn
atv = []
pbn = self.bn[ibn]
#print "Blind Node N° ",ibn,pbn
self.tic_ensemblist = time.time()
cla = CLA(self.parmsh)
cla.bn = self.bn[ibn]
clarss = CLA(self.parmsh)
clatoa = CLA(self.parmsh)
clatdoa = CLA(self.parmsh)
#cla.C_Id=0
if parmsc['exclude_out'] != None:
E = Exclude(nodes=parmsc['exclude_out'])
cla.append(E)
for ian in range(lbcl): # for each AN or couple of AN (TDOA)
#print "Anchor Node N° ",ian
try:
self.parmsc['Constrain_Type'] = self.parmsc['l_connect'][
ian]
except:
pass
# pdb.set_trace()
rgpatimea = time.time()
if self.parmsc['Constrain_Type'] == 'TOA':
pan = self.an[ian]
# tvalue : true value (ns)
tvalue = np.sqrt(np.dot(pan - pbn, pan - pbn)) / 3e8
# err (ns)
err = (self.std_v[ibn, ian] * sp.randn())
while err + tvalue < 0:
err = (self.std_v[ibn, ian] * sp.randn())
self.errTOA = np.vstack((self.errTOA, err))
# value (toa : ns )
value = max(0, tvalue + err)
C = TOA(value=value * 1e9,
std=self.std_v[ibn, ian] * 1e9,
vcw=self.parmsc['vcw'],
p=pan)
cla.append(C)
clatoa.append(C)
if self.parmsc['Constrain_Type'] == 'TDOA':
pan = vstack((self.an[tdoa_idx[0]], self.an[ian + 1]))
# dan : delay between 2 AN (ns)
dan = np.sqrt(dot(pan[0] - pan[1], pan[0] - pan[1])) / 3e8
minvalue = -dan
maxvalue = dan
toa1 = np.sqrt(np.dot(pan[0] - pbn, pan[0] - pbn)) / 3e8
toa2 = np.sqrt(np.dot(pan[1] - pbn, pan[1] - pbn)) / 3e8
tvalue = toa2 - toa1
err = self.std_v[ibn, ian] * sp.randn()
while ((tvalue + err) < minvalue) or (
(tvalue + err) > maxvalue):
err = self.std_v[ibn, ian] * sp.randn()
self.errTDOA = np.vstack((self.errTDOA, err))
# tvalue : true value (ns)
# value = max(minvalue,tvalue + err)
# value = min(maxvalue,value)
# value (ns)
value = tvalue + err
C = TDOA(value=-value * 1e9,
std=(self.std_v[ibn, ian] * 1e9),
vcw=self.parmsc['vcw'],
p=pan)
cla.append(C)
#C = TDOA(p=pan,value=value,std=2)
clatdoa.append(C)
if self.parmsc['Constrain_Type'] == 'RSS':
pan = self.an[ian]
######################################## MODEL RSS NICO
# dr = max(0, (np.sqrt(np.dot(pan-pbn,pan-pbn))))
# M = Model()
# err = (self.std_v[ibn,ian]*1e-9*sp.randn())
# value = M.OneSlope(max(0,dr + err))
# value = min(500,value)
# value = max(-500,value)
######################################## MOHAMED
d0 = self.parmsc['d0']
RSSnp = vstack((self.parmsc['pn'], self.parmsc['pn']))
PL0 = vstack((self.parmsc['rss0'], self.parmsc['rss0']))
RSSStd = vstack((self.parmsc['sigma_max_RSS'],
self.parmsc['sigma_max_RSS']))
PP = vstack((self.bn[ibn], self.bn[ibn]))
PA = vstack((pan, pan))
rssloc = RSSLocation(PP)
value = (rssloc.getPLmean(PA.T, PP.T, PL0, d0, RSSnp))
err = (RSSStd * randn(shape(value)[0],
shape(value)[1]))[0][0]
self.errRSS = np.vstack((self.errRSS, err))
value = value[0] + err
# value = rssloc.getPL(PA.T, PP.T, PL0, d0, RSSnp, RSSStd)
value = value
# value = self.parmsc['rss0']-10*self.parmsc['pn']*log10(dr/self.parmsc['d0'])+self.err_v[ibn,ian]
self.Model = {}
self.Model['PL0'] = self.parmsc['rss0']
self.Model['d0'] = self.parmsc['d0']
self.Model['RSSnp'] = self.parmsc['pn']
self.Model['RSSStd'] = self.parmsc['sigma_max_RSS']
self.Model['Rest'] = 'mode'
C = RSS(value=value,
std=self.std_v[ibn, ian],
vcw=self.parmsc['vcw'],
model=self.Model,
p=pan)
cla.append(C)
clarss.append(C)
if self.parmsc['algebraic']:
atv.append(value)
if len(self.rss_idx) != 0:
self.errRSS = delete(self.errRSS, 0, 0)
if len(self.toa_idx) != 0:
self.errTOA = delete(self.errTOA, 0, 0)
if len(self.tdoa_idx) != 0:
self.errTDOA = delete(self.errTDOA, 0, 0)
# version boite recursive
#
######################### CLA TOTALE
cla.merge2()
cla.refine(cla.Nc)
self.cla = cla
### DoubleListRefine version
cla.estpos2()
pe1 = cla.pe
rgpatimeb = time.time()
self.time_compute['RGPA'].append(rgpatimeb - rgpatimea)
self.pe.append(pe1)
errli.append(np.sqrt(np.dot(pe1[:2] - pbn[:2], pe1[:2] - pbn[:2])))
#print len(parmsc['l_connect'])
if len(parmsc['l_connect']
) > 4: # pour ne pas calculer 2fois les cas non hybrides
if len(nonzero(
np.array(parmsc['l_connect']) == 'RSS')[0]) != 0:
for i in range(4):
clarss.c[i].Id = i
clarss.merge2()
clarss.refine(clarss.Nc)
clarss.estpos2()
clarss.bn = bn[ibn]
self.clarss = clarss
self.perss = clarss.pe
errli.append(
np.sqrt(
np.dot(self.perss[:2] - pbn[:2],
self.perss[:2] - pbn[:2])))
if len(nonzero(
np.array(parmsc['l_connect']) == 'TOA')[0]) != 0:
for i in range(4):
clatoa.c[i].Id = i
clatoa.merge2()
clatoa.refine(clatoa.Nc)
clatoa.estpos2()
clatoa.bn = bn[ibn]
self.clatoa = clatoa
self.petoa = clatoa.pe
errli.append(
np.sqrt(
np.dot(self.petoa[:2] - pbn[:2],
self.petoa[:2] - pbn[:2])))
if len(nonzero(
np.array(parmsc['l_connect']) == 'TDOA')[0]) != 0:
for i in range(3):
clatdoa.c[i].Id = i
clatdoa.merge2()
clatdoa.refine(clatdoa.Nc)
clatdoa.estpos2()
clatdoa.bn = bn[ibn]
self.clatdoa = clatdoa
self.petdoa = clatdoa.pe
errli.append(
np.sqrt(
np.dot(self.petdoa[:2] - pbn[:2],
self.petdoa[:2] - pbn[:2])))
#print errli
err1 = min(errli)
#print err1
self.err1 = np.hstack((self.err1, err1))
#self.err2 = np.hstack((self.err2,err2))
#if err >3:
# pdb.set_trace()
if self.parmsc['algebraic']:
if algehyb == 1:
self.parmsc['Constrain_Type'] = 'hybrid'
algetimea = time.time()
p_LS = self.algebraic_compute(atv)
algetimeb = time.time()
self.time_compute['algebraic'].append(algetimeb - algetimea)
if self.parmsc['save_pe']:
self.p_LS.append(p_LS)
if self.parmsc['Constrain_Type'] != 'hybrid':
errLS = np.sqrt(
np.dot(p_LS[:2] - pbn[:2], p_LS[:2] - pbn[:2]))
#elif self.parmsc['Algebraic_method'] == 'CRB':
# errLS = np.sqrt(self.CRB)
else:
errLS = np.sqrt(
np.dot(p_LS[:2] - pbn[:2], p_LS[:2] - pbn[:2]))
self.errLS = np.hstack((self.errLS, errLS))
if errli > errLS:
print 'NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNnn\n', errli, '\n', errLS
def run(self):
"""
run : run simulation of the scenario
"""
self.time_compute={}
self.time_compute['RGPA']=[]
self.time_compute['algebraic']=[]
self.CRB=[]
Nbn = len(self.bn)
Nan = len(self.an)
if self.parmsc['save_pe']:
self.pe = []
self.p_LS = []
if self.parmsc['save_CLA']:
self.CLA = []
self.err1 = np.array([])
#self.err2 = np.array([])
self.errx = np.array([])
self.erry = np.array([])
self.errz = np.array([])
self.errLS = np.array([])
self.errxLS = np.array([])
self.erryLS = np.array([])
self.errzLS = np.array([])
# list for algebraic
atoabn = []
astdbn = []
P = []
if self.parmsc['Constrain_Type']=='TDOA':
lbcl=Nan-1
else :
lbcl=Nan
tdoa_idx = nonzero(np.array(l_connect)=='TDOA')[0]
if self.parmsc['Constrain_Type']=='hybrid' or self.parmsc['Constrain_Type']=='test':
algehyb=1
else :
algehyb=0
if len(tdoa_idx) != 0:
lbcl=Nan-1
#self.dan=[]
#for i in range(len(tdoa_idx)-1):
# self.dan.append(vstack((self.an[tdoa_idx[0]],self.an[i+1])))
self.rss_idx = nonzero(np.array(l_connect)=='RSS')[0]
self.toa_idx = nonzero(np.array(l_connect)=='TOA')[0]
self.tdoa_idx = nonzero(np.array(l_connect)=='TDOA')[0]
self.ERRSAVE=[]
for ibn in range(Nbn): # for each blind node
self.errRSS=zeros((1))
self.errTOA=zeros((1))
self.errTDOA=zeros((1))
self.ibn=ibn
errli = []
Constraint.C_Id = 0 # reset constraint Id for each BN
print " Blind Node N°",ibn+1,"/",Nbn
atv=[]
pbn = self.bn[ibn]
#print "Blind Node N° ",ibn,pbn
self.tic_ensemblist=time.time()
cla = CLA(self.parmsh)
cla.bn = self.bn[ibn]
clarss = CLA(self.parmsh)
clatoa = CLA(self.parmsh)
clatdoa = CLA(self.parmsh)
#cla.C_Id=0
if parmsc['exclude_out'] != None :
E = Exclude(nodes=parmsc['exclude_out'])
cla.append(E)
for ian in range(lbcl): # for each AN or couple of AN (TDOA)
#print "Anchor Node N° ",ian
try :
self.parmsc['Constrain_Type'] = self.parmsc['l_connect'][ian]
except :
pass
# pdb.set_trace()
rgpatimea=time.time()
if self.parmsc['Constrain_Type']=='TOA':
pan = self.an[ian]
# tvalue : true value (ns)
tvalue = np.sqrt(np.dot(pan-pbn,pan-pbn))/3e8
# err (ns)
err = (self.std_v[ibn,ian]*sp.randn())
while err + tvalue < 0:
err = (self.std_v[ibn,ian]*sp.randn())
self.errTOA=np.vstack((self.errTOA,err))
# value (toa : ns )
value = max(0,tvalue+err)
C = TOA(value=value*1e9,
std=self.std_v[ibn,ian]*1e9,
vcw=self.parmsc['vcw'],
p=pan)
cla.append(C)
clatoa.append(C)
if self.parmsc['Constrain_Type']=='TDOA':
pan = vstack((self.an[tdoa_idx[0]],self.an[ian+1]))
# dan : delay between 2 AN (ns)
dan = np.sqrt(dot(pan[0]-pan[1],pan[0]-pan[1]))/3e8
minvalue = -dan
maxvalue = dan
toa1 = np.sqrt(np.dot(pan[0]-pbn,pan[0]-pbn))/3e8
toa2 = np.sqrt(np.dot(pan[1]-pbn,pan[1]-pbn))/3e8
tvalue = toa2-toa1
err = self.std_v[ibn,ian]*sp.randn()
while ((tvalue + err) < minvalue) or ((tvalue + err) > maxvalue):
err = self.std_v[ibn,ian]*sp.randn()
self.errTDOA=np.vstack((self.errTDOA,err))
# tvalue : true value (ns)
# value = max(minvalue,tvalue + err)
# value = min(maxvalue,value)
# value (ns)
value = tvalue+err
C = TDOA(value=-value*1e9,
std=(self.std_v[ibn,ian]*1e9),
vcw=self.parmsc['vcw'],
p = pan)
cla.append(C)
#C = TDOA(p=pan,value=value,std=2)
clatdoa.append(C)
if self.parmsc['Constrain_Type']=='RSS':
pan = self.an[ian]
######################################## MODEL RSS NICO
# dr = max(0, (np.sqrt(np.dot(pan-pbn,pan-pbn))))
# M = Model()
# err = (self.std_v[ibn,ian]*1e-9*sp.randn())
# value = M.OneSlope(max(0,dr + err))
# value = min(500,value)
# value = max(-500,value)
######################################## MOHAMED
d0 = self.parmsc['d0']
RSSnp = vstack((self.parmsc['pn'],self.parmsc['pn']))
PL0= vstack((self.parmsc['rss0'],self.parmsc['rss0']))
RSSStd= vstack((self.parmsc['sigma_max_RSS'],self.parmsc['sigma_max_RSS']))
PP= vstack((self.bn[ibn],self.bn[ibn]))
PA= vstack((pan,pan))
rssloc = RSSLocation(PP)
value = (rssloc.getPLmean(PA.T, PP.T, PL0, d0, RSSnp))
err = (RSSStd*randn(shape(value)[0],shape(value)[1]))[0][0]
self.errRSS=np.vstack((self.errRSS,err))
value = value[0] + err
# value = rssloc.getPL(PA.T, PP.T, PL0, d0, RSSnp, RSSStd)
value = value
# value = self.parmsc['rss0']-10*self.parmsc['pn']*log10(dr/self.parmsc['d0'])+self.err_v[ibn,ian]
self.Model = {}
self.Model['PL0'] =self.parmsc['rss0']
self.Model['d0'] = self.parmsc['d0']
self.Model['RSSnp'] = self.parmsc['pn']
self.Model['RSSStd'] = self.parmsc['sigma_max_RSS']
self.Model['Rest'] = 'mode'
C = RSS(value=value,
std=self.std_v[ibn,ian],
vcw=self.parmsc['vcw'],
model=self.Model,
p=pan )
cla.append(C)
clarss.append(C)
if self.parmsc['algebraic']:
atv.append(value)
if len(self.rss_idx) != 0:
self.errRSS = delete(self.errRSS,0,0)
if len(self.toa_idx) != 0:
self.errTOA = delete(self.errTOA,0,0)
if len(self.tdoa_idx) != 0:
self.errTDOA = delete(self.errTDOA,0,0)
# version boite recursive
#
######################### CLA TOTALE
cla.merge2()
cla.refine(cla.Nc)
self.cla = cla
### DoubleListRefine version
cla.estpos2()
pe1=cla.pe
rgpatimeb=time.time()
self.time_compute['RGPA'].append(rgpatimeb-rgpatimea)
self.pe.append(pe1)
errli.append(np.sqrt(np.dot(pe1[:2]-pbn[:2],pe1[:2]-pbn[:2])))
#print len(parmsc['l_connect'])
if len(parmsc['l_connect']) > 4 : # pour ne pas calculer 2fois les cas non hybrides
if len(nonzero(np.array(parmsc['l_connect'])=='RSS')[0]) != 0:
for i in range(4):
clarss.c[i].Id=i
clarss.merge2()
clarss.refine(clarss.Nc)
clarss.estpos2()
clarss.bn=bn[ibn]
self.clarss=clarss
self.perss=clarss.pe
errli.append(np.sqrt(np.dot(self.perss[:2]-pbn[:2],self.perss[:2]-pbn[:2])))
if len(nonzero(np.array(parmsc['l_connect'])=='TOA')[0]) != 0:
for i in range(4):
clatoa.c[i].Id=i
clatoa.merge2()
clatoa.refine(clatoa.Nc)
clatoa.estpos2()
clatoa .bn=bn[ibn]
self.clatoa=clatoa
self.petoa=clatoa.pe
errli.append(np.sqrt(np.dot(self.petoa[:2]-pbn[:2],self.petoa[:2]-pbn[:2])))
if len(nonzero(np.array(parmsc['l_connect'])=='TDOA')[0]) != 0:
for i in range(3):
clatdoa.c[i].Id=i
clatdoa.merge2()
clatdoa.refine(clatdoa.Nc)
clatdoa.estpos2()
clatdoa.bn=bn[ibn]
self.clatdoa=clatdoa
self.petdoa=clatdoa.pe
errli.append(np.sqrt(np.dot(self.petdoa[:2]-pbn[:2],self.petdoa[:2]-pbn[:2])))
#print errli
err1=min(errli)
#print err1
self.err1 = np.hstack((self.err1,err1))
#self.err2 = np.hstack((self.err2,err2))
#if err >3:
# pdb.set_trace()
if self.parmsc['algebraic']:
if algehyb==1:
self.parmsc['Constrain_Type']='hybrid'
algetimea=time.time()
p_LS = self.algebraic_compute(atv)
algetimeb=time.time()
self.time_compute['algebraic'].append(algetimeb-algetimea)
if self.parmsc['save_pe']:
self.p_LS.append(p_LS)
if self.parmsc['Constrain_Type'] != 'hybrid':
errLS = np.sqrt(np.dot(p_LS[:2]-pbn[:2],p_LS[:2]-pbn[:2]))
#elif self.parmsc['Algebraic_method'] == 'CRB':
# errLS = np.sqrt(self.CRB)
else :
errLS = np.sqrt(np.dot(p_LS[:2]-pbn[:2],p_LS[:2]-pbn[:2]))
self.errLS = np.hstack((self.errLS,errLS))
if errli > errLS:
print 'NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNnn\n',errli,'\n',errLS
print(reg + " = " + str(register_data[reg]), sep="", end="\n")
elif i % 4 != 0: #Common case
print("{:20s}".format(reg + " = " + str(register_data[reg])),
sep="",
end="")
else: #Last on line
print(reg + " = " + str(register_data[reg]), sep="", end="\n")
i += 1
print("-" * 82)
return
if __name__ == '__main__':
CLA.run_error_check() #DEBUG
isForwarding = (sys.argv[1] == "F")
make_pipeline(sys.argv[2])
control = Control(isForwarding)
print("START OF SIMULATION (" + ("no " if not isForwarding else "") +
"forwarding)")
print("-" * 82)
pipeline_registers = make_pipereg()
while cycle_count < max_cycle_count:
temp = control.CheckBranch(pipeline_registers, branch_labels)
if temp != -1:
next_instruction_index = temp
pipeline_registers[-1].output.update(cycle_count, "WB")
for register in pipeline_registers:
if (register.input != None):
