class Runner(object): # from environment import Environment # # VARIABLES # # # METHODS # #------------------------------------------------------------------------- # __init__ #------------------------------------------------------------------------- def __init__(self): pass #------------------------------------------------------------------------- #------------------------------------------------------------------------- # initialize() #------------------------------------------------------------------------- def initialize(self, environment): self.environment = environment self.updater = Updater(self.environment) self.shocker = Shock() #------------------------------------------------------------------------- #------------------------------------------------------------------------- # do_run #------------------------------------------------------------------------- def do_run(self, measurement, debug): # loop over all time steps and do the updating for i in range(self.environment.parameters.numSweeps): # the update step self.updater.do_update(self.environment, i, debug) # check if there is a shock at the current time step if (int(self.environment.get_state(i).shockType) != 0): self.shocker.do_shock(self.environment, int(i)) self.environment.get_state(i).shockType = 0 # do the measurement measurement.do_measurement(self.environment.banks)
def updater__do_update(self, args): import os from src.bank import Bank from src.household import Household from src.firm import Firm from src.environment import Environment from src.transaction import Transaction from src.market import Market from src.updater import Updater text = "This test checks updater.do_update \n" self.print_info(text) # # INITIALIZATION # environment_directory = str(args[0]) identifier = str(args[1]) log_directory = str(args[2]) # Configure logging parameters so we get output while the program runs logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S', filename=log_directory + identifier + ".log", level=logging.INFO) logging.info('START logging for test updater__do_update in run: %s', environment_directory + identifier + ".xml") # Construct household filename environment = Environment(environment_directory, identifier) # # TESTING # model = Updater(environment) print(environment.households[0]) print("Doing update") model.do_update(environment, 0) print(environment.households[0])
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_simulations = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, _value): super(Runner, self).set_identifier(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_num_simulations # ------------------------------------------------------------------------- def get_num_simulations(self): return self.num_simulations # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_simulations(self, _value): super(Runner, self).set_num_simulaitons(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_sweeps = int(environment.num_sweeps) self.updater = Updater(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating for i in range(self.num_sweeps): # the update step self.updater.do_update(environment, i) # TESTING IN SIMPLE EXAMPLES # REMOVE FOR PRODUCTION # OR MOVE TO LOGGING print(environment.firms[0]) print(environment.households[0])
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_simulations = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, _value): super(Runner, self).set_identifier(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_num_simulations # ------------------------------------------------------------------------- def get_num_simulations(self): return self.num_simulations # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_simulations(self, _value): super(Runner, self).set_num_simulaitons(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_sweeps = int(environment.num_sweeps) self.updater = Updater(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating for i in range(self.num_sweeps): # the update step self.updater.do_update(environment, i) print(environment.firms[0]) print(environment.households[0])
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_sweeps = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_sweeps = int(environment.static_parameters['num_sweeps']) self.updater = Updater(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, value): return super(Runner, self).set_identifier(value) # ------------------------------------------------------------------------- # get_num_sweeps # ------------------------------------------------------------------------- def get_num_sweeps(self): return self.num_sweeps # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_sweeps(self, value): super(Runner, self).set_num_sweeps(value) # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating # For each update step measurement = Measurement(environment, self) measurement.open_file() for i in range(self.num_sweeps): self.current_step = i self.updater.do_update(environment) measurement.write_to_file() print("***\nThis run had %s sweeps and %s simulations") % ( self.num_sweeps, environment.static_parameters['num_simulations']) print( "Check the output file that was written as csv in the measurements folder\n***" ) # environment.print_parameters() # agent = Agent() # print(self.get_identifier()) # print(self.get_num_sweeps()) # print(environment.agents[0]) # print(environment.agents[1]) # parameters={'deposit_rate':-0.02} # agent.append_parameters(parameters) # print(agent.get_parameters()) measurement.close_file()
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_sweeps = 0 # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.updater = Updater(environment) self.num_sweeps = int(environment.static_parameters['num_sweeps']) #For measurement self.sweep_result_list = [] # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, value): return super(Runner, self).set_identifier(value) # ------------------------------------------------------------------------- # get_num_sweeps # ------------------------------------------------------------------------- def get_num_sweeps(self): return self.num_sweeps # ------------------------------------------------------------------------- def traverse(self, item): try: for i in iter(item): for j in self.traverse(i): yield j except TypeError: yield item # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_sweeps(self, value): super(Runner, self).set_num_sweeps(value) # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating # For each update step for i in range(self.num_sweeps): self.current_step = i self.updater.do_update(environment, i) self.sweep_result_list.append(self.updater.env_var_par_df) self.updater.write_sweep_list_of_results_to_csv( environment, self.current_step) print( "Check the simulation specific output file that was written as result_all_sweeps.csv in the main folder\n***" )
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_sweeps = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.updater = Updater(environment) self.num_sweeps = int(environment.static_parameters['num_sweeps']) self.m = int(environment.static_parameters['m']) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, value): return super(Runner, self).set_identifier(value) # ------------------------------------------------------------------------- # get_num_sweeps # ------------------------------------------------------------------------- def get_num_sweeps(self): return self.num_sweeps # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_sweeps(self, value): super(Runner, self).set_num_sweeps(value) # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating # For each update step measurement = Measurement(environment, self) measurement.open_file() for i in range(self.num_sweeps): self.current_step = i self.updater.do_update(environment, i) measurement.write_to_file() print("***\nThis run had %s sweeps and %s simulations" ) % (self.num_sweeps, environment.static_parameters['num_simulations']) print("Check the output file that was written as csv in the measurements folder\n***") agent = Agent() for each_agent in environment.agents: print(agent.identifier) # agent = Agent() # print(agent.private_belief) # print(agent.calc_social_belief) # print(agent.investment_decision(environment)) # for keys, values in agent.parameters.items(): # print keys, '-->', values # agent = Agent() # print(self.get_identifier()) # print(self.get_num_sweeps()) # print(environment.agents[0]) # parameters={'deposit_rate':-0.02} # agent.append_parameters(parameters) # print(agent.get_parameters()) measurement.close_file()
class Runner(BaseRunner): # from environment import Environment # # VARIABLES # identifier = "" num_simulations = 0 # # METHODS # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self): pass # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier def set_identifier(self, _value): """ Class variables: identifier Local variables: _identifier """ super(Runner, self).set_identifier(_value) def get_num_simulations(self): return self.num_simulations def set_num_simulations(self, _value): """ Class variables: num_simulations Local variables: _num_simulations """ super(Runner, self).set_num_simulaitons(_value) # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_simulations = environment.static_parameters["numSweeps"] self.environment = environment self.updater = Updater(self.environment) self.shocker = Shock() # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, measurement, debug): # loop over all time steps and do the updating for i in range(self.num_simulations): # the update step self.updater.do_update(self.environment, i, debug) # check if there is a shock at the current time step if (int(self.environment.get_state(i).static_parameters["shockType"]) != 0): self.shocker.do_shock(self.environment, int(i)) self.environment.get_state(i).static_parameters["shockType"] = 0 # do the measurement measurement.do_measurement(self.environment.banks)
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_simulations = 0 current_step = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, _value): super(Runner, self).set_identifier(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_num_simulations # ------------------------------------------------------------------------- def get_num_simulations(self): return self.num_simulations # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_simulations(self, _value): super(Runner, self).set_num_simulaitons(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_sweeps = int(environment.num_sweeps) self.updater = Updater(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating # We initialise the measurement class for writing outputs to csv # measurement = Measurement("Measurement", environment, self, {1: ["Step", "static", "self.runner.current_step"], # 2: ["Deposits", "dynamic", "self.environment.households[0].get_account", ["deposits"]]}, "TestMeasurement.csv") measurement = Measurement(environment, self) # And open the output file measurement.open_file() # For each update step for i in range(self.num_sweeps): print(environment.measurement_config) # the update step # append current step, this is mostly for measurements self.current_step = i # do the actual update self.updater.do_update(environment, i) # write the state of the system measurement.write_to_file() # HELPER, to be removed in production print(environment.households[0]) print(environment.firms[0]) # Close the output file at the end of the simulation measurement.close_file()
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_sweeps = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.updater = Updater(environment) self.num_sweeps = int(environment.static_parameters['num_sweeps']) # self.m = int(environment.static_parameters['m']) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, value): return super(Runner, self).set_identifier(value) # ------------------------------------------------------------------------- # get_num_sweeps # ------------------------------------------------------------------------- def get_num_sweeps(self): return self.num_sweeps # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_sweeps(self, value): super(Runner, self).set_num_sweeps(value) # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating # For each update step measurement = Measurement(environment, self) measurement.open_file() for i in range(self.num_sweeps): self.current_step = i self.updater.do_update(environment, i) measurement.write_to_file() print("***\nThis run had %s sweeps and %s simulations" ) % (self.num_sweeps, environment.static_parameters['num_simulations']) print("Check the output file that was written as csv in the measurements folder\n***") measurement.close_file()
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_simulations = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, _value): super(Runner, self).set_identifier(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_num_simulations # ------------------------------------------------------------------------- def get_num_simulations(self): return self.num_simulations # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_simulations # ------------------------------------------------------------------------- def set_num_simulations(self, _value): super(Runner, self).set_num_simulaitons(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_sweeps = int(environment.num_sweeps) self.updater = Updater(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating for i in range(self.num_sweeps): # the update step self.updater.do_update(environment, i) print("Sweep number %s" % str(i+1)) for bank in environment.banks: print(bank) print("Bank objects:") print(environment.banks) print("Firm objects:") print(environment.firms) print("Household objects:") print(environment.households)
class Runner(BaseRunner): # # # VARIABLES # # identifier = "" num_sweeps = 0 current_step = 0 # # # METHODS # # # ------------------------------------------------------------------------- # __init__ # ------------------------------------------------------------------------- def __init__(self, environment): self.initialize(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_identifier # ------------------------------------------------------------------------- def get_identifier(self): return self.identifier # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_identifier # ------------------------------------------------------------------------- def set_identifier(self, _value): super(Runner, self).set_identifier(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # get_num_sweeps # ------------------------------------------------------------------------- def get_num_sweeps(self): return self.num_sweeps # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # set_num_sweeps # ------------------------------------------------------------------------- def set_num_sweeps(self, _value): super(Runner, self).set_num_sweeps(_value) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # initialize() # ------------------------------------------------------------------------- def initialize(self, environment): self.identifier = environment.identifier self.num_sweeps = int(environment.num_sweeps) self.updater = Updater(environment) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # do_run # ------------------------------------------------------------------------- def do_run(self, environment): # loop over all time steps and do the updating # We initialise the measurement class for writing outputs to csv # measurement = Measurement("Measurement", environment, self, {1: ["Step", "static", "self.runner.current_step"], # 2: ["Deposits", "dynamic", "self.environment.households[0].get_account", ["deposits"]]}, "TestMeasurement.csv") measurement = Measurement(environment, self) # And open the output file measurement.open_file() # We start the shock class as well shock_class = Shock() # For each update step for i in range(self.num_sweeps): # Do the shock: # First we check if the shock occurs at the current sweep # Then we run the shock procedure at the start of the update for shock in environment.shocks: if int(shock[0]) <= i+1 and int(shock[1]) >= i+1: shock_class.do_shock(environment, i, shock[2], "start") # the update step # append current step, this is mostly for measurements self.current_step = i # do the actual update self.updater.do_update(environment, i) # write the state of the system measurement.write_to_file() # Do the shock (revert the shock if necessary): # First we check if the shock occurs at the current sweep # Then we run the shock procedure at the end of the update for shock in environment.shocks: if int(shock[0]) <= i+1 and int(shock[1]) >= i+1: shock_class.do_shock(environment, i, shock[2], "end") # HELPER, to be removed in production # for firm in environment.households: # print(firm) # print(environment.households[0]) # print(environment.firms[0]) # capital = 0.0 # for tranx in environment.firms[0].accounts: # if tranx.type_ == "capital" and tranx.from_ == environment.firms[0]: # capital = capital + tranx.amount # if tranx.type_ == "capital" and tranx.to == environment.firms[0]: # capital = capital - tranx.amount # print(environment.firms[0].get_account("deposits")+capital-environment.firms[0].get_account("loans")) # capital = 0.0 # for tranx in environment.firms[1].accounts: # if tranx.type_ == "capital" and tranx.from_ == environment.firms[1]: # capital = capital + tranx.amount # if tranx.type_ == "capital" and tranx.to == environment.firms[1]: # capital = capital - tranx.amount # print(environment.firms[1].get_account("deposits")+capital-environment.firms[1].get_account("loans")) # capital = 0.0 # for tranx in environment.firms[2].accounts: # if tranx.type_ == "capital" and tranx.from_ == environment.firms[2]: # capital = capital + tranx.amount # if tranx.type_ == "capital" and tranx.to == environment.firms[2]: # capital = capital - tranx.amount # print(environment.firms[2].get_account("deposits")+capital-environment.firms[2].get_account("loans")) print(environment.banks[0]) # print(environment.firms[0]) # Close the output file at the end of the simulation measurement.close_file()