def eval1(cs):
for i,r in enumerate(cs):
vno.edges[i].r=r
#解算网络
cvno(vno)
Q11=np.array([vno.edges[E_dict[x[0]]].q for x in TQ])
Q22=np.array([x[1] for x in TQ])
P11=np.array([vno.nodes[N_dict[x[0]]].p for x in TP])
P22=np.array([x[1] for x in TP])
a,b=0.5,0.5
return a*np.log10(1+np.var(Q11-Q22))+b*np.log10(1+np.var(P11-P22))
def cvno_test():
print("[vno模块]测试...")
#初始化vno数据(测试用)
vno = vno_data()
initVNO(vno)
#解算通风网络
ret = cvno(vno)
#打印解算结果
if not ret:
print("解算失败")
else:
#打印解算风量与测试风量的差值'
#plot_Q(vno,Q1)
#plot_P(vno,P1)
#输出解算风量
#PrintVN(vno)
#计算风量灵敏度
#edge_sst_test(vno)
#lb=np.array(R)-0.01
#ub=np.array(R)+1.5
lb=np.array(R)*0.95
ub=np.array(R)*1.05
#lb=np.array(R)*0.9
#ub=np.array(R)*1.1
TQ=zip(E,Q1)
TP=zip(N,P1)
ec_test(vno,lb,ub,TQ,TP)
def cvno_test():
print("[vno模块]测试...")
# 初始化vno数据(测试用)
vno = vno_data()
#initVNO(vno)
#initVNO2(vno)
#initVNO3(vno)
initVNO4(vno)
# 解算通风网络
ret = cvno(vno)
# 打印解算结果
if not ret:
print("解算失败")
else:
# 输出解算风量
PrintVN(vno)
# 计算风量灵敏度(2维数组,即数组的数组)
Dq=edge_sst(vno,nCount=10,accuracy=0.01)
print Dq
# 计算压力灵敏度(2维数组,即数组的数组)
Dp=node_sst(vno,nCount=50,accuracy=0.01)
print Dp
def __node_sst(vno, i, nCount=10, accuracy=0.0001, factor=0.45):
# nodes和edges就是c++中的vector
#节点的个数
NE=vno.edges.size()
#节点个数
NN=vno.nodes.size()
#第i条节点的原始风阻
r0=vno.edges[i].r
#记录第i条节点的风阻没有变化之前的所有节点压力
P0=[vno.nodes[j].p for j in range(NN)]
#记录第k次迭代时的所有节点压力
Pk=[vno.nodes[j].p for j in range(NN)]
#第i条节点风阻变化时,其它节点的压力灵敏度
D=np.zeros(NN-1) #要去掉第一个节点(压力始终等于0)
#记录迭代次数
nIter=0
#记录上次的风量误差和
last_std=0
#gen_seq1生成一个数列(收敛因子[w w^2 w^3 w^4...])
#注意:包含yield关键词的函数可以视为一个迭代器,可以使用for语句对迭代器进行迭代
for w in gen_seq1(factor,nCount):
#第i条节点的风阻变化(r=(1+w)*r)
vno.edges[i].r=(1+w)*r0
#print i,w,r0,(1+w)*r0
#第i条节点风阻变化后,执行一次网络解算
if cvno(vno):
#用压力的收敛判定替代灵敏度的收敛判定(参见论文)
f1=lambda pkk, pk, p0: pkk-(1-w)*p0-w*pk
#(pk-p0)/dr --> (pk-p0)/(r0*w)
f2=lambda pk, p0: (pk-p0)/(r0*w)
#收敛性判定(计算两个数列的差值,然后求方差--平方和然后开根号)
offset=[f1(vno.nodes[j].p, Pk[j], P0[j]) for j in range(NN)]
#print i,w,'std',np.std(offset),offset
if abs(np.std(offset)-last_std) < accuracy:
#print i,w,[vno.nodes[j].p-P0[j] for j in range(NN)]
#print i,'shoulian'
D[:]=[f2(vno.nodes[j].p, P0[j]) for j in range(1,NN)]
break
else:
nIter = nIter+1
#记录上一次迭代的压力值
Pk[:]=[vno.nodes[j].p for j in range(NN)]
#记录上一次迭代的方差
last_std = np.std(offset)
else:
#vno不收敛的情况应该非常少见
#因为我们只是第i条分支的风阻发生了微小的变化dr(非常接近0)
#print i,'vno error'
D.fill(0)
break
#print 'iter:',nIter
#if nIter == nCount:
#print i,'reach max count'
#恢复第i条节点的风阻
vno.edges[i].r=r0
return D
def __edge_sst(vno, i, nCount=10, accuracy=0.0001, factor=0.45):
# edges就是c++中的vector
#分支的个数
NE=vno.edges.size()
#第i条分支的原始风阻
r0=vno.edges[i].r
#记录第i条分支的风阻没有变化之前的所有分支风量
Q0=[vno.edges[j].q for j in range(NE)]
#记录第k次迭代时的所有分支风量
Qk=[vno.edges[j].q for j in range(NE)]
#第i条分支风阻变化时,其它分支的风量灵敏度
D=np.zeros(NE)
#记录迭代次数
nIter=0
#记录上一次的偏差
last_std=0
#生成一个数列(收敛因子[w w^2 w^3 w^4...])
#注意:包含yield关键词的函数可以视为一个迭代器,可以使用for语句对迭代器进行迭代
for w in gen_seq1(factor,nCount):
#第i条分支的风阻变化(r=(1+w)*r)
vno.edges[i].r=(1+w)*r0
#print i,w,r0,(1+w)*r0
#第i条分支风阻变化后,执行一次网络解算
if cvno(vno):
#用风量的收敛判定替代灵敏度的收敛判定(参见论文)
f1=lambda qkk, qk, q0: qkk-((1-w)*q0+w*qk)
#(qk-q0)/dr --> (qk-q0)/(r0*w)
f2=lambda qk, q0: (qk-q0)/(r0*w)
#收敛性判定(计算两个数列的差值,然后求方差--平方和然后开根号)
offset=[f1(vno.edges[j].q, Qk[j], Q0[j]) for j in range(NE)]
#print i,w,'std',np.std(offset)
if abs(np.std(offset)-last_std) < accuracy:
#print i,w,[vno.edges[j].q-Q0[j] for j in range(NE)]
D[:]=[f2(vno.edges[j].q, Q0[j]) for j in range(NE)]
break
else:
nIter = nIter+1
#记录上一次迭代的风量值
Qk[:]=[vno.edges[j].q for j in range(NE)]
#记录上一次迭代的方差
last_std=np.std(offset)
else:
D.fill(0)
break
#print 'iter:',nIter
#if nIter == nCount:
#print i,'reach max count'
#恢复第i条分支的风阻
vno.edges[i].r=r0
return D
def cvno_test():
print("[vno模块]测试...")
# 初始化vno数据(测试用)
vno = vno_data()
#initVNO(vno)
#initVNO2(vno)
#initVNO3(vno)
initVNO4(vno)
# 解算通风网络
ret = cvno(vno)
# 打印解算结果
if not ret:
print("解算失败")
else:
# 输出解算风量
PrintVN(vno)
# 计算风量灵敏度(2维数组,即数组的数组)
Dq=edge_sst(vno,nCount=10,accuracy=0.01)
#print Dq
np.savetxt('Dq.txt',Dq)
#数据标准化(白化)
whiten_Dq = whiten(np.abs(Dq))
#print whiten_Dq
np.savetxt('whiten_Dq.txt',whiten_Dq)
#分类后计算聚类重心的索引位置
print '------------fengliang-----------'
for n in range(1,9):
centroids=fca(whiten_Dq,n)
print n,'-->',[vno.edges[i].id for i in centroids]
# 计算压力灵敏度(2维数组,即数组的数组)
Dp=node_sst(vno,nCount=50,accuracy=0.01)
#print Dp
np.savetxt('Dp.txt',Dp)
whiten_Dp = whiten(np.abs(Dp))
#print whiten_Dp
np.savetxt('whiten_Dp.txt',whiten_Dp)
#分类后计算聚类重心的索引位置
print '--------yali--------------'
for n in range(1,9):
centroids=fca(whiten_Dp,n)
#print centroids
print n,'-->',[vno.nodes[i+1].id for i in centroids]
#np.savetxt('centroids_Dq.txt',[vno.edges[i].id for i in centroids])
#---------------------------------------#
ZDq=sst(Dq)
print ZDq
np.savetxt('ZDq.txt',ZDq)
#数据标准化(白化)
whiten_ZDq = whiten(ZDq)
#print whiten_ZDq
np.savetxt('whiten_ZDq.txt',whiten_ZDq)
print '--------whiten fengliang--------------'
for n in range(1,9):
centroids=fca(whiten_ZDq,n)
print n,'-->',[vno.edges[i].id for i in centroids]
#------------------
ZDp=sst(Dp)
np.savetxt('ZDp.txt',ZDp)
#数据标准化(白化)
whiten_ZDp = whiten(ZDp)
print whiten_ZDp
np.savetxt('whiten_ZDp.txt',whiten_ZDp)
print '--------whiten yali--------------'
for n in range(1,9):
centroids=fca(whiten_ZDp,n)
print centroids
print n,'-->',[vno.nodes[i+1].id for i in centroids]
