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