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])
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()
