def update(num_growth_pix):
# print(f"Num_growth_pix: {num_growth_pix}")
nrows = IGrid.nrows
ncols = IGrid.ncols
total_pixels = nrows * ncols
road_pixel_count = IGrid.get_road_pixel_count(
Processing.get_current_year())
excluded_pixel_count = IGrid.get_excld_count()
# Compute this year stats
Stats.compute_cur_year_stats()
# Set num growth pixels
Stats.set_num_growth_pixels(num_growth_pix)
# Calibrate growth rate
Stats.cal_growth_rate()
# Calibrate Percent Urban
Stats.cal_percent_urban(total_pixels, road_pixel_count,
excluded_pixel_count)
output_dir = Scenario.get_scen_value('output_dir')
cur_run = Processing.get_current_run()
cur_year = Processing.get_current_year()
if IGrid.test_for_urban_year(Processing.get_current_year()):
Stats.cal_leesalee()
filename = f"{output_dir}grow_{cur_run}_{cur_year}.log"
Stats.save(filename)
if Processing.get_processing_type() == Globals.mode_enum['predict']:
filename = f"{output_dir}grow_{cur_run}_{cur_year}.log"
Stats.save(filename)
def analyze(fmatch):
output_dir = Scenario.get_scen_value('output_dir')
run = Processing.get_current_run()
write_avg_file = Scenario.get_scen_value('write_avg_file')
avg_filename = f'{output_dir}avg.log'
write_std_dev_file = Scenario.get_scen_value('write_std_dev_file')
std_filename = f'{output_dir}std_dev.log'
control_filename = f'{output_dir}control_stats.log'
if write_avg_file:
if not os.path.isfile(avg_filename):
Stats.create_stats_val_file(avg_filename)
if write_std_dev_file:
if not os.path.isfile(std_filename):
Stats.create_stats_val_file(std_filename)
if Processing.get_processing_type() != Globals.mode_enum['predict']:
if not os.path.isfile(control_filename):
Stats.create_control_file(control_filename)
# start at i = 1; i = 0 is the initial seed
# I think I need to put a dummy stats_val to represent the initial seed
Stats.average.append(StatsVal())
for i in range(1, IGrid.igrid.get_num_urban()):
year = IGrid.igrid.get_urban_year(i)
Stats.calculate_averages(i)
Stats.process_grow_log(run, year)
if write_avg_file:
Stats.write_stats_val_line(avg_filename, run, year,
Stats.average[i], i)
if write_std_dev_file:
Stats.write_stats_val_line(std_filename, run, year,
Stats.std_dev[i], i)
Stats.do_regressions()
Stats.do_aggregate(fmatch)
Stats.write_control_stats(control_filename)
if Processing.get_processing_type() == Globals.mode_enum['predict']:
start = int(Scenario.get_scen_value('prediction_start_date'))
stop = Processing.get_stop_year()
for year in range(start + 1, stop + 1):
Stats.clear_stats()
Stats.process_grow_log(run, year)
if write_avg_file:
Stats.write_stats_val_line(avg_filename, run, year,
Stats.average[0], 0)
if write_std_dev_file:
Stats.write_stats_val_line(std_filename, run, year,
Stats.std_dev[0], 0)
Stats.clear_stats()
def save(filename):
Stats.record.run = Processing.get_current_run()
Stats.record.monte_carlo = Processing.get_current_monte()
Stats.record.year = Processing.get_current_year()
index = 0
if Processing.get_processing_type() != Globals.mode_enum['predict']:
index = IGrid.igrid.urban_yr_to_idx(Stats.record.year)
Stats.update_running_total(index)
# Now we are writing the record to file for now...
if Stats.record.monte_carlo == 0:
# Create file
with open(filename,
'wb') as output: # Overwrites any existing file.
_pickle.dump(Stats.record, output, -1)
else:
with open(filename, 'ab') as output:
_pickle.dump(Stats.record, output, -1)
def grow(z, land1):
deltatron = PGrid.get_deltatron()
avg_slope = 0
if Processing.get_processing_type() == Globals.mode_enum['predict']:
Processing.set_current_year(
Scenario.get_scen_value('prediction_start_date'))
else:
Processing.set_current_year(IGrid.igrid.get_urban_year(0))
Utilities.init_grid(z.gridData)
# print(z.gridData)
if len(Scenario.get_scen_value('landuse_data_file')) > 0:
Grow.landuse_init(deltatron.gridData, land1.gridData)
seed = IGrid.igrid.get_urban_grid(0)
Utilities.condition_gif(seed, z.gridData)
if Scenario.get_scen_value('echo'):
print("******************************************")
if Processing.get_processing_type(
) == Globals.mode_enum['calibrate']:
c_run = Processing.get_current_run()
t_run = Processing.get_total_runs()
print(f"Run = {c_run} of {t_run}"
f" ({100 * c_run / t_run:8.1f} percent complete)")
print(
f"Monte Carlo = {int(Processing.get_current_monte()) + 1} of "
f"{Scenario.get_scen_value('monte_carlo_iterations')}")
print(f"Processing.current_year = {Processing.get_current_year()}")
print(f"Processing.stop_year = {Processing.get_stop_year()}")
if Scenario.get_scen_value('logging') and int(
Scenario.get_scen_value('log_processing_status')) > 0:
Grow.completion_status()
while Processing.get_current_year() < Processing.get_stop_year():
# Increment Current Year
Processing.increment_current_year()
cur_yr = Processing.get_current_year()
if Scenario.get_scen_value('echo'):
print(f" {cur_yr}", end='')
sys.stdout.flush()
if (cur_yr +
1) % 10 == 0 or cur_yr == Processing.get_stop_year():
print()
if Scenario.get_scen_value('logging'):
Logger.log(f" {cur_yr}")
if (cur_yr +
1) % 10 == 0 or cur_yr == Processing.get_stop_year():
Logger.log("")
# Apply the Cellular Automaton Rules for this Year
avg_slope, num_growth_pix, sng, sdc, og, rt, pop = Spread.spread(
z, avg_slope)
#print(f"rt: {rt}")
sdg = 0 # this isn't passed into spread, but I don't know why then it's here
Stats.set_sng(sng)
Stats.set_sdg(sdc)
#Stats.set_sdc(sdc)
Stats.set_og(og)
Stats.set_rt(rt)
Stats.set_pop(pop)
if Scenario.get_scen_value('view_growth_types'):
if IGrid.using_gif:
filename = f"{Scenario.get_scen_value('output_dir')}z_growth_types" \
f"_{Processing.get_current_run()}_{Processing.get_current_monte()}_" \
f"{Processing.get_current_year()}.gif"
else:
filename = f"{Scenario.get_scen_value('output_dir')}z_growth_types" \
f"_{Processing.get_current_run()}_{Processing.get_current_monte()}_" \
f"{Processing.get_current_year()}.tif"
date = str(Processing.get_current_year())
ImageIO.write_gif(z, Color.get_growth_table(), filename, date,
IGrid.nrows, IGrid.ncols)
if len(Scenario.get_scen_value('landuse_data_file')) > 0:
Grow.grow_landuse(land1, num_growth_pix)
else:
Grow.grow_non_landuse(z.gridData)
seed = IGrid.igrid.get_urban_grid(0)
Utilities.condition_gif(seed, z.gridData)
# do Statistics
Stats.update(num_growth_pix)
# do Self Modification
Coeff.self_modify(Stats.get_growth_rate(),
Stats.get_percent_urban())
Coeff.write_current_coeff(Processing.get_current_run(),
Processing.get_current_monte(),
Processing.get_current_year())
def main():
TimerUtility.start_timer('total_time')
valid_modes = ["predict", "restart", "test", "calibrate"]
Globals.mype = 0
Globals.npes = 1
packing = False
restart_run = 0
# Parse command line
if len(sys.argv) != 3:
__print_usage(sys.argv[0])
sys.exit(1)
if len(sys.argv) != 3 or sys.argv[1] not in valid_modes:
__print_usage(sys.argv[0])
sys.exit(1)
Processing.set_processing_type(Globals.mode_enum[sys.argv[1]])
if Processing.get_processing_type() == Globals.mode_enum['restart']:
Processing.set_restart_flag(True)
Scenario.init(sys.argv[2], Processing.get_restart_flag())
try:
log_it = Scenario.get_scen_value("logging")
random_seed = Scenario.get_scen_value("random_seed")
Random.set_seed(random_seed)
landuse_class_info = Scenario.get_scen_value("landuse_class_info")
LandClass.num_landclasses = len(landuse_class_info)
# filling in the class array in Land_Class
for i, landuse_class in enumerate(landuse_class_info):
# num, class_id, name, idx, hexColor
landuse_class_meta = LanduseMeta(landuse_class.grayscale,
landuse_class.type,
landuse_class.name, i,
landuse_class.color[2:])
LandClass.landuse_classes.append(landuse_class_meta)
# Set up Coefficients
if sys.argv[1] == 'restart':
if log_it:
print("Implement log here")
diffusion, breed, spread, slope_resistance, road_gravity, random_seed, restart_run = \
Input.read_restart_file(Scenario.get_scen_value("output_dir"))
Processing.set_current_run(restart_run)
else:
Processing.set_current_run(0)
Coeff.set_start_coeff(
Scenario.get_scen_value("calibration_diffusion_start"),
Scenario.get_scen_value("calibration_spread_start"),
Scenario.get_scen_value("calibration_breed_start"),
Scenario.get_scen_value("calibration_slope_start"),
Scenario.get_scen_value("calibration_road_start"))
Coeff.set_stop_coeff(
Scenario.get_scen_value("calibration_diffusion_stop"),
Scenario.get_scen_value("calibration_spread_stop"),
Scenario.get_scen_value("calibration_breed_stop"),
Scenario.get_scen_value("calibration_slope_stop"),
Scenario.get_scen_value("calibration_road_stop"))
Coeff.set_step_coeff(
Scenario.get_scen_value("calibration_diffusion_step"),
Scenario.get_scen_value("calibration_spread_step"),
Scenario.get_scen_value("calibration_breed_step"),
Scenario.get_scen_value("calibration_slope_step"),
Scenario.get_scen_value("calibration_road_step"))
Coeff.set_best_fit_coeff(
Scenario.get_scen_value("prediction_diffusion_best_fit"),
Scenario.get_scen_value("prediction_spread_best_fit"),
Scenario.get_scen_value("prediction_breed_best_fit"),
Scenario.get_scen_value("prediction_slope_best_fit"),
Scenario.get_scen_value("prediction_road_best_fit"))
# Initial IGrid
IGrid.init(packing, Processing.get_processing_type())
'''
Skipped memory and logging stuff for now, don't know if I'll need it
If there is a problem, I can go back and implement
'''
# Initialize Landuse
if len(Scenario.get_scen_value("landuse_data_file")) > 0:
LandClass.init()
if Scenario.get_scen_value("log_landclass_summary"):
if log_it:
# this is where we would log
Logger.log("Test log")
# Initialize Colortables
Color.init(IGrid.ncols)
# Read and validate input
IGrid.read_input_files(packing,
Scenario.get_scen_value("echo_image_files"),
Scenario.get_scen_value("output_dir"))
IGrid.validate_grids(log_it)
# Normalize Roads
IGrid.normalize_roads()
landuse_flag = len(Scenario.get_scen_value("landuse_data_file")) != 0
IGrid.verify_inputs(log_it, landuse_flag)
# Initialize PGRID Grids
PGrid.init(IGrid.get_total_pixels())
if log_it and Scenario.get_scen_value("log_colortables"):
Color.log_colors()
# Count the Number of Runs
Processing.set_total_runs()
Processing.set_last_monte(
int(Scenario.get_scen_value("monte_carlo_iterations")) - 1)
if log_it:
if Processing.get_processing_type(
) == Globals.mode_enum["calibrate"]:
Logger.log(
f"Total Number of Runs = {Processing.get_total_runs()}")
# Compute Transition Matrix
if len(Scenario.get_scen_value("landuse_data_file")) > 0:
Transition.create_matrix()
if log_it and Scenario.get_scen_value("log_transition_matrix"):
Transition.log_transition()
# Compute the Base Statistics against which the calibration will take place
Stats.set_base_stats()
if log_it and Scenario.get_scen_value("log_base_statistics"):
Stats.log_base_stats()
if log_it and Scenario.get_scen_value("log_debug"):
IGrid.debug("main.py")
Processing.set_num_runs_exec_this_cpu(0)
if Processing.get_current_run() == 0 and Globals.mype == 0:
output_dir = Scenario.get_scen_value("output_dir")
if Processing.get_processing_type(
) != Globals.mode_enum["predict"]:
filename = f"{output_dir}control_stats.log"
Stats.create_control_file(filename)
if Scenario.get_scen_value("write_std_dev_file"):
filename = f"{output_dir}std_dev.log"
Stats.create_stats_val_file(filename)
if Scenario.get_scen_value("write_avg_file"):
filename = f"{output_dir}avg.log"
Stats.create_stats_val_file(filename)
if Scenario.get_scen_value("write_coeff_file"):
output_dir = Scenario.get_scen_value("output_dir")
filename = f"{output_dir}coeff.log"
Coeff.create_coeff_file(filename, True)
if Processing.get_processing_type() == Globals.mode_enum["predict"]:
# Prediction Runs
Processing.set_stop_year(
Scenario.get_scen_value("prediction_stop_date"))
Coeff.set_current_coeff(Coeff.get_best_diffusion(),
Coeff.get_best_spread(),
Coeff.get_best_breed(),
Coeff.get_best_slope_resistance(),
Coeff.get_best_road_gravity())
if Globals.mype == 0:
Driver.driver()
Processing.increment_num_runs_exec_this_cpu()
# Timing stuff
if log_it and int(Scenario.get_scen_value('log_timings')) > 1:
TimerUtility.log_timers()
else:
# Calibration and Test Runs
Processing.set_stop_year(
IGrid.igrid.get_urban_year(IGrid.igrid.get_num_urban() - 1))
output_dir = Scenario.get_scen_value('output_dir')
d_start, d_step, d_stop = Coeff.get_start_step_stop_diffusion()
for diffusion_coeff in range(d_start, d_stop + 1, d_step):
b_start, b_step, b_stop = Coeff.get_start_step_stop_breed()
for breed_coeff in range(b_start, b_stop + 1, b_step):
s_start, s_step, s_stop = Coeff.get_start_step_stop_spread(
)
for spread_coeff in range(s_start, s_stop + 1, s_step):
sr_start, sr_step, sr_stop = Coeff.get_start_step_stop_slope_resistance(
)
for slope_resist_coeff in range(
sr_start, sr_stop + 1, sr_step):
rg_start, rg_step, rg_stop = Coeff.get_start_step_stop_road_gravity(
)
for road_grav_coeff in range(
rg_start, rg_stop + 1, rg_step):
filename = f"{output_dir}{UGMDefines.RESTART_FILE}{Globals.mype}"
Output.write_restart_data(
filename, diffusion_coeff, breed_coeff,
spread_coeff, slope_resist_coeff,
road_grav_coeff,
Scenario.get_scen_value('random_seed'),
restart_run)
restart_run += 1
Coeff.set_current_coeff(
diffusion_coeff, spread_coeff, breed_coeff,
slope_resist_coeff, road_grav_coeff)
Driver.driver()
Processing.increment_num_runs_exec_this_cpu()
# Timing Logs
if log_it and int(
Scenario.get_scen_value(
'log_timings')) > 1:
TimerUtility.log_timers()
Processing.increment_current_run()
if Processing.get_processing_type(
) == Globals.mode_enum['test']:
TimerUtility.stop_timer('total_time')
if log_it and int(
Scenario.get_scen_value(
'log_timings')) > 0:
TimerUtility.log_timers()
Logger.close()
sys.exit(0)
# Stop timer
TimerUtility.stop_timer('total_time')
if log_it and int(Scenario.get_scen_value('log_timings')) > 0:
TimerUtility.log_timers()
# Close Logger
Logger.close()
except KeyError as err:
traceback.print_exc()
print("{0} is not set. Please set it in your scenario file".format(
str(err).upper()))
Logger.log("Something went wrong")
Logger.close()
sys.exit(1)
except FileNotFoundError as err:
traceback.print_exc()
print(err)
Logger.log("Something went wrong")
Logger.close()
sys.exit(1)
except Exception:
traceback.print_exc()
Logger.log("Something went wrong")
Logger.close()
sys.exit(1)
