def get_rand_landuse_offset(): nrows = IGrid.nrows ncols = IGrid.ncols i_center = Random.get_int(0, nrows - 1) j_center = Random.get_int(0, ncols - 1) return int(i_center * ncols + j_center), i_center, j_center
def phase1n3(diffusion_coeff, breed_coeff, z, delta, slope, excld, slope_weights, sng, sdc): TimerUtility.start_timer("spr_phase1n3") diffusion_value = Spread.calculate_diffusion_value(diffusion_coeff) nrows = IGrid.nrows ncols = IGrid.ncols for k in range(1 + int(diffusion_value)): # get a random row and col index i = Random.get_int(0, nrows - 1) j = Random.get_int(0, ncols - 1) # check if it is an interior point if 0 < i < nrows - 1 and 0 < j < ncols - 1: success, sng = Spread.urbanize(i, j, z, delta, slope, excld, slope_weights, UGMDefines.PHASE1G, sng) if success and Random.get_int(0, 100) < breed_coeff: count = 0 max_tries = 8 for tries in range(max_tries): urbanized, sdc, i_neigh, j_neigh = Spread.urbanize_neighbor( i, j, z, delta, slope, excld, slope_weights, UGMDefines.PHASE3G, sdc) if urbanized: count += 1 if count == UGMDefines.MIN_NGHBR_TO_SPREAD: break TimerUtility.stop_timer('spr_phase1n3') return sng, sdc
def phase4(spread_coeff, z, excld, delta, slope, slope_weights, og): TimerUtility.start_timer('spr_phase4') nrows = IGrid.nrows ncols = IGrid.ncols neighbor_options = [(-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1)] # Loop over the interior pixels looking for urban from which to perform organic growth for row in range(1, nrows - 1): for col in range(1, ncols - 1): offset = row * ncols + col # Is this an urban pixel and do we pass the random spread coefficient test? if z[offset] > 0 and Random.get_int(0, 100) < spread_coeff: # Examine the eight cell neighbors # Spread at random if at least 2 are urban # Pixel itself must be urban (3) urb_count = Spread.count_neighbor(z, row, col) if 2 <= urb_count < 8: x_neigh, y_neigh = Random.get_element(neighbor_options) row_neighbor = row + x_neigh col_neighbor = col + y_neigh success, og = Spread.urbanize(row_neighbor, col_neighbor, z, delta, slope, excld, slope_weights, UGMDefines.PHASE4G, og) TimerUtility.stop_timer('spr_phase4') return og
def RandomPrecision(k,l): m = Random(2) bf = Random(pow(10,k))-1 af = Random(pow(10,l))-1 af = af / pow(10,l) x = bf+af if m == 1: x = x*(-1) return x
def get_neighbor(row, col): neighbor_options = [(-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1)] idx = Random.get_int(0, 7) idx_x, idx_y = neighbor_options[idx] neigh_row = row + idx_x neigh_col = col + idx_y return idx, int(neigh_row), int(neigh_col)
def __init__(self, DorR, cat_corr, **kwargs): """ A class that describes the FFT of galaxy simulated/observed data """ if 'spec' not in cat_corr.keys(): # default spectrum parameters cat_corr['spec'] = { 'P0': 20000, #P0 'Lbox': 3600, 'Ngrid':360, 'ell': 0 } self.cat_corr = cat_corr.copy() self.kwargs = kwargs self.type = DorR if self.type == 'data': self.galdata = CorrData(self.cat_corr, **self.kwargs) # data class elif self.type == 'random': self.galdata = Random(self.cat_corr, **self.kwargs) # data class self.file_name = self.file()
def urbanize(row, col, z, delta, slope, excld, slope_weights, pixel_val, stat): nrows = IGrid.nrows ncols = IGrid.ncols offset = row * ncols + col flag = False if z[offset] == 0: if delta[offset] == 0: if Random.get_float() > slope_weights[slope[offset]]: if excld[offset] < Random.get_int(0, 99): flag = True delta[offset] = pixel_val stat += 1 else: Stats.increment_excluded_failure() else: Stats.increment_slope_failure() else: Stats.increment_delta_failure() else: Stats.increment_z_failure() return flag, stat
def get_new_landuse(class_indices, landuse_classes, local_slope, class_slope): # Find two unique land classes first_choice, second_choice = Random.get_unique_elements( class_indices, 2) # Choose landuse with the most similar topographical slope slope_diff1 = local_slope - class_slope[first_choice.idx] slope_diff2 = local_slope - class_slope[second_choice.idx] if slope_diff1 * slope_diff2 < slope_diff2 * slope_diff2: new_landuse = landuse_classes[first_choice.idx].num else: new_landuse = landuse_classes[second_choice.idx].num return new_landuse
def get_valid_neighbor(row, col): nrows = IGrid.nrows ncols = IGrid.ncols neighbor_options = [(-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1)] idx = Random.get_int(0, 7) valid = False neigh_row = 0 neigh_col = 0 while not valid: idx_x, idx_y = neighbor_options[idx] neigh_row = row + idx_x neigh_col = col + idx_y if 0 <= neigh_row < nrows and 0 <= neigh_col < ncols: valid = True else: # The neighbor chosen isn't valid, go to next index in neighbor list and try again idx = (idx + 1) % 8 return neigh_row, neigh_col
class Fft(object): def __init__(self, DorR, cat_corr, **kwargs): """ A class that describes the FFT of galaxy simulated/observed data """ if 'spec' not in cat_corr.keys(): # default spectrum parameters cat_corr['spec'] = { 'P0': 20000, #P0 'Lbox': 3600, 'Ngrid':360, 'ell': 0 } self.cat_corr = cat_corr.copy() self.kwargs = kwargs self.type = DorR if self.type == 'data': self.galdata = CorrData(self.cat_corr, **self.kwargs) # data class elif self.type == 'random': self.galdata = Random(self.cat_corr, **self.kwargs) # data class self.file_name = self.file() def file(self): """ FFT data file name """ #corrdict = (self.cat_corr)['correction'] specdict = (self.cat_corr)['spec'] fft_dir = direc('fft', self.cat_corr) self.data_file = self.galdata.file_name # galaxy data file # FFT label fft_str = 'FFT_' if specdict['ell'] != 0: fft_str += 'Q_' #if (corrdict['name'].lower() in ('floriansn', 'hectorsn')) & (self.type != 'random'): # fft_corr_str = ''.join(['.', corrdict['name'].lower()]) # FFTs from data file fft_file = ''.join([ fft_dir, fft_str, (self.data_file).rsplit('/')[-1], '.grid', str(specdict['Ngrid']), '.P0', str(specdict['P0']), '.box', str(int(specdict['Lbox'])) ]) return fft_file def build(self): """ Run FFT FORTRAN code to calculate FFT of data """ specdict = (self.cat_corr)['spec'] if not os.path.isfile(self.data_file): self.galdata.build() #if 'quad' not in specdict.keys(): # raise KeyError(" 'quad' must be specified ") #if not specdict['quad']: # quadrupole or regular FFT code # fft_type = 'fft' #else: # fft_type = 'quad_fft' #if specdict['ell'] == 0: fft_type = 'fft' #else: # fft_type = 'quad_fft' # (outdated naming convention but too lazy to fully change) codeclass = Fcode(fft_type, self.cat_corr) fftcode = codeclass.code fftexe = codeclass.fexe() # code and exe modification time fftcode_t_mod, fftexe_t_mod = codeclass.mod_time() if fftexe_t_mod < fftcode_t_mod: codeclass.compile() fft_file = self.file() if specdict['ell'] == 0: # Monopole # command line call FFTcmd = codeclass.commandline_call( DorR = self.type, datafile = self.data_file, fftfile = self.file_name ) if 'clobber' not in (self.kwargs).keys(): bool_clobber = False else: bool_clobber = self.kwargs['clobber'] if any([not os.path.isfile(self.file_name), bool_clobber]): print '' print '-----------------------' print 'Constructing ' print self.file_name print '-----------------------' print '' print FFTcmd print '-----------------------' subprocess.call(FFTcmd.split()) else: print '' print '-----------------------' print self.file_name print 'Already Exists' print '-----------------------' print '' else: # others Quadrupole # command line call FFTcmd = codeclass.commandline_call( DorR = self.type, datafile = self.data_file, fftfile = self.file_name ) if 'clobber' not in (self.kwargs).keys(): bool_clobber = False else: bool_clobber = self.kwargs['clobber'] if any([not os.path.isfile(self.file_name), bool_clobber]): print '' print '-----------------------' print 'Constructing ' print self.file_name print '-----------------------' print '' print FFTcmd print '-----------------------' subprocess.call(FFTcmd.split()) else: print '' print '-----------------------' print self.file_name print 'Already Exists' print '-----------------------' print '' return None
def RandomInterval(k,l): x = Random(l-k+1)+k-1 return x
def main(): """Starts the program""" # check command lines argument count if len(sys.argv) < 3: print("Not enough arguments:\n\tUsage: ./test.py path/to/board" + " random/breadth/depth [amount of tries]") sys.exit(1) # defines how many times a solution is searched for if len(sys.argv) == 4: tries = int(sys.argv[3]) else: tries = 1 # defines the path to the board that needs solving path = str(sys.argv[1]) # counts how many solutions have been found already count = 0 # get start time for basic benchmarking t0 = time.time() # solve using random search if sys.argv[2] == "random": while count < tries: # get current system time time0 = time.time() # sets up a start board from file board = setup_board(path) # creates a random instance random = Random(board) # starts the random algorithm to solve the puzzle random.solve() # count how many solutions have been found count += 1 # solve using breadth first elif sys.argv[2] == "breadth": board = setup_board(path) breadth = Breadth(board) breadth.solve() # solve using depth first elif sys.argv[2] == "depth": board = setup_board(path) depth = Depth(board) depth.solve() # invalid commandline arguments else: print("Usage: ./test.py path/to/board random/breadth/depth" + "[amount of tries]") sys.exit(2) # print benchmark time t1 = time.time() print("Total time: {}".format(t1 - t0))
def get_neighbor(i_in, j_in): neighbor_options = [(-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1)] i_offset, j_offset = Random.get_element(neighbor_options) return i_in + i_offset, j_in + j_offset
def phase5(road_gravity, diffusion_coeff, breed_coeff, z, delta, slope, excld, roads, slope_weights, rt): TimerUtility.start_timer('spr_phase5') nrows = IGrid.nrows ncols = IGrid.ncols total_pixels = nrows * ncols # Determine the total growth count and save the row and col locations of the new growth growth_tracker = [] growth_count = 0 for i in range(total_pixels): if delta[i] > 0: growth_tracker.append((int(i / ncols), i % ncols)) growth_count += 1 # Phase 5: Road Trips # If there is new growth, begin processing road trips if growth_count > 0: for i in range(1 + int(breed_coeff)): """Determine the Max Index into the Global_Road_Seach_Incices Array for road_gravity of 1 we have 8 values for road_gravity of 2 we have 16 values for road_gravity of 3 we have 24 values and so on... if we need to cover N road_gravity values, then the total number of indexed values woud be 8 + 16 + 24 + ... + (8*N) = 8 *(1+2+3+...+N) = 8*(N(1+N))/2 """ int_road_gravity = Spread.get_road_gravity_val(road_gravity) max_search_index = 4 * (int_road_gravity * (1 + int_road_gravity)) max_search_index = max(max_search_index, nrows) max_search_index = max(max_search_index, ncols) # Randomly select a growth pixel to start search for road growth_row, growth_col = Random.get_element(growth_tracker) # Search for road about this growth point road_found, i_road_start, j_road_start = Spread.road_search( growth_row, growth_col, max_search_index, roads) # If there is a road found, then walk along it i_road_end = 0 j_road_end = 0 spread = False if road_found: #print(roads) spread, i_road_end, j_road_end = Spread.road_walk( i_road_start, j_road_start, roads, diffusion_coeff) if spread: urbanized, rt, i_neigh, j_neigh = Spread.urbanize_neighbor( i_road_end, j_road_end, z, delta, slope, excld, slope_weights, UGMDefines.PHASE5G, rt) if urbanized: max_tries = 3 for tries in range(3): urbanized, rt, i_neigh_neigh, j_neigh_neigh = Spread.urbanize_neighbor( i_neigh, j_neigh, z, delta, slope, excld, slope_weights, UGMDefines.PHASE5G, rt) TimerUtility.stop_timer('spr_phase5') return rt
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)
def phase1(drive, urban_land, slope, deltatron, landuse_classes, class_indices, new_indices, class_slope, ftransition): TimerUtility.start_timer('delta_phase1') nrows = IGrid.nrows ncols = IGrid.ncols phase1_land = [] # Copy input land grid into output land grid for urban in urban_land: phase1_land.append(urban) # Try to make Transitions for tries in range(drive): # Select a transition pixel to e center of spreading cluster offset, i_center, j_center = Deltatron.get_rand_landuse_offset() index = new_indices[urban_land[offset]] while not landuse_classes[index].trans: offset, i_center, j_center = Deltatron.get_rand_landuse_offset( ) index = new_indices[urban_land[offset]] # Randomly choose new landuse number new_landuse = Deltatron.get_new_landuse(class_indices, landuse_classes, slope[offset], class_slope) # Test transition probability for new cluster new_i = new_indices[urban_land[offset]] new_j = new_indices[new_landuse] trans_offset = new_i * LandClass.get_num_landclasses() + new_j if Random.get_float() < ftransition[trans_offset]: # Transition the center pixel phase1_land[offset] = new_landuse deltatron[offset] = 1 # Try building up cluster around this center pixel i = i_center j = j_center for regions in range(UGMDefines.REGION_SIZE): # Occasionally Reset to center of cluster random_int = Random.get_int(0, 7) if random_int == 7: i = i_center j = j_center # Get a neighbor i, j = Utilities.get_neighbor(i, j) if 0 <= i < nrows and 0 <= j < ncols: # Test new pixel against transition probability offset = i * ncols + j # print(f"{len(urban_land)} | {i} {j} -> {offset}") urban_index = urban_land[offset] new_i = new_indices[urban_index] new_j = new_indices[new_landuse] trans_offset = new_i * LandClass.get_num_landclasses( ) + new_j if Random.get_float() < ftransition[trans_offset]: # If the immediate pixel is allowed to transition, then change it index = new_indices[urban_land[offset]] if landuse_classes[index].trans: phase1_land[offset] = new_landuse deltatron[offset] = 1 # Try to transition a neighboring pixel i, j = Utilities.get_neighbor(i, j) if 0 <= i < nrows and 0 <= j < ncols: offset = i * ncols + j index = new_indices[urban_land[offset]] if landuse_classes[index].trans: phase1_land[offset] = new_landuse deltatron[offset] = 1 TimerUtility.stop_timer('delta_phase1') return phase1_land
def which_way_to_turn(self): # create a random number generator rand = Random() if self.intersectionID == predefines.INTERSECTION1: # can't be coming down if self.direction == predefines.UP: # can go down, left, or right self.path = rand.og_randint(1, 3) elif self.direction == predefines.LEFT: # down, left or up self.path = rand.og_randint(0, 2) elif self.direction == predefines.RIGHT: # up, down, or right self.path = rand.skip_randint(0, 3, 2) else: return elif self.intersectionID == predefines.INTERSECTION2: # can't be coming right if self.direction == predefines.UP: # can go up, down, or right self.path = rand.skip_randint(0, 3, 2) elif self.direction == predefines.DOWN: # up, down, left self.path = rand.og_randint(0, 2) elif self.direction == predefines.LEFT: # down, left, right self.path = rand.og_randint(1, 3) else: return elif self.intersectionID == predefines.INTERSECTION3: # can go anywhere self.path = rand.og_randint(0, 3) # up, down, left, right elif self.intersectionID == predefines.INTERSECTION4: # can't be coming left if self.direction == predefines.UP: # can go up, down, or left self.path = rand.og_randint(0, 2) elif self.direction == predefines.DOWN: # up, down, right self.path = rand.skip_randint(0, 3, 2) elif self.direction == predefines.RIGHT: # down, left, right self.path = rand.og_randint(1, 3) else: return elif self.intersectionID == predefines.INTERSECTION5: # can't be coming up if self.direction == predefines.RIGHT: # can go up, down, or right self.path = rand.og_randint(0, 2) elif self.direction == predefines.DOWN: # down, left, right (can't go up) self.path = rand.og_randint(1, 3) elif self.direction == predefines.LEFT: # up, down, left self.path = rand.skip_randint(0, 3, 2) else: return else: return
def phase2(urban_land, phase1_land, deltatron, landuse_classes, new_indices, ftransition): TimerUtility.start_timer('delta_phase2') nrows = IGrid.nrows ncols = IGrid.ncols phase2_land = [] # Copy current land to phase2_land for pixel in phase1_land: phase2_land.append(pixel) # For each interior point for i in range(1, nrows - 1): for j in range(1, ncols - 1): offset = i * ncols + j index = new_indices[phase1_land[offset]] if landuse_classes[index].trans and deltatron[offset] == 0: """ I,J is a Transitional Pixel which was not transitioned within the last min_years_between_transitions years; count its neighbors which have transitioned in previous year (IE Deltatron == 2) """ deltatron_neighbors = Deltatron.count_neighbor( deltatron, i, j) random_int = 1 + Random.get_int(0, 1) if deltatron_neighbors >= random_int: max_tries = 16 for tries in range(max_tries): i_neigh, j_neigh = Utilities.get_neighbor(i, j) offset_neigh = i_neigh * ncols + j_neigh index = new_indices[phase1_land[offset_neigh]] if deltatron[offset_neigh] == 2 and landuse_classes[ index]: trans_i = new_indices[phase2_land[offset]] trans_j = new_indices[urban_land[offset_neigh]] offset_trans = trans_i * LandClass.get_num_landclasses( ) + trans_j if Random.get_float( ) < ftransition[offset_trans]: phase2_land[offset] = urban_land[ offset_neigh] deltatron[offset] = 1 break if Scenario.get_scen_value('view_deltatron_aging'): if IGrid.using_gif: filename = f"{Scenario.get_scen_value('output_dir')}deltatron_{Processing.get_current_run()}_" \ f"{Processing.get_current_monte()}_{Processing.get_current_year()}.gif" else: filename = f"{Scenario.get_scen_value('output_dir')}deltatron_{Processing.get_current_run()}_" \ f"{Processing.get_current_monte()}_{Processing.get_current_year()}.tif" date = f"{Processing.get_current_year()}" ImageIO.write_gif(deltatron, Color.get_deltatron_table(), filename, date, nrows, ncols) # Age the Deltatrons for i in range(nrows * ncols): if deltatron[i] > 0: deltatron[i] += 1 # Kill old deltatrons Utilities.condition_gt_gif(deltatron, UGMDefines.MIN_YEARS_BETWEEN_TRANSITIONS, deltatron, 0) TimerUtility.stop_timer("delta_phase2") return phase2_land