def setUp(self):
self.N = europe_plus_Nodes()
self.testlapse = range(200)
self.h0_sqr = au.get_quant_caps(\
filename='./results/Europe_aHE_copper_sqr_flows.npy')
self.h0_lin = au.get_quant_caps(\
filename='./results/Europe_aHE_copper_lin_flows.npy')
def setUp(self):
self.N = europe_plus_Nodes()
self.mean_loads = [n.mean for n in self.N]
self.mode = 'linear'
self.network_constr, self.sum_of_squared_flows_constr \
= DCs.build_DC_network(self.N, b=1e3)
self.network_copper, self.sum_of_squared_flows_copper\
= DCs.build_DC_network(self.N, copper=True)
self.Nlinks = len(au.AtoKh(self.N)[-1])
self.Nnodes = len(self.N)
self.testtimesteps = [52094, 52095, 52096, \
0, 7, 50, 100, 1434, 32049, 198391]
def PhitoF(Phi, K=None):
""" This function assumes that Phi is a single N vector,
and is intended to convert a principal component of
and injection pattern into a principal flow component.
"""
assert(sum(Phi)<= 1e-8), 'Phi is not a consistent flow pattern.'
if K!=None:
N = europe_plus_Nodes()
K = common_tools.AtoKh_old(N)[0]
L = np.dot(K, K.T)
Lplus = np.linalg.pinv(L)
KTLplus = np.dot(K.T, Lplus)
F = np.dot(KTLplus, Phi)
return F
def FtoPhi(F, K=None):
""" This function takes a L x T array (time dependent flow vector)
and converts it into an N x T array, of the corresponding
injection pattern.
"""
if K==None:
N = europe_plus_Nodes()
K = au.AtoKh_old(N)[0]
length_of_timeseries = F.shape[1]
Phi = np.empty((K.shape[0], length_of_timeseries))
for t in xrange(length_of_timeseries):
Phi[:,t] = np.dot(K, F[:,t])
return Phi, K
def solve_flow(flow_calc):
admat = ''.join(['./settings/', flow_calc.layout, 'admat.txt'])
filename = str(flow_calc)
copperflow_filename = ''.join(['./results/', flow_calc.layout, '_',
flow_calc.alphas, '_copper_', flow_calc.solvermode, '_flows.npy'])
if flow_calc.alphas=='aHE':
if flow_calc.basisnetwork == 'europeplus':
nodes = europe_plus_Nodes(admat=admat)
else:
sys.stderr.write('The object has a basisnetwork that\
is not accounted for. Use "europeplus".')
elif flow_calc.alphas.startswith('aHO'):
alpha = float(flow_calc.alphas[3:]) # expects alphas on the form aHO0.4
if flow_calc.basisnetwork == 'europeplus':
nodes = europe_plus_Nodes(admat=admat, alphas=alpha)
if flow_calc.mismatch_path != None:
nodes = set_mismatches(nodes, flow_calc.mismatch_path)
else:
sys.stderr.write('The object has a basisnetwork that\
is not accounted for. Use "europeplus".')
else:
sys.stderr.write('The object has an distribution of mixes that\
is not accounted for.')
mode_str_list = []
if 'lin' in flow_calc.solvermode:
mode_str_list.append('linear ')
elif 'sqr' in flow_calc.solvermode:
mode_str_list.append('square ')
else:
sys.stderr.write('The solver mode must be "lin", "sqr"')
if 'imp' in flow_calc.solvermode:
mode_str_list.append('impedance ')
mode = ''.join(mode_str_list)
flowfilename = ''.join(['./results/', filename, '_flows.npy'])
if 'DC' in flow_calc.solvermode:
solver = DCs.DC_solve
else:
solver = au.solve
if flow_calc.capacities=='copper':
solved_nodes, flows = solver(nodes, mode=''.join([mode, ' copper']),\
msg=str(flow_calc))
elif flow_calc.capacities=='q99':
h0 = au.get_quant_caps(filename=copperflow_filename)
solved_nodes, flows = solver(nodes, h0=h0, mode=mode, \
msg=str(flow_calc))
elif flow_calc.capacities=='hq99': # corresponds to half the capacities
# of the 99% quantile layout
h0 = 0.5*au.get_quant_caps(filename=copperflow_filename)
solved_nodes, flows = solver(nodes, h0=h0, mode=mode, \
msg=str(flow_calc))
elif flow_calc.capacities.endswith('q99'):
scale = float(flow_calc.capacities[0:-3])
h0 = au.get_quant_caps(filename=copperflow_filename)
solved_nodes, flows = solver(nodes, h0=h0, b=scale, mode=mode,\
msg=str(flow_calc))
else:
sys.stderr.write('The capacities must be either "copper", "q99",\
"hq99", or on the form "<number>q99"')
if flow_calc.savemode == 'full':
solved_nodes.save_nodes(filename)
try:
flows
np.save('./results/' + filename + '_flows', flows)
except NameError:
print "Flows not defined."
elif 'FCResult' in flow_calc.savemode:
result = FCResult(filename+'.pkl')
result.add_instance(solved_nodes, flows, flow_calc)
result.save_results(filename+'.pkl')
if 'flows' in flow_calc.savemode:
try:
flows
np.save('./results/' + filename + '_flows', flows)
except NameError:
print "Flows not defined."
else:
print "Results not saved, invalid savemode provided"
import aurespf.solvers as au
import figutils as fig
from FlowCalculation import FlowCalculation
from europe_plusgrid import europe_plus_Nodes
layouts = ['Europe_RU', 'Europe_NA', 'Europe_ME', 'Europe_RU_NA_ME']
modes = ['lin', 'sqr']
datapath = './results/Europeplus/'
Europe = europe_plus_Nodes(admat='./settings/Europeadmat.txt')
internal_links = [au.AtoKh(Europe)[-1][i][0]\
for i in range(len(au.AtoKh(Europe)[-1]))]
for layout in layouts:
admat = './settings/' + layout + 'admat.txt'
print admat
N = europe_plus_Nodes(admat=admat)
for mode in modes:
fc = FlowCalculation(layout, 'aHE', 'copper', mode)
filename = str(fc) + '.pkl'
internal_indices, external_indices = fig.get_internal_external_link_indices(N, internal_links)
all_TC = au.biggestpair(fig.get_data(filename, 'TC', path=datapath))
print fc.pretty_layout(), fc.pretty_solvermode()
for link_index in external_indices:
print au.AtoKh(N)[-1][link_index]
print all_TC[link_index]
def setUp(self):
self.N = europe_plus_Nodes()
from europe_plusgrid import europe_plus_Nodes
from FlowCalculation import FlowCalculation
for flow in ['lin', 'sqr']:
DC_filename = 'Europe_aHE_copper_DC_' + flow + '.npz'
F2_filename = 'Europe_aHE_copper_' + flow + '.npz'
DC_N = europe_plus_Nodes(load_filename=DC_filename)
F2_N = europe_plus_Nodes(load_filename=F2_filename)
def setUp(self):
self.N = europe_plus_Nodes()
self.model = DCs.build_DC_network(self.N)[0]
self.Nlinks = len(au.AtoKh(self.N)[-1])
self.Nnodes = len(self.N)
def make_europeplus_barplot(ydatalabel, interactive=False,\
barwidth=0.5):
""" Creates a bar plot showing the property specified by
ydatalabel in the five different layouts in the Europeplus
configuration.
"""
plt.close()
plt.rcParams['axes.color_cycle'] = color_cycle
if interactive:
plt.ion()
datapath = "./results/Europeplus/"
savepath = "./results/figures/Europeplusfigs/"
sqr_and_lin = False
if ydatalabel != 'BE':
sqr_and_lin = True
layoutlist = ['Europe',\
'Europe-RU', 'Europe-NA', 'Europe-ME', 'Europe-RU-NA-ME']
ydata_lin = []
ydata_sqr = []
ydata_lin_ext = []
ydata_sqr_ext = []
for l in layoutlist:
layout = l.replace('-', '_')
fc_string_lin = str(FlowCalculation(layout, 'aHE', 'copper', 'lin'))
fc_string_sqr = str(FlowCalculation(layout, 'aHE', 'copper', 'sqr'))
admat = "./settings/" + layout + "admat.txt"
N = europe_plus_Nodes(admat=admat)
if layout=='Europe':
internal_links = [au.AtoKh(N)[-1][i][0] \
for i in range(len(au.AtoKh(N)[-1]))]
total_mean_load = np.sum([n.mean for n in N])
if ydatalabel == 'BE':
unnormalized_data = get_data(fc_string_lin + '.pkl', \
ydatalabel, path=datapath)
ydata_lin.append(np.sum(unnormalized_data)/total_mean_load)
ylabel = "Backup energy [normalized]"
elif ydatalabel == 'BC':
unnormalized_data_lin = get_data(fc_string_lin + '.pkl',\
ydatalabel, path=datapath)
unnormalized_data_sqr = get_data(fc_string_sqr + '.pkl',\
ydatalabel, path=datapath)
ydata_lin.append(np.sum(unnormalized_data_lin)/total_mean_load)
ydata_sqr.append(np.sum(unnormalized_data_sqr)/total_mean_load)
ylabel = "Backup capacity [normalized]"
elif ydatalabel == 'TC':
internal_indices, external_indices =\
get_internal_external_link_indices(N, internal_links)
print internal_indices, external_indices
all_lin_TC = au.biggestpair(\
get_data(fc_string_lin + '.pkl', 'TC', path=datapath))
all_sqr_TC = au.biggestpair(\
get_data(fc_string_sqr + '.pkl', 'TC', path=datapath))
ydata_lin.append(\
sum([all_lin_TC[i] for i in internal_indices])/1e3)
ydata_lin_ext.append(\
sum([all_lin_TC[i] for i in external_indices])/1e3)
ydata_sqr.append(\
sum([all_sqr_TC[i] for i in internal_indices])/1e3)
ydata_sqr_ext.append(\
sum([all_sqr_TC[i] for i in external_indices])/1e3)
ylabel = "Transmission capacity [GW]" ## note the unit, this was
## obtained by /1e3
################# implement transmission capacity that only include internal european links######
index = np.array([0, 1.5, 2.5, 3.5, 5])
left = index + 0.5*barwidth
left2 = index + barwidth
ax = plt.subplot(1,1,1)
if ydatalabel=='BE':
plt.bar(left, ydata_lin, width=barwidth, color=blue)
elif ydatalabel=='BC':
plt.bar(left, ydata_lin, width=0.5*barwidth,\
color=blue, label = 'Localized flow')
plt.bar(left2, ydata_sqr, width=0.5*barwidth,\
color=red, label = 'Synchronized flow')
plt.legend()
elif ydatalabel=='TC':
plt.bar(left, np.array(ydata_lin)+np.array(ydata_lin_ext), \
width=0.5*barwidth, color=darkblue,\
label = 'External capacity: Localized flow')
plt.bar(left, np.array(ydata_lin), width=0.5*barwidth,\
color=blue, label = 'Internal capacity: Localized flow')
plt.bar(left2, np.array(ydata_sqr)+np.array(ydata_sqr_ext), \
width=0.5*barwidth, color=darkred,\
label = 'External capacity: Synchronized flow')
plt.bar(left2, np.array(ydata_sqr), width=0.5*barwidth,\
color=red, label = 'Internal capacity: Synchronized flow')
plt.legend(prop={'size':13}, loc=2)
plt.xticks(left + 0.5*barwidth, layoutlist)
plt.ylabel(ylabel)
plt.title('Copper flow')
figfilename = ydatalabel + "vslayout.pdf"
if not interactive:
plt.savefig(savepath + figfilename)
from europe_plusgrid import europe_plus_Nodes
import DCsolvers as DCs
import numpy as np
N = europe_plus_Nodes()
h0 = np.load('./results/EuropeCopperh0.npy')
#copperNodes, copperFlow = DCs.DC_solve(N, mode='linear copper verbose', msg="Solving copper flows")
#copperNodes.save_nodes("copperNodes.npz")
#np.save("./results/copper_flows.npy", copperFlow)
constrNodes_lin, constrFlow_lin = DCs.DC_solve(N, mode='linear verbose', msg="Solving constrained flows lin", h0=h0, b=0.05)
constrNodes_lin.save_nodes("Europe_aHE_0.05q99_lin.npz")
np.save("./results/Europe_aHE_0.5q99_lin_flows.npy", constrFlow_lin)
copperNodes_sqr, copperFlow_sqr = DCs.DC_solve(N, mode='square copper verbose', msg="Solving copper flows square")
copperNodes_sqr.save_nodes("Europe_aHE_copper_sqr.npz")
np.save("./results/Europe_aHE_copper_sqr_flows.npy", copperFlow_sqr)
