def normalizePop(pathX, Generation): """ Normalizes the population with the min / max IN THAT GENERATION All 3 objectives are normalized to [0,1] Parameters ---------- pathMasterRes : string path to folder where checkpoints are stored Generation : int generation to extract pathNtwRes : string path to ntw result folder Returns ------- popFinal : list normalized population """ popFinal, eps, testedPop = sFn.readCheckPoint(pathX, Generation, storeData=0) maxCosts = 0 minCosts = 0 maxCO2 = 0 minCO2 = 0 maxPrim = 0 minPrim = 0 popNorm = toolbox.clone(popFinal) for ind in popFinal: if ind.fitness.values[0] < minCosts: minCosts = ind.fitness.values[0] if ind.fitness.values[0] > maxCosts: maxCosts = ind.fitness.values[0] if ind.fitness.values[1] < minCO2: minCO2 = ind.fitness.values[1] if ind.fitness.values[1] > maxCO2: maxCO2 = ind.fitness.values[1] if ind.fitness.values[2] < minPrim: minPrim = ind.fitness.values[2] if ind.fitness.values[2] > maxPrim: maxPrim = ind.fitness.values[2] for i in range(len(popFinal)): ind = popFinal[i] NormCost = (ind.fitness.values[0] - minCosts) / (maxCosts - minCosts) NormCO2 = (ind.fitness.values[1] - minCO2) / (maxCO2 - minCO2) NormPrim = (ind.fitness.values[2] - minPrim) / (maxPrim - minPrim) popNorm[i].fitness.values = (NormCost, NormCO2, NormPrim) return popFinal
def normalizePop(pathX, Generation): """ Normalizes the population with the min / max IN THAT GENERATION All 3 objectives are normalized to [0,1] Parameters ---------- pathMasterRes : string path to folder where checkpoints are stored Generation : int generation to extract pathNtwRes : string path to ntw result folder Returns ------- popFinal : list normalized population """ popFinal, eps, testedPop = sFn.readCheckPoint(pathX, Generation, storeData = 0) maxCosts =0 minCosts =0 maxCO2 =0 minCO2 =0 maxPrim =0 minPrim =0 popNorm = toolbox.clone(popFinal) for ind in popFinal: if ind.fitness.values[0] < minCosts: minCosts = ind.fitness.values[0] if ind.fitness.values[0] > maxCosts: maxCosts = ind.fitness.values[0] if ind.fitness.values[1] < minCO2: minCO2 = ind.fitness.values[1] if ind.fitness.values[1] > maxCO2: maxCO2 = ind.fitness.values[1] if ind.fitness.values[2] < minPrim: minPrim = ind.fitness.values[2] if ind.fitness.values[2] > maxPrim: maxPrim = ind.fitness.values[2] for i in range( len( popFinal ) ): ind = popFinal[i] NormCost = (ind.fitness.values[0] - minCosts) / (maxCosts - minCosts) NormCO2 = (ind.fitness.values[1] - minCO2) / (maxCO2 - minCO2) NormPrim = (ind.fitness.values[2] - minPrim) / (maxPrim - minPrim) popNorm[i].fitness.values = (NormCost, NormCO2, NormPrim) return popFinal
def sensAnalysis(pathX, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, gen): gV = glob.globalVariables() step = gV.sensibilityStep bandwidth = sensBandwidth() os.chdir(pathX.pathMasterRes) pop, eps, testedPop = sFn.readCheckPoint(pathX, gen, 0) toolbox = base.Toolbox() os.chdir(pathX.pathRaw) buildList = sFn.extractList("Total.csv") ParetoResults = np.zeros( len(pop) ) FactorResults = np.zeros((step + 1, bandwidth.nFactors * 2)) def sensOneFactor(obj, factor_name, mini, maxi, colNumber): iniValue = getattr(obj, factor_name) index = 0 for delta in np.arange(mini, maxi + 1E-5, (maxi-mini)/step): FactorResults[index][colNumber + 0] = delta if abs(delta) > 1E-10: setattr(obj, factor_name, iniValue * (1+delta)) newpop = [] for ind in pop: newInd = toolbox.clone(ind) newpop.append(newInd) (costs, CO2, prim) = eI.evalInd(newInd, buildList, pathX, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, obj) newInd.fitness.values = (costs, CO2, prim) selection = sel.selectPareto(newpop) for i in range(len(newpop)): if newpop[i] in selection: ParetoResults[i] += 1 FactorResults[index][colNumber + 1] = len(newpop) - len(selection) index += 1 setattr(obj, factor_name, iniValue) sensOneFactor(gV, 'ELEC_PRICE', bandwidth.minElec, bandwidth.maxElec, 0) sensOneFactor(gV, 'NG_PRICE', bandwidth.minNG, bandwidth.maxNG, 2) sensOneFactor(gV, 'BG_PRICE', bandwidth.minBG, bandwidth.maxBG, 4) indexSensible = FactorResults.argmax()%(2*bandwidth.nFactors) if indexSensible == 1: mostSensitive = 'Electricity price' elif indexSensible == 3: mostSensitive = 'NG price' else: mostSensitive = 'BG price' return ParetoResults, FactorResults, mostSensitive
def plot_pareto_scenarios(generations, headers, relative, savelocation): xs =[] ys =[] zs =[] fig = plt.figure() counter = 0 for header in headers: pathX = sFn.pathX(header) pop, eps, testedPop = sFn.readCheckPoint(pathX, generations[counter], 0) Area_buildings = pd.read_csv(pathX.pathRaw+'//'+'Total.csv',usecols=['Af']).values.sum() [x, y, z] = map(np.array, zip( *[ind.fitness.values for ind in pop] ) ) ax = fig.add_subplot(111) if relative == True: z[:] = [a / Area_buildings for a in z] x[:] = [b / Area_buildings for b in x] y[:] = [c / Area_buildings for c in y] xs.extend(x) ys.extend(y) zs.extend(z) counter +=1 if relative == True: TAC = 'TAC [EU/m2.yr]' CO2 = 'CO2 [kg-CO2/m2.yr]' PEN = 'PEN [MJ/m2.yr]' ax.set_ylim([10,50]) finallocation = savelocation+"pareto_m2.png" else: var = 1000000 zs[:] = [x / var for x in zs] xs[:] = [x / var for x in xs] ys[:] = [x / var for x in ys] TAC = 'TAC [Mio EU/yr]' CO2 = 'CO2 [kton-CO2/yr]' PEN = 'PEN [TJ/yr]' ax.set_xlim([2.5,7.0]) finallocation = savelocation+"pareto.png" cm = plt.get_cmap('jet') cNorm = matplotlib.colors.Normalize(vmin=min(zs), vmax=max(zs)) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) ax.scatter(xs, ys, c=scalarMap.to_rgba(zs), s=50, alpha =0.8) ax.set_xlabel(TAC) ax.set_ylabel(CO2) scalarMap.set_array(zs) fig.colorbar(scalarMap, label=PEN) plt.grid(True) plt.rcParams['figure.figsize'] = (6,4) plt.rcParams.update({'font.size':12}) plt.gcf().subplots_adjust(bottom=0.15) plt.savefig(finallocation) plt.clf()
def normalizePop(locator, Generation): """ Normalizes the population with the min / max IN THAT GENERATION All 3 objectives are normalized to [0,1] :param locator: inputlocator set to scenario :param Generation: generation to extract :type locator: string :type Generation: int :return: normalized population :rtype: list """ popFinal, eps, testedPop, ntwList, fitness = sFn.readCheckPoint( locator, Generation, storeData=0) maxCosts = 0 minCosts = 0 maxCO2 = 0 minCO2 = 0 maxPrim = 0 minPrim = 0 popNorm = toolbox.clone(popFinal) for ind in popFinal: if ind.fitness.values[0] < minCosts: minCosts = ind.fitness.values[0] if ind.fitness.values[0] > maxCosts: maxCosts = ind.fitness.values[0] if ind.fitness.values[1] < minCO2: minCO2 = ind.fitness.values[1] if ind.fitness.values[1] > maxCO2: maxCO2 = ind.fitness.values[1] if ind.fitness.values[2] < minPrim: minPrim = ind.fitness.values[2] if ind.fitness.values[2] > maxPrim: maxPrim = ind.fitness.values[2] for i in range(len(popFinal)): ind = popFinal[i] NormCost = (ind.fitness.values[0] - minCosts) / (maxCosts - minCosts) NormCO2 = (ind.fitness.values[1] - minCO2) / (maxCO2 - minCO2) NormPrim = (ind.fitness.values[2] - minPrim) / (maxPrim - minPrim) popNorm[i].fitness.values = (NormCost, NormCO2, NormPrim) return popFinal
def plot_buildings_connected_scenarios(scenarios, generations, headers): counter = 0 data = [1, 2, 3, 4] colors = ['b', 'r', 'y', 'c'] fig = plt.figure() for header in headers: pathX = sFn.pathX(header) BuildCon = [] BuildCon2 = [] for i in range(generations[counter]): i += 1 pop, eps, testedPop, ntwList, fitness = sFn.readCheckPoint( pathX, i, 0) buildCon = [] buildCon2 = [] for ind in pop: buildCon.extend([np.average(ind[21:]) * 100]) buildCon2.append([np.average(ind[21:]) * 100]) BuildCon.extend(buildCon) BuildCon2.append(np.average(buildCon2)) data[counter] = BuildCon # individual lines per generation xList = [1 + x for x in range(len(BuildCon2))] ax = fig.add_subplot(111) ax.plot(xList, BuildCon2, colors[counter], label=scenarios) ax.set_xlim(1, generations[counter]) ax.set_ylabel('Percentage of buildings connected (%)') ax.set_xlabel('Generation No.') #ax.set_xticks(np.arange(1,generations[counter]+1,2)) counter += 1 plt.legend(scenarios, loc='upper left') plt.rcParams['figure.figsize'] = (6, 4) plt.rcParams['font.size'] = 12 plt.show() # box plot with all data) fig = plt.figure(figsize=(6, 4)) plt.rcParams['font.size'] = 12 plt.boxplot(data, 1, 'rs', 0) plt.yticks([1, 2, 3, 4], scenarios) plt.xlabel("Percentage of buildings connected (%)") plt.show() return data
def plot_buildings_connected_scenarios(scenarios, generations, headers): counter =0 data = [1,2,3,4] colors = ['b','r','y','c'] fig = plt.figure() for header in headers: pathX = sFn.pathX(header) BuildCon = [] BuildCon2 = [] for i in range(generations[counter]): i += 1 pop, eps, testedPop = sFn.readCheckPoint(pathX, i, 0) buildCon = [] buildCon2 = [] for ind in pop: buildCon.extend([np.average(ind[21:])*100]) buildCon2.append([np.average(ind[21:])*100]) BuildCon.extend(buildCon) BuildCon2.append(np.average(buildCon2)) data[counter] = BuildCon # individual lines per generation xList = [ 1 + x for x in range(len(BuildCon2)) ] ax = fig.add_subplot(111) ax.plot(xList, BuildCon2, colors[counter], label=scenarios) ax.set_xlim(1,generations[counter]) ax.set_ylabel('Percentage of buildings connected (%)') ax.set_xlabel('Generation No.') #ax.set_xticks(np.arange(1,generations[counter]+1,2)) counter +=1 plt.legend(scenarios, loc='upper left') plt.rcParams['figure.figsize'] = (6,4) plt.rcParams['font.size'] = 12 plt.show() # box plot with all data) fig = plt.figure(figsize = (6,4)) plt.rcParams['font.size'] = 12 plt.boxplot(data,1,'rs',0) plt.yticks([1, 2, 3, 4], scenarios) plt.xlabel("Percentage of buildings connected (%)") plt.show() return data
def buildingConnection(generation, locator): BuildCon = [] nInd = [] for i in range(generation): i += 1 pop, eps, testedPop, ntwList, fitness = sFn.readCheckPoint( locator, i, 0) buildCon = [] for ind in pop: buildCon.append(np.average(ind[21:])) BuildCon.append(np.average(buildCon)) nInd.append(len(pop)) # Plotting the number of connected buildings vs the generations fig = plt.figure() ax = fig.add_subplot(111, xlim=(1, generation), ylim=(0.1)) xList = [1 + x for x in range(len(BuildCon))] ax.plot(xList, BuildCon) ax.set_xlim(1, generation) ax.set_ylabel('Averaged building connection') ax.set_xlabel('Generation') ax.set_xticks(np.arange(1, generation + 1, 2)) plt.show() # Plotting the number of individuals vs the generations fig = plt.figure() ax = fig.add_subplot(111, xlim=(1, generation)) xList = [1 + x for x in range(len(nInd))] ax.plot(xList, nInd) ax.set_xlim(1, generation) ax.set_ylabel('Number of individuals in the Pareto front') ax.set_xlabel('Generation') ax.set_xticks(np.arange(1, generation + 1, 2)) plt.show() return BuildCon, nInd
def buildingConnection(generation, pathX): BuildCon = [] nInd = [] for i in range(generation): i += 1 pop, eps, testedPop = sFn.readCheckPoint(pathX, i, 0) buildCon = [] for ind in pop: buildCon.append(np.average(ind[21:])) BuildCon.append(np.average(buildCon)) nInd.append(len(pop)) # Plotting the number of connected buildings vs the generations fig = plt.figure() ax = fig.add_subplot(111, xlim = (1,generation), ylim = (0.1)) xList = [ 1 + x for x in range(len(BuildCon)) ] ax.plot(xList, BuildCon) ax.set_xlim(1,generation) ax.set_ylabel('Averaged building connection') ax.set_xlabel('Generation') ax.set_xticks(np.arange(1,generation+1,2)) plt.show() # Plotting the number of individuals vs the generations fig = plt.figure() ax = fig.add_subplot(111, xlim = (1,generation)) xList = [ 1 + x for x in range(len(nInd)) ] ax.plot(xList, nInd) ax.set_xlim(1,generation) ax.set_ylabel('Number of individuals in the Pareto front') ax.set_xlabel('Generation') ax.set_xticks(np.arange(1,generation+1,2)) plt.show() return BuildCon, nInd
def normalize_epsIndicator(locator, generation): """ Calculates the normalized epsilon indicator For all generations, the population are normalized with regards to the min / max over ALL generations :param locator: inputlocator set to scenario :param generation: generation up to which data are extracted :type locator: string :type generation: int :return: epsAll, normalized epsilon indicator from the beginning of the master to generation :rtype: list """ epsAll = [] allPop = [] allPopNorm = [] # Load the population i = 1 while i < generation + 1: pop, eps, testedPop, ntwList, fitness = sFn.readCheckPoint(locator, i, storeData=0) i += 1 allPop.append(pop) # Find the max and min maxCosts = 0 minCosts = 0 maxCO2 = 0 minCO2 = 0 maxPrim = 0 minPrim = 0 for i in range(generation): popScaned = allPop[i] for ind in popScaned: if ind.fitness.values[0] < minCosts: minCosts = ind.fitness.values[0] if ind.fitness.values[0] > maxCosts: maxCosts = ind.fitness.values[0] if ind.fitness.values[1] < minCO2: minCO2 = ind.fitness.values[1] if ind.fitness.values[1] > maxCO2: maxCO2 = ind.fitness.values[1] if ind.fitness.values[2] < minPrim: minPrim = ind.fitness.values[2] if ind.fitness.values[2] > maxPrim: maxPrim = ind.fitness.values[2] # Normalize for k in range(generation): popScaned = allPop[k] popNorm = toolbox.clone(popScaned) for i in range(len(popScaned)): ind = popScaned[i] NormCost = (ind.fitness.values[0] - minCosts) / (maxCosts - minCosts) NormCO2 = (ind.fitness.values[1] - minCO2) / (maxCO2 - minCO2) NormPrim = (ind.fitness.values[2] - minPrim) / (maxPrim - minPrim) popNorm[i].fitness.values = (NormCost, NormCO2, NormPrim) allPopNorm.append(popNorm) # Compute the eps indicator for i in range(generation - 1): frontOld = allPopNorm[i] frontNew = allPopNorm[i + 1] epsAll.append(eI.epsIndicator(frontOld, frontNew)) return epsAll
def normalize_epsIndicator(pathX, generation): """ Calculates the normalized epsilon indicator For all generations, the populations are normalized with regards to the min / max over ALL generations Parameters ---------- pathMasterRes : string path to folder where checkpoints are stored generation : int generation up to which data are extracted pathNtwRes : string path to ntw result folder Returns ------- epsAll : list normalized epsilon indicator from the beginning of the EA to generation """ epsAll = [] allPop = [] allPopNorm = [] # Load the populations i = 1 while i < generation+1: pop, eps, testedPop = sFn.readCheckPoint(pathX, i, storeData = 0) i+=1 allPop.append(pop) # Find the max and min maxCosts =0 minCosts =0 maxCO2 =0 minCO2 =0 maxPrim =0 minPrim =0 for i in range(generation): popScaned = allPop[i] for ind in popScaned: if ind.fitness.values[0] < minCosts: minCosts = ind.fitness.values[0] if ind.fitness.values[0] > maxCosts: maxCosts = ind.fitness.values[0] if ind.fitness.values[1] < minCO2: minCO2 = ind.fitness.values[1] if ind.fitness.values[1] > maxCO2: maxCO2 = ind.fitness.values[1] if ind.fitness.values[2] < minPrim: minPrim = ind.fitness.values[2] if ind.fitness.values[2] > maxPrim: maxPrim = ind.fitness.values[2] # Normalize for k in range(generation): popScaned = allPop[k] popNorm = toolbox.clone(popScaned) for i in range( len( popScaned ) ): ind = popScaned[i] NormCost = (ind.fitness.values[0] - minCosts) / (maxCosts - minCosts) NormCO2 = (ind.fitness.values[1] - minCO2) / (maxCO2 - minCO2) NormPrim = (ind.fitness.values[2] - minPrim) / (maxPrim - minPrim) popNorm[i].fitness.values = (NormCost, NormCO2, NormPrim) allPopNorm.append(popNorm) # Compute the eps indicator for i in range(generation-1): frontOld = allPopNorm[i] frontNew = allPopNorm[i+1] epsAll.append(eI.epsIndicator(frontOld, frontNew)) return epsAll
def normalize_epsIndicator(pathX, generation): """ Calculates the normalized epsilon indicator For all generations, the populations are normalized with regards to the min / max over ALL generations Parameters ---------- pathMasterRes : string path to folder where checkpoints are stored generation : int generation up to which data are extracted pathNtwRes : string path to ntw result folder Returns ------- epsAll : list normalized epsilon indicator from the beginning of the EA to generation """ epsAll = [] allPop = [] allPopNorm = [] # Load the populations i = 1 while i < generation + 1: pop, eps, testedPop = sFn.readCheckPoint(pathX, i, storeData=0) i += 1 allPop.append(pop) # Find the max and min maxCosts = 0 minCosts = 0 maxCO2 = 0 minCO2 = 0 maxPrim = 0 minPrim = 0 for i in range(generation): popScaned = allPop[i] for ind in popScaned: if ind.fitness.values[0] < minCosts: minCosts = ind.fitness.values[0] if ind.fitness.values[0] > maxCosts: maxCosts = ind.fitness.values[0] if ind.fitness.values[1] < minCO2: minCO2 = ind.fitness.values[1] if ind.fitness.values[1] > maxCO2: maxCO2 = ind.fitness.values[1] if ind.fitness.values[2] < minPrim: minPrim = ind.fitness.values[2] if ind.fitness.values[2] > maxPrim: maxPrim = ind.fitness.values[2] # Normalize for k in range(generation): popScaned = allPop[k] popNorm = toolbox.clone(popScaned) for i in range(len(popScaned)): ind = popScaned[i] NormCost = (ind.fitness.values[0] - minCosts) / (maxCosts - minCosts) NormCO2 = (ind.fitness.values[1] - minCO2) / (maxCO2 - minCO2) NormPrim = (ind.fitness.values[2] - minPrim) / (maxPrim - minPrim) popNorm[i].fitness.values = (NormCost, NormCO2, NormPrim) allPopNorm.append(popNorm) # Compute the eps indicator for i in range(generation - 1): frontOld = allPopNorm[i] frontNew = allPopNorm[i + 1] epsAll.append(eI.epsIndicator(frontOld, frontNew)) return epsAll
def sensAnalysis(locator, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, gen): """ :param locator: path to input locator :param extraCosts: costs calculated before optimization of specific energy services (process heat and electricity) :param extraCO2: green house gas emissions calculated before optimization of specific energy services (process heat and electricity) :param extraPrim: primary energy calculated before optimization ofr specific energy services (process heat and electricity) :param solarFeat: solar features call to class :param ntwFeat: network features call to class :param gen: generation on which the sensitivity analysis is performed :type locator: string :type extraCosts: float :type extraCO2: float :type extraPrim: float :type solarFeat: class :type ntwFeat: class :type gen: int :return: returns the most sensitive parameter among the group provided :rtype: string """ gV = glob.GlobalVariables() step = gV.sensibilityStep bandwidth = sensBandwidth() os.chdir(locator.get_optimization_master_results_folder()) pop, eps, testedPop, ntwList, fitness = sFn.readCheckPoint(locator, gen, 0) toolbox = base.Toolbox() total_demand = pd.read_csv(locator.get_total_demand()) buildList = total_demand.Name.values FactorResults = np.zeros((step + 1, bandwidth.nFactors * 2)) def sensOneFactor(obj, factor_name, mini, maxi, colNumber): iniValue = getattr(obj, factor_name) index = 0 for delta in np.arange(mini, maxi + 1E-5, (maxi-mini)/step): FactorResults[index][colNumber + 0] = delta if abs(delta) > 1E-10: setattr(obj, factor_name, iniValue * (1+delta)) newpop = [] for ind in pop: newInd = toolbox.clone(ind) newpop.append(newInd) (costs, CO2, prim) = eI.evaluation_main(newInd, buildList, locator, solarFeat, ntwFeat, obj,, newInd.fitness.values = (costs, CO2, prim) index += 1 setattr(obj, factor_name, iniValue) sensOneFactor(gV, 'ELEC_PRICE', bandwidth.minElec, bandwidth.maxElec, 0) sensOneFactor(gV, 'NG_PRICE', bandwidth.minNG, bandwidth.maxNG, 2) sensOneFactor(gV, 'BG_PRICE', bandwidth.minBG, bandwidth.maxBG, 4) indexSensible = FactorResults.argmax()%(2*bandwidth.nFactors) if indexSensible == 1: mostSensitive = 'Electricity price' elif indexSensible == 3: mostSensitive = 'NG price' else: mostSensitive = 'BG price' print FactorResults print mostSensitive return mostSensitive gen = 4 def run_as_script(scenario_path=None): import cea.globalvar import pandas as pd import cea.optimization.distribution.network_opt_main as network_opt from cea.optimization.preprocessing.preprocessing_main import preproccessing gv = cea.globalvar.GlobalVariables() if scenario_path is None: scenario_path = gv.scenario_reference locator = cea.inputlocator.InputLocator(scenario_path=scenario_path) total_demand = pd.read_csv(locator.get_total_demand()) building_names = total_demand.Name.values gv.num_tot_buildings = total_demand.Name.count() weather_file = locator.get_default_weather() extraCosts, extraCO2, extraPrim, solarFeat = preproccessing(locator, total_demand, building_names, weather_file, gv) ntwFeat = network_opt.network_opt_main() sensAnalysis(locator, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, gen) print 'sensitivity analysis succeeded' if __name__ == '__main__': run_as_script(r'C:\reference-case-zug\baseline')
def plot_pareto_scenarios(locator, generations, relative): ''' This function plots a pareto curve for a certan checkpoint number. The checkpoint number is equivalent to the Generation number to be mapped :param locator: :param generations: :param headers: :param relative: :param savelocation: :return: ''' # create local variables xs = [] ys = [] zs = [] fig = plt.figure() savelocation = locator.get_optimization_plots_folder() # read the checkpoint counter = 0 #for scenario in scenarios: pop, eps, testedPop, ntwList, fitness = sFn.readCheckPoint( locator, generations, 0) # get floor area of buildings and estimate relative parameters Area_buildings = pd.read_csv(locator.get_total_demand(), usecols=['Af_m2']).values.sum() [x, y, z] = map(np.array, zip(*[ind.fitness.values for ind in pop])) ax = fig.add_subplot(111) if relative == True: z[:] = [a / Area_buildings for a in z] x[:] = [b / Area_buildings for b in x] y[:] = [c / Area_buildings for c in y] xs.extend(x) ys.extend(y) zs.extend(z) counter += 1 if relative == True: TAC = 'TAC [EU/m2.yr]' CO2 = 'CO2 [kg-CO2/m2.yr]' PEN = 'PEN [MJ/m2.yr]' ax.set_ylim([10, 50]) finallocation = os.path.join(savelocation, "pareto_m2.png") else: var = 1000000 zs[:] = [x / var for x in zs] xs[:] = [x / var for x in xs] ys[:] = [x / var for x in ys] TAC = 'TAC [Mio EU/yr]' CO2 = 'CO2 [kton-CO2/yr]' PEN = 'PEN [TJ/yr]' ax.set_xlim([2.5, 7.0]) finallocation = os.path.join(savelocation, "pareto.png") cm = plt.get_cmap('jet') cNorm = matplotlib.colors.Normalize(vmin=min(zs), vmax=max(zs)) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) ax.scatter(xs, ys, c=scalarMap.to_rgba(zs), s=50, alpha=0.8) ax.set_xlabel(TAC) ax.set_ylabel(CO2) scalarMap.set_array(zs) fig.colorbar(scalarMap, label=PEN) plt.grid(True) plt.rcParams['figure.figsize'] = (6, 4) plt.rcParams.update({'font.size': 12}) plt.gcf().subplots_adjust(bottom=0.15) plt.savefig(finallocation) plt.clf()
def sensAnalysis(locator, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, gen): """ :param locator: path to input locator :param extraCosts: costs calculated before optimization of specific energy services (process heat and electricity) :param extraCO2: green house gas emissions calculated before optimization of specific energy services (process heat and electricity) :param extraPrim: primary energy calculated before optimization ofr specific energy services (process heat and electricity) :param solarFeat: solar features call to class :param ntwFeat: network features call to class :param gen: generation on which the sensitivity analysis is performed :type locator: string :type extraCosts: float :type extraCO2: float :type extraPrim: float :type solarFeat: class :type ntwFeat: class :type gen: int :return: returns the most sensitive parameter among the group provided :rtype: string """ gV = glob.GlobalVariables() step = gV.sensibilityStep bandwidth = sensBandwidth() os.chdir(locator.get_optimization_master_results_folder()) pop, eps, testedPop, ntwList, fitness = sFn.readCheckPoint(locator, gen, 0) toolbox = base.Toolbox() total_demand = pd.read_csv(locator.get_total_demand()) buildList = total_demand.Name.values FactorResults = np.zeros((step + 1, bandwidth.nFactors * 2)) def sensOneFactor(obj, factor_name, mini, maxi, colNumber): iniValue = getattr(obj, factor_name) index = 0 for delta in np.arange(mini, maxi + 1E-5, (maxi - mini) / step): FactorResults[index][colNumber + 0] = delta if abs(delta) > 1E-10: setattr(obj, factor_name, iniValue * (1 + delta)) newpop = [] for ind in pop: newInd = toolbox.clone(ind) newpop.append(newInd) (costs, CO2, prim) = eI.evaluation_main( newInd, buildList, locator, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, obj) newInd.fitness.values = (costs, CO2, prim) index += 1 setattr(obj, factor_name, iniValue) sensOneFactor(gV, 'ELEC_PRICE', bandwidth.minElec, bandwidth.maxElec, 0) sensOneFactor(gV, 'NG_PRICE', bandwidth.minNG, bandwidth.maxNG, 2) sensOneFactor(gV, 'BG_PRICE', bandwidth.minBG, bandwidth.maxBG, 4) indexSensible = FactorResults.argmax() % (2 * bandwidth.nFactors) if indexSensible == 1: mostSensitive = 'Electricity price' elif indexSensible == 3: mostSensitive = 'NG price' else: mostSensitive = 'BG price' print FactorResults print mostSensitive return mostSensitive
def sensAnalysis(pathX, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, gen): gV = glob.globalVariables() step = gV.sensibilityStep bandwidth = sensBandwidth() os.chdir(pathX.pathMasterRes) pop, eps, testedPop = sFn.readCheckPoint(pathX, gen, 0) toolbox = base.Toolbox() os.chdir(pathX.pathRaw) buildList = sFn.extractList("Total.csv") ParetoResults = np.zeros(len(pop)) FactorResults = np.zeros((step + 1, bandwidth.nFactors * 2)) def sensOneFactor(obj, factor_name, mini, maxi, colNumber): iniValue = getattr(obj, factor_name) index = 0 for delta in np.arange(mini, maxi + 1E-5, (maxi - mini) / step): FactorResults[index][colNumber + 0] = delta if abs(delta) > 1E-10: setattr(obj, factor_name, iniValue * (1 + delta)) newpop = [] for ind in pop: newInd = toolbox.clone(ind) newpop.append(newInd) (costs, CO2, prim) = eI.evalInd(newInd, buildList, pathX, extraCosts, extraCO2, extraPrim, solarFeat, ntwFeat, obj) newInd.fitness.values = (costs, CO2, prim) selection = sel.selectPareto(newpop) for i in range(len(newpop)): if newpop[i] in selection: ParetoResults[i] += 1 FactorResults[index][colNumber + 1] = len(newpop) - len(selection) index += 1 setattr(obj, factor_name, iniValue) sensOneFactor(gV, 'ELEC_PRICE', bandwidth.minElec, bandwidth.maxElec, 0) sensOneFactor(gV, 'NG_PRICE', bandwidth.minNG, bandwidth.maxNG, 2) sensOneFactor(gV, 'BG_PRICE', bandwidth.minBG, bandwidth.maxBG, 4) indexSensible = FactorResults.argmax() % (2 * bandwidth.nFactors) if indexSensible == 1: mostSensitive = 'Electricity price' elif indexSensible == 3: mostSensitive = 'NG price' else: mostSensitive = 'BG price' return ParetoResults, FactorResults, mostSensitive