def GetConfig(path):
cfg = configparser.ConfigParser()
cfg.read(path)
name = cfg.get('Project', 'name')
setup = cfg.get('Project', 'setup')
scenario_count = cfg.get('Project', 'scenario_count')
scenarios = []
for i in range(int(scenario_count)):
scen = Scenario.Scenario('scenario_' + str(i))
scen.SetScenario(cfg)
scenarios.append(scen)
with open(join(info_dir,setup), 'r') as setup:
setup_file = setup.read()
config = {
'name' : name,
'setup' : setup_file,
'scenario_count' : scenario_count,
'scenarios' : scenarios
}
return config
def run(self):
filename = sys.argv[1].decode("utf-8") if len(sys.argv) > 1 else None
if not filename:
filename = os.path.join(
os.path.dirname(sys.argv[0].decode("utf-8")), "config.yaml")
with open(filename, "r") as f:
config = yaml.safe_load(f)
root_path = os.path.dirname(filename.encode("utf-8"))
(w, h) = (config.get("screen").get("size")[0],
config.get("screen").get("size")[1])
(x, y) = (w / 2, h / 2)
Media.Music.init()
pygame.init()
# pygame.display.set_mode((w, h),pygame.FULLSCREEN,32)
pygame.display.set_mode((w, h), pygame.DOUBLEBUF, 32)
screen = pygame.display.get_surface()
pygame.display.set_caption(
os.path.basename(os.path.dirname(filename.encode("utf-8"))))
pygame.display.update()
image_cache = Media.ImageCache(screen)
while True:
scenario = Scenario.Scenario(root_path, config)
self.title(scenario, screen, image_cache)
self.execute_scenario(scenario, screen, image_cache)
def test_scenario_getSteps(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario = Scenario.Scenario(3, "scn", steps, control_words)
self.assertEqual(scenario.get_steps(), [scenario.steps[0]])
def test_scenario_init(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario = Scenario.Scenario(3, "scn", steps, control_words)
self.assertEqual(scenario.id, 3)
self.assertEqual(scenario.name, "scn")
self.assertEqual(scenario.steps, steps)
def __init__(self, f, cash=0):
self.family = f # ?
self.cash = cash # ?
self.ritems = []
self.S = Scenario(f)
self.inflation = 1.03
# Make our Summary 'columns'
RSummary("Inc")
RSummary("Exp")
RSummary("Inv")
def test_scenario_addStep(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario = Scenario.Scenario(3, "scn", steps, control_words)
scenario.add_step("act", "nod")
self.assertEqual(scenario.steps[1].action.description, ["act"])
self.assertEqual(scenario.steps[1].node.description, ["nod"])
def create_scenarios(self):
for pathId in range(0, len(self.pathList)):
scenario = Scenario(pathId + 1, '', [], self.control_words)
for edge in self.pathList[pathId]:
scenario.add_step(edge.label,
self.get_node_label(edge.destinationNode))
self.scenariosList.append(scenario)
def test_scenario_get_id(self):
control_words = ControllWords.ControlWords(Output.Output())
steps = [Step.Step(7, "abc\n\code: ghi", "def\n\code:jkl", control_words)]
scenario1 = Scenario.Scenario(1, "scn", steps, control_words)
scenario9 = Scenario.Scenario(9, "scn", steps, control_words)
scenario10 = Scenario.Scenario(10, "scn", steps, control_words)
scenario99 = Scenario.Scenario(99, "scn", steps, control_words)
scenario100 = Scenario.Scenario(100, "scn", steps, control_words)
scenario999 = Scenario.Scenario(999, "scn", steps, control_words)
scenario1000 = Scenario.Scenario(1000, "scn", steps, control_words)
scenario9999 = Scenario.Scenario(9999, "scn", steps, control_words)
self.assertEqual(scenario1.get_id_str(), '0001')
self.assertEqual(scenario9.get_id_str(), '0009')
self.assertEqual(scenario10.get_id_str(), '0010')
self.assertEqual(scenario99.get_id_str(), '0099')
self.assertEqual(scenario100.get_id_str(), '0100')
self.assertEqual(scenario999.get_id_str(), '0999')
self.assertEqual(scenario1000.get_id_str(), '1000')
self.assertEqual(scenario9999.get_id_str(), '9999')
def solve(self):
""" Run storageVET
Returns: the Results class
"""
starts = time.time()
if Params.storagevet_requirement_check():
for key, value in self.case_dict.items():
run = Scenario.Scenario(value)
run.add_technology()
run.add_services()
run.init_financials(value.Finance)
run.add_control_constraints()
run.optimize_problem_loop()
Result.add_instance(
key, run) # cost benefit analysis is in the Result class
Result.sensitivity_summary()
ends = time.time()
print("Full runtime: " + str(ends - starts)) if self.verbose else None
return Result
config = yaml.safe_load(f)
root_path = os.path.dirname(filename.encode("utf-8"))
(w, h) = (config.get("screen").get("size")[0],
config.get("screen").get("size")[1])
(x, y) = (w / 2, h / 2)
Media.Music.init()
pygame.init()
# pygame.display.set_mode((w, h),pygame.FULLSCREEN,32)
pygame.display.set_mode((w, h), pygame.DOUBLEBUF, 32)
screen = pygame.display.get_surface()
pygame.display.set_caption(
os.path.basename(os.path.dirname(filename.encode("utf-8"))))
pygame.display.update()
image_cache = Media.ImageCache(screen)
while True:
scenario = Scenario.Scenario(root_path, config)
self.title(scenario, screen, image_cache)
self.execute_scenario(scenario, screen, image_cache)
if 0:
scenario = Scenario.Scenario()
for f in scenario.run():
print(f)
else:
gui = GUI()
gui.run()
#!/usr/bin/env python
import Scenario
import Perso
import utils as u
if __name__ == "__main__":
u.clear()
u.splash()
c = input("o-]===> ")
u.clear()
if c == "1":
print("Mode non disponible")
elif c == "3":
pass
else:
u.game_init()
Scenario.Scenario(Perso.Perso(), 0)
from Tools import *
from Scenario import *
from NSGA import *
from Evolution import *
import matplotlib.pyplot as plt
tool_box = Tools()
flow_data = tool_box.read_flow_data_from_txt()
loc_data = tool_box.read_loc_data_from_txt()
time_data = tool_box.read_slot_data_from_txt()
scenario = Scenario(flow_data, loc_data, time_data)
# scenario.generate_initial_solution()
print 'scenario generated'
problem = NSGA_problem(scenario)
evolve = Evolution(problem, 50, 100)
selected_individuals = evolve.evolve()
f = open('gene.txt', 'w')
for i in selected_individuals:
s = ''
for g in i.features:
s = s + ',' + str(g)
f.write(s + '\n')
f.close()
x = [problem.f1(i) for i in selected_individuals]
y = [problem.f2(i) for i in selected_individuals]
print x, y
plt.plot(x, y, 'ro')
plt.show()
num=45).astype(int)
# The number of possible budgets that can be allocated to each subcampaign
number_of_budgets = 11
time_horizon = 300
regret = []
for e in range(0, number_of_experiments):
print('\n')
print('Starting experiment', e + 1)
logging.info("\n" + "Starting experiment " + str(e + 1))
advertising_scenarios = [
Scenario(daily_budgets=daily_budgets, campaign=0, var=0),
Scenario(daily_budgets=daily_budgets, campaign=1, var=0),
Scenario(daily_budgets=daily_budgets, campaign=2, var=0)
]
advertising_learners = [
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets])
]
pricing_scenarios = [
CustomizablePricingScenario(sex=1, under_30=1),
CustomizablePricingScenario(sex=1, under_30=0),
CustomizablePricingScenario(sex=0)
]
def main(cm_file, cdis_file, output_dir):
#------------------------------ BEGIN LOADING ------------------------------#
print(">>>: Carregando cenário")
scenario = Scenario.Scenario()
scenario.read(cm_file, cdis_file)
scenario_name = os.path.splitext(os.path.basename(cm_file))[0]
cdis_info_name = os.path.splitext(os.path.basename(cdis_file))[0]
scenario_path = os.path.join(output_dir, scenario_name + cdis_info_name)
result_log_path = os.path.join(scenario_path, "result_log.csv")
result_fig_path = os.path.join(scenario_path, "figures")
result_res_path = os.path.join(scenario_path, "results")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if not os.path.exists(scenario_path):
os.makedirs(scenario_path)
else:
shutil.rmtree(scenario_path)
os.makedirs(scenario_path)
if not os.path.exists(result_fig_path):
os.makedirs(result_fig_path)
if not os.path.exists(result_res_path):
os.makedirs(result_res_path)
Visualization.visualize(scenario, scenario.cm.ceList, result_fig_path,
"00")
#------------------------------ END LOADING ------------------------------#
with open(result_log_path, "w+") as resultLogFile:
resultLogFile.write(
"Data_e_Hora;Nome_do_cenário;Caminho_do_arquivo_do_cenário;Nome_das_informações_do_CDIS;Caminho_do_arquivo_das_informações_do_cdis;Tempo_de_execução\n"
)
resultLogFile.write(datetime.now().strftime("%d/%m/%Y %H:%M:%S") +
";" + scenario_name + ";" + cm_file + ";" +
cdis_info_name + ";" + cdis_file)
startTime = time.time()
totalIteration = len(scenario.cdisList)
for iteration in range(0, totalIteration):
print("\n>>>: Resolvendo cenário com informações do CDIS=" +
str(iteration) + "/" + str(totalIteration))
scenario.updateChannels(scenario.cdisList[iteration].channelList)
#------------------------------ BEGIN PREPROCESSING ------------------------------#
print(">>>: Pré-processando entrada")
(allCEVarList, ceVarList, ceByChannelVarList,
interferenceList) = PreProcessing.process(scenario)
#------------------------------ END PREPROCESSING ------------------------------#
#------------------------------ BEGIN SOLVER ------------------------------#
print(">>>: Criando modelo")
model = gb.Model('cognitive-networks')
print(">>>: Adicionando variáveis ao modelo")
allCEModelVarList = []
for ceVar in allCEVarList:
allCEModelVarList.append(
model.addVar(name=ceVar.name, vtype=gb.GRB.BINARY))
ceByChannelModelVarList = []
for ceByChannelVar in ceByChannelVarList:
ceByChannelModelVarList.append(
model.addVar(name=ceByChannelVar.name))
model.update()
ceModelVarList = []
for ceVars in ceVarList:
modelVarList = []
for ceVar in ceVars:
modelVarList.append(model.getVarByName(ceVar.name))
ceModelVarList.append(modelVarList)
print(">>>: Adicionando restrições ao modelo")
ceId = 0
for ceModelVars in ceModelVarList:
model.addConstr(gb.quicksum(ceModelVars), gb.GRB.EQUAL, 1,
"Única_configuração_para_CE_" + str(ceId))
ceId += 1
interferenceModelVarList = []
for interference in interferenceList:
ceVar = interference[0]
ceTotalInterference = interference[1]
ceInterferenceList = interference[2]
if (ceTotalInterference > 0):
interferenceModelVar = model.addVar(
name="Interferência-devido-" + ceVar.name)
interferenceModelVarList.append(interferenceModelVar)
model.update()
ceInterferenceModelVarList = []
for ceInterference in ceInterferenceList:
ceInterferenceModelVarList.append(
ceInterference * model.getVarByName(ceVar.name))
model.addConstr(
gb.quicksum(ceInterferenceModelVarList), gb.GRB.EQUAL,
interferenceModelVar,
"Interferência_provocada_por_" + ceVar.name)
model.addConstr(
interferenceModelVar, gb.GRB.LESS_EQUAL,
args.max_interference,
"Máximo_de_interferência_tolerada_de_" + ceVar.name)
for ceByChannelModelVar in ceByChannelModelVarList:
ceByChannelVarNameSplit = ceByChannelModelVar.varName.split(
'_')
channel = int(ceByChannelVarNameSplit[3])
filtredCEModelVarList = PreProcessing.filterCEByChannelModelVar(
allCEModelVarList, channel)
model.addConstr(gb.quicksum(filtredCEModelVarList),
gb.GRB.EQUAL, ceByChannelModelVar,
"Qtd_de_CE_no_canal_" + str(channel))
model.addConstr(
ceByChannelModelVar, gb.GRB.LESS_EQUAL,
min(len(scenario.cm.ceList),
((len(scenario.cm.ceList) /
PreProcessing.countAvailableChannels(scenario)) +
1)), "Máximo_de_CEs_no_canal_" + str(channel))
ceId = 0
for ceModelVars in ceModelVarList:
potencyList = []
for ceModelVar in ceModelVars:
ceModelVarNameSplit = ceModelVar.varName.split("_")
cePotency = int(ceModelVarNameSplit[3])
potencyList.append(cePotency * ceModelVar)
model.addConstr(
gb.quicksum(potencyList), gb.GRB.GREATER_EQUAL,
args.min_potency,
"Mínimo_de_potência_para_máxima_cobertura_do_CE_" +
str(ceId))
ceId += 1
print(">>>: Definindo a função objetivo")
model.setObjective(gb.quicksum(interferenceModelVarList),
gb.GRB.MINIMIZE)
model.write(
os.path.join(result_res_path,
"model_it_" + str(iteration) + ".lp"))
print(">>>: Modelo salvo")
print(">>>: Otimizando modelo")
model.optimize()
resultCEVarList = []
with open(
os.path.join(result_res_path,
"it_" + str(iteration) + ".txt"),
"w") as resultFile:
if (model.status == gb.GRB.Status.OPTIMAL):
resultFile.write(">>>: Resultado ótimo:\n")
print(">>>: Resultado ótimo:")
for ceModelVar in allCEModelVarList:
if (ceModelVar.x == 1.0):
resultCEVarList.append(ceModelVar.varName)
resultFile.write("%s\n" % ceModelVar.varName)
print("%s" % ceModelVar.varName)
for interferenceModelVar in interferenceModelVarList:
ceModelVar = model.getVarByName(
interferenceModelVar.varName.split("-")[2])
if ((ceModelVar.x == 1.0)
and (interferenceModelVar.x > 0.0)):
resultFile.write("%s %s\n" %
(interferenceModelVar.varName,
interferenceModelVar.x))
print("%s %s" % (interferenceModelVar.varName,
interferenceModelVar.x))
for ceByChannelModelVar in ceByChannelModelVarList:
resultFile.write("%s %s\n" %
(ceByChannelModelVar.varName,
ceByChannelModelVar.x))
print("%s %s" % (ceByChannelModelVar.varName,
ceByChannelModelVar.x))
elif (model.status == gb.GRB.Status.INFEASIBLE):
resultFile.write(">>>: O modelo é inviável!\n")
print(">>>: O modelo é inviável!")
print(">>>: Computando IIS")
model.computeIIS()
resultFile.write(
"\n>>>: As restrições a seguir não foram satisfeitas:\n"
)
print(">>>: As restrições a seguir não foram satisfeitas:")
for c in model.getConstrs():
if c.IISConstr:
resultFile.write("%s\n" % c.constrName)
print("%s" % c.constrName)
print(">>>: Otimizando modelo relaxado")
model.feasRelaxS(0, False, False, True)
model.optimize()
if (model.status == gb.GRB.Status.OPTIMAL):
resultFile.write(
"\n>>>: Resultado ótimo do modelo relaxado:\n")
print(">>>: Resultado ótimo do modelo relaxado:")
for ceModelVar in allCEModelVarList:
if (ceModelVar.x == 1.0):
resultCEVarList.append(ceModelVar.varName)
resultFile.write("%s\n" % ceModelVar.varName)
print("%s" % ceModelVar.varName)
for interferenceModelVar in interferenceModelVarList:
ceModelVar = model.getVarByName(
interferenceModelVar.varName.split("-")[2])
if ((ceModelVar.x == 1.0)
and (interferenceModelVar.x > 0.0)):
resultFile.write("%s %s\n" %
(interferenceModelVar.varName,
interferenceModelVar.x))
print("%s %s" % (interferenceModelVar.varName,
interferenceModelVar.x))
for ceByChannelModelVar in ceByChannelModelVarList:
resultFile.write("%s %s\n" %
(ceByChannelModelVar.varName,
ceByChannelModelVar.x))
print("%s %s" % (ceByChannelModelVar.varName,
ceByChannelModelVar.x))
elif (model.status in (gb.GRB.Status.INF_OR_UNBD,
gb.GRB.Status.UNBOUNDED,
gb.GRB.Status.INFEASIBLE)):
print(
">>>: O modelo relaxado não pode ser resolvido porque é ilimitado ou inviável"
)
else:
resultFile.write(
">>>: A otimização parou com status: %d\n" %
model.status)
print(">>>: A otimização parou com status: %d" %
model.status)
elif (model.status == gb.GRB.Status.UNBOUNDED):
resultFile.write(
">>>: O modelo não pode ser resolvido porque é ilimitado\n"
)
print(
">>>: O modelo não pode ser resolvido porque é ilimitado"
)
else:
resultFile.write(
">>>: A otimização parou com status: %d\n" %
model.status)
print(">>>: A otimização parou com status: %d" %
model.status)
resultCEList = []
for resultCEVar in resultCEVarList:
ceVarNameSplit = resultCEVar.split('_')
ceId = int(ceVarNameSplit[1])
resultCEChannelNumber = int(ceVarNameSplit[2])
resultCEPotency = int(ceVarNameSplit[3])
ce = scenario.cm.ceList[ceId]
resultCEList.append(
DataStructures.CE(ceId, ce.antenna, resultCEChannelNumber,
ce.geoPoint, resultCEPotency,
ce.maxPotency, ce.clientList))
#------------------------------ END SOLVER ------------------------------#
#------------------------------ BEGIN VISUALIZATION ------------------------------#
if (len(resultCEVarList) > 0):
Visualization.visualize(scenario, resultCEList,
result_fig_path, str(iteration))
#------------------------------ END VISUALIZATION ------------------------------#
resultLogFile.write(";" + str((time.time() - startTime)))
daily_budgets = np.linspace(5000, budget_cap, endpoint=True,
num=45).astype(int)
# The number of possible budgets that can be allocated to each subcampaign
number_of_budgets = 11
time_horizon = 100
regret = []
for e in range(0, number_of_experiments):
print('\n')
print('Starting experiment', e + 1)
scenarios = [
Scenario(daily_budgets=daily_budgets, campaign=0),
Scenario(daily_budgets=daily_budgets, campaign=1),
Scenario(daily_budgets=daily_budgets, campaign=2)
]
subcampaigns = [
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets]),
SW_GPTS_Learner(arms=daily_budgets[:number_of_budgets])
]
optimizer = Optimizer(daily_budgets, len(daily_budgets))
ideal_optimizer = Optimizer(daily_budgets, len(daily_budgets))
# The optimal and the ideal result obtained by playing the best possible combination of arms known
optimal_rewards_per_round = np.zeros(time_horizon)
from Scenario import *
from Unite import *
import time
hexagones = []
listetopo= [Topologie(1,"Clear",(136,66,29,0.50)),
Topologie(2,"Ridge",(91,60,17,0.50)),
Topologie(3,"Canal",(20,147,20,0.50)),
Topologie(4,"AccesSPUR",(22,184,78,0.50)),
Topologie(5,"Vapor pool",(255,255,255,0.50)),
Topologie(4,"Rise",(146,109,39,0.50)),
Topologie(7,"Cliffside",(255,206,154,0.50)),
Topologie(8,"Mesa-Top",(240,195,0,0.50)),
Topologie(9,"Crater",(0,0,0,0.50))]
Scenario=Scenario(DISPLAY)
UniteLegionnaire= [Legionnaire_Trouper(1)]
def evenr_offset_to_pixel(direction):
x = size * sqrt(3) * (direction.q - 0.5 * (direction.r&1))
y = size * 3/2 * direction.r
return Point(x, y)
for q in range(0,12):
for r in range(0,14):
hexagones.append(Hexagone(evenr_offset_to_pixel(Direction(q,r)),listetopo[random.randint(0,8)]))
grid = Grid(hexagones)
grid.display()
while True:
for event in pygame.event.get():
def exportSeries( scenario, ID ):
success = 0
outputDir = OutputWriter.getOutputDir( ID )
if not os.path.isifile('dir'):
os.mkdir(outputDir)
else:
print( 'WARNING! OutputWriter.exportSeries() is overwriting scenario ID %s\n' % int(ID))
# Load dynamic and static variables
cacheDir = PathFinder.getCacheDir(scenario)
with open(os.path.join(cacheDir, 'dynamics.pkl'), 'rb') as handle:
Dynamic = pickle.load(handle)
with open(os.path.join(cacheDir, 'market.pkl'), 'rb') as handle:
Market = pickle.load(handle)
if scenario.isCurrentPolicy() or scenario.postShock().isCurrentPolicy():
Static = Dynamic
StaticMarket = Market
else:
with open(os.path.join(cacheDir, 'statics.pkl'), 'rb') as handle:
Static = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy()), 'market.pkl' ), 'rb') as handle:
StaticMarket = pickle.load(handle)
# TEMP TEMP -- This is until Scenario.OpennessPath is not a
# dependence in ModelSolver.
# NOTE: This is not quite right for any openness <> baseline.
# Since the delta should be of constant 'baseline'
# behavior while the openness changes.
if scenario.OpennessPath != 'baseline':
print( 'WARNING! Changing policy delta -- Scenario.Openness=%s --> baseline.\n' % scenario.OpennessPath )
params = scenario.getParams()
params.OpennessPath = 'baseline'
bscenario = Scenario(params)
if( bscenario.isCurrentPolicy() or bscenario.postShock().isCurrentPolicy() ):
dynamicsFile = 'dynamics.pkl'
else:
dynamicsFile = 'statics.pkl'
with open(os.path.join(PathFinder.getCacheDir(bscenario), dynamicsFile), 'rb') as handle:
Static = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(bscenario.currentPolicy()), 'market.pkl' ), 'rb') as handle:
StaticMarket = pickle.load(handle)
# END TEMP
# Load Dynamics for Microsim baseline add factor fix-up
# NOTE: Fix-up factor is going to be Dynamic_base/Dynamic_open_base
try:
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy().open()), 'dynamics.pkl'), 'rb') as handle:
Dynamic_open_base = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(scenario.baseline()), 'dynamics.pkl')) as handle:
Dynamic_base = pickle.load(handle)
except:
raise Exception('WARNING! Cannot read files to make "Dynamic baseline". Skipping...\n' )
return success
## Write AGGREGATES.csv
##
# Build the source series.
# For static series, read from input interfaces
firstYear = scenario.TransitionFirstYear
lastYear = scenario.TransitionLastYear - 1
numYears = lastYear - firstYear + 1
pathFinder = PathFinder(scenario)
source_series = {}
projections_file = pathFinder.getProjectionsInputPath( 'Projections' )
source_series['projections'] = InputReader.read_series(projections_file, 'Year', firstYear, lastYear)
taxcalculator_file = pathFinder.getTaxCalculatorInputPath( 'Aggregates' )
source_series['taxcalculator'] = InputReader.read_series(taxcalculator_file, 'Year', firstYear, lastYear )
oasicalculator_file = pathFinder.getOASIcalculatorInputPath( 'aggregates' );
source_series['oasicalculator'] = InputReader.read_series(oasicalculator_file, 'Year', firstYear, lastYear );
source_series['Market'] = Market
# Add GDP deflator changes series
p_series = InputReader.read_series(projections_file, 'Year', firstYear-1, lastYear)
gdp_deflator = p_series['GDPDeflator']
inflation_rate = np.ones((1,numYears))
for i in range(numYears):
inflation_rate[i] = gdp_deflator[i+1]/gdp_deflator[i]
# Construct dynamic scaling series
## Helper function
@staticmethod
def makeDeltaSeries( Source1, Source2, var_name ):
if var_name == '_add_inflation_to_interestrate':
delta = inflation_rate
elif var_name == '_asis':
delta = np.ones((1, numYears))
elif var_name == '_nonindexed':
series1 = [np.ones((1,10)), Source1['outs'][10:]]
series2 = [np.ones((1,10)), Source2['outs'][10:]]
delta = series1 / series2
delta = delta[0:numYears] # truncate in case too long
else:
series1 = Source1[var_name]
series2 = Source2[var_name]
delta = series1 / series2
return delta
dynamic_series = {}
# Iterate over series names
for o in OutputWriter.series_names.keys():
series_name = o
var_name = OutputWriter.series_names[series_name]['var_name']
source = OutputWriter.series_names[series_name]['source']
source_name = OutputWriter.series_names[series_name]['source_name']
if len(source_name) == 0:
source_name = series_name
# Calculate Dynamic/Static delta
delta = makeDeltaSeries( Dynamic, Static, var_name )
# Calculate fixup factor for microsim (as delta open_baseline/baseline)
fixup = makeDeltaSeries( Dynamic_base, Dynamic_open_base, var_name )
# Calculate scaling series
v_scale = delta * fixup # Adjust by fix-up factor
v_scale[np.isnan(v_scale)] = 1
# Apply to source series
v_source = source_series[OutputWriter.series_names[series_name]['source']]['source_name']
if np.size(v_source,2) == numYears:
v_source = np.transpose(v_source) # frickin' matlab and its vector direction
if var_name == '_add_inflation_to_interestrate':
dynamic_series[series_name] = ((1+v_source) * delta) - 1
else:
dynamic_series[series_name] = v_source * v_scale
# Write series to file
series_table = pd.DataFrame(dynamic_series)
series_table.to_csv((os.path.join(outputDir, 'Aggregates.csv')))
## Write DYNAMICS.CSV
Dynamic['outvars'] = OutputWriter.dynamic_outvars
Market['outvars'] = OutputWriter.market_outvars
Static['outvars'] = Dynamic.outvars
StaticMarket['outvars'] = Market.outvars
# Create new column names for Static
for o in Static['outvars'].keys():
p = Static['outvars'][o]
Static['outvars'][o] = 'STATIC_' + p
for o in StaticMarket['outvars'].keys():
p = StaticMarket['outvars'][o]
StaticMarket['outvars'][o] = 'STATIC_' + p
# Load steady state variables
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy().steady()), 'dynamics.pkl'), 'rb') as handle:
Dynamic_steady = pickle.load(handle)
with open(os.path.join(PathFinder.getCacheDir(scenario.currentPolicy().steady()), 'market.pkl'), 'rb') as handle:
Market_steady = pickle.load(handle)
# Append steady state variables and reset the first year
firstYear = firstYear - 1
for o in Dynamic['outvars'].keys():
Dynamic[o] = np.hstack((Dynamic_steady[o], Dynamic[o]))
Static[o] = np.hstack((Dynamic_steady[o], Static[o]))
for o in Market['outvars'].keys():
Market[o] = np.hstack((Market_steady[o], Market[o]))
StaticMarket[o] = np.hstack((Market_steady[o], StaticMarket[o]))
# Concatenate structs
output_series = {}
for M in [Dynamic, Market, Static, StaticMarket]:
for o in M['outvars'].keys():
p = M['outvars'][o]
output_series[p] = M[o]
# Write series to file
series_table = pd.DataFrame(output_series)
series_table.to_csv(os.path.join(outputDir, 'Dynamics.csv' ))
success = 1
return success
