def get_mu(self,
mu_k,
mu_k_1,
load_k,
load_k_1,
nabla_k,
rating_load,
gamma=None):
#rating_load = nabla_k / (mu_k+tol)
#hessian = np.absolute(rating_load - 2 * mu_k * ((load_k-load_k_1)/util.non_zero((mu_k-mu_k_1+0.5))))
delta = 0.0000001
hessian = np.absolute((load_k - load_k_1) / util.non_zero(
(mu_k - mu_k_1)))
hessian = np.maximum(delta, hessian)
#print(hessian)
#hessian = np.array([util.tol if e <= util.tol else e for e in hessian])
hessian = 1.0 / hessian
#print(hessian)
if gamma == None:
#mu = mu_k - hessian * nabla_k
mu = np.maximum(0.0, mu_k - hessian * nabla_k)
else:
#mu = rating_load - 2 * mu_k * ((load_k-load_k_1)/(mu_k-mu_K_1))
mu = np.maximum(0.0, mu_k - gamma * hessian * nabla_k)
return mu
def get_load_nabla(self, T, A, U, LB, UB, connected, P, Q, w, mu):
#x = np.minimum(np.maximum(LB, w/util.non_zero(np.dot(T.T, mu**2))), UB)
x = np.minimum(np.maximum(LB, w / util.non_zero(np.dot(T.T, mu))), UB)
ev_power = np.zeros(self.env['evNumber'])
for j in range(0, len(connected)):
ev_power[connected[j]] = x[j]
load = self.get_trans_load(ev_power, P, Q)
nabla = np.array(self.env['transRating']) - load
load = np.array([load[e] for e in U])
rating_load = np.array([nabla[e] for e in U])
#nabla = 2 * mu * rating_load
nabla = rating_load
return (load, nabla, x, rating_load)
load_k_1 = np.copy(load_k)
mu_k_1 = np.copy(mu_k)
(load_k, nabla_k, x, rating_load) = get_load_nabla(T,A,U,LB,mu)
#print(mu_k)
mu_k = np.copy(mu)
#lamda = lamda_k - ( ( load_k-load_k_1 )/( nabla_k-nabla_k_1 ) ) * nabla_k
#print(lamda)
#lamda = 1.0 / (lamda+1e-7)
#g = 2 * lamda * g
#lamda = lamda_k - lamda * g
#lamda = lamda - gamma*scale*g
#x = np.minimum(np.maximum(LB, w/np.dot(T.T, (lamda+1e-7)**2)), get_UB())
else:
x = np.minimum(np.maximum(LB, w/util.non_zero( np.dot(T.T, lamda) )), get_UB())
#x = np.minimum(np.maximum(LB, w/np.dot(T.T, (lamda+1e-7))), get_UB())
ev_power = np.zeros(env['evNumber'])
for j in range(0, len(connected)):
ev_power[connected[j]] = x[j]
#load = get_trans_load(ev_power)
#nabla = np.array(env['transRating']) - load
#g = ( np.array(env['transRating']) - load )
if name=='GPA':
g = np.array(env['transRating']) - get_trans_load(ev_power)
g = np.array([g[e] for e in U])
#print(gamma*scale)
def update(self, P, Q, central={}):
connected = self.get_connected()
#w = util.f(self.get_driver_type(connected)) * util.g(self.get_laxity(connected, scale=0.0))
w = util.w(self.get_discrepancy(connected),
self.get_laxity(connected, scale=0.0))
#laxity = self.get_laxity(connected)
#w = w * (144-laxity)
LB = np.zeros(len(connected))
n_iter = 0
gamma = 0.0
x = []
'''
urgent = self.get_urgent(connected)
if len(urgent)>0:
T, A, _ = self.get_TAU(urgent, P, Q)
ur_LB = lb.solve(self.get_laxity(urgent), self.params['theta'], self.get_UB(urgent), A, T)
for i in range(0, len(urgent)):
j, = np.where(connected == urgent[i])
LB[j[0]] = ur_LB[i]
'''
if len(connected) > 0:
T, A, U = self.get_TAU(connected, P, Q)
'''
m = (np.amax(self.get_UB(connected)))**2
L = np.amax(np.sum(T, axis=0))
S = np.amax(np.sum(T, axis=1))
'''
#gamma = (2.0*self.params['step_factor'])/(m*L*S+util.tol)
#gamma = 0.00060483158055174284
rho = 1.0
#print('gamma')
#print(gamma)
#lamda = np.zeros(len(A))
u_k = np.zeros(len(A))
y_k = np.zeros(len(A))
lamda_k = np.ones(len(A))
#print(np.dot(T.T, lamda))
x = np.zeros(len(connected))
for i in range(0, self.params['max_iter']):
#for i in range(0, 40):
n_iter = i + 1
x = np.minimum(
np.maximum(LB, w / util.non_zero(np.dot(T.T, lamda_k))),
self.get_UB(connected))
ev_power = np.zeros(self.env['evNumber'])
for j in range(0, len(connected)):
ev_power[connected[j]] = x[j]
#self.update_remaining_demand(ev_power, self.slot_len_in_min/self.params['max_iter'])
g = np.array(self.env['transRating']) - self.get_trans_load(
ev_power, P, Q)
g = np.array([g[e] for e in U])
lamda = -g / rho + y_k - u_k
y = np.maximum(0.0, lamda + u_k)
u = u_k + rho * (lamda - y)
lamda_k = np.copy(lamda)
y_k = np.copy(y)
u_k = np.copy(u)
#if np.allclose(self.get_trans_load(ev_power,P,Q), central['trans_load'], atol=0.0, rtol=self.params['tol'])==True:
# break
#print(ev_power)
#print(central['ev_power'])
'''
sub = [0,0]
temp = self.get_trans_load(ev_power,P,Q)
sub[0] = central['trans_load'][0]+central['trans_load'][1]+central['trans_load'][2]
sub[1] = temp[0]+temp[1]+temp[2]
#print(abs(sub[1]-sub[0])/sub[0])
if abs(sub[1]-sub[0]) <= self.params['tol']*sub[0]:
break
'''
c = sum(central['ev_power'])
d = sum(ev_power)
if abs(d - c) <= self.params['tol'] * c:
break
#if np.allclose(ev_power, central['ev_power'], atol=0.0, rtol=self.params['tol'])==True:
# break
print('admm')
print(n_iter)
#print(x)
ev_power = np.zeros(self.env['evNumber'])
for i in range(0, len(connected)):
ev_power[connected[i]] = x[i]
self.update_remaining_demand(ev_power, self.slot_len_in_min)
'''
c = sum(central['ev_power'])
d = sum(ev_power)
z = 1 - abs(d-c)/(c + util.tol)
print( z*100 )
'''
#self.update_remaining_demand(ev_power)
result = {
'trans_load': self.get_trans_load(ev_power, P, Q).tolist(),
'ev_power': ev_power.tolist(),
'x': x,
'connected': connected.tolist(),
'remaining_demand': self.remaining_demand.tolist(),
'gamma': gamma,
'n_iter': n_iter
}
self.current_slot += 1
#print('decentral')
#print(result['ev_power'])
return result