def __new__(mcs, name, bases, dict): def gen_test_array_equal(a,b): def test(self): self.assertTrue(np.array_equal(a, b)) return test config = CAConfig('test/testdescriptions/2dbasic.py') dimensions = 2 config.states = 0,1,2 config.nhood_arr = [1,1,1] def transfunc(self, grid, neighbourcounts): return grid #matching dimensions config.grid_dims = (20,20) testname = "test_gridset_2d_{i}{j}".format(i=config.grid_dims[0], j=config.grid_dims[1]) config.initial_grid = np.random.randint(0, 3, config.grid_dims) g = Grid2D(config, transfunc) dict[testname] = gen_test_array_equal(g.grid, config.initial_grid) #non matching testsize = [(19,20), (20,21), (21,21), (19,19)] for s in testsize: testname = "test_gridset_2d_{i}{j}".format(i=s[0], j=s[1]) config.grid_dims = s ig = np.random.randint(0, 3, s) config.initial_grid = ig g = Grid2D(config, transfunc) if s < config.grid_dims: dict[testname] = gen_test_array_equal(g.grid[:s[0], :s[1]], ig) else: dict[testname] = gen_test_array_equal(g.grid, ig[:config.grid_dims[0], :config.grid_dims[1]]) return type.__new__(mcs, name, bases, dict)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) # Create grid object using parameters from config + transition function grid = Grid2D(config, transition_function) global fuel_grid, ignition_grid, wind_NS, wind_WE fn_fuel = partial(switcheroo, value_key="fuel_capacity", default=1) fuel_grid = grid_mapper(fn_fuel, grid.grid) fn_ignition = partial(switcheroo, value_key="ignition_threshold", default=0) ignition_grid = grid_mapper(fn_ignition, grid.grid) wind_NS = 1 wind_WE = -1 # # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object config = setup(sys.argv[1:]) chaparral = np.zeros(config.grid_dims) area1 = np.zeros(config.grid_dims) area2 = np.zeros(config.grid_dims) decay_grid = np.zeros(config.grid_dims) # decay grid -100 = lake decay_grid[:, :] = 40 decay_grid[0:3, 197:200] = 10 decay_grid[40:60, 20:60] = -100 decay_grid[120:160, 60:100] = 320 decay_grid[20:140, 130:140] = 8 print(decay_grid) print(decay_grid.shape) # Create grid object grid = Grid2D(config, (transition_func, chaparral, decay_grid)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) #sets default num of ticks for chaparral and forest to ignite chap_ignition = np.zeros(config.grid_dims) chap_ignition.fill(2) forest_ignition = np.zeros(config.grid_dims) forest_ignition.fill(6) #sets default fuel for chaparral and other states can be adjusted later fuel_reserves = np.zeros(config.grid_dims) fuel_reserves.fill(10) # Create grid object using parameters from config + transition function #added forest_ignition and fuel_reserves as arguements grid = Grid2D( config, (transition_function, chap_ignition, forest_ignition, fuel_reserves)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" global args args = parser.parse_args() wind = np.array(args.wind).reshape((8,1,1)) # Get the config object from set up config = setup([args.config, *args.system]) # Create grid object using parameters from config + transition function data = config.initial_grid.astype(int) grid = Grid2D(config, (transition_function, data == Terrain.BURNING, np.array([0, 0, 0, 8.0, 48.0, 720.0])[data], # Fuel np.array([0, 0, 0, .41, .40, .03])[data], # Ignition probability wind )) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) decaygrid = np.zeros(config.grid_dims) decaygrid.fill(20 / (coef * coef)) decaygrid[5 * coef:35 * coef, 32 * coef:35 * coef] = (4 / (coef * coef)) decaygrid[30 * coef:41 * coef, 15 * coef:25 * coef] = (300 / (coef * coef)) # Set up fuel probability for each cell fuelgrid = np.random.random(config.grid_dims) # Multiply fuel probality with decay constant fuel_prob_grid = np.multiply(decaygrid, fuelgrid) fuel_prob_grid = np.round(fuel_prob_grid, 0) print(fuel_prob_grid) # Create grid object using parameters from config + transition function grid = Grid2D(config, (transition_function, fuel_prob_grid)) # Run the CA, save grid state every generation to line timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) # Create grid object using parameters from config + transition function fire_chance_chap = np.zeros(config.grid_dims) fire_chance_df = np.zeros(config.grid_dims) fire_chance_canyon = np.zeros(config.grid_dims) burnt_up_chap = np.zeros(config.grid_dims) burnt_up_chap.fill(100) burnt_up_df = np.zeros(config.grid_dims) burnt_up_df.fill(100) burnt_up_canyon = np.zeros(config.grid_dims) burnt_up_canyon.fill(100) wind = np.zeros(config.grid_dims) grid = Grid2D(config, (transition_function, fire_chance_chap, fire_chance_df, fire_chance_canyon, burnt_up_chap, burnt_up_df, burnt_up_canyon, wind)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object config = setup(sys.argv[1:]) #Define fuel parameter matrix ( 1 = 1.5hours ) fuel_parameter = np.full((200, 200), 34) #2.1 days for i in range(128, 144): for j in range(20, 144): fuel_parameter[j][i] = 4 #6 hours #Setting fuel for forest. #Extending dense forest in 4 direcions. #The appropriate lines of code need to be commented out. #for i in range(17, 104): #Extend East ( overlaps canyon ) #for i in range(60, 147): #Extend West for i in range(60, 104): #No extention W/E #for j in range(72, 168): #Extend north #for j in range(120, 200): #Extend south ( cannot double area ) for j in range(120, 168): #No extention N/S fuel_parameter[j][i] = 400 #25 days for i in range(196, 200): for j in range(0, 8): fuel_parameter[i][j] = 1 #Define water break coordinate matrix water_break = np.zeros((200, 200)) #for i in range(0,41): for i in range(155, 195): for j in range(5, 46): #for j in range(140,181): water_break[j][i] = 1 #Define fire break coordinate matrix fire_break = np.zeros((200, 200)) for i in range(190, 195): for j in range(0, 20): fire_break[i][j] = 1 for i in range(190, 200): for j in range(20, 25): fire_break[i][j] = 1 # Create grid object grid = Grid2D(config, (transition_func, fuel_parameter, water_break, fire_break)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object config = setup(sys.argv[1:]) # Initilise decay grid decaygrid = np.zeros(config.grid_dims) # Initilise wind grid windgrid = np.zeros(config.grid_dims) delaygrid = np.ones(config.grid_dims) for y in range(120, 161): for x in range(60, 101): delaygrid[y][x] = 0.02 #Random Grid randomgrid = np.zeros(config.grid_dims) for x in range(randomgrid.shape[0]): for y in range(randomgrid.shape[0]): randomgrid[x][y] = random.random() probabilitygrid = np.zeros(config.grid_dims) #Terrain Grid terraingrid = np.zeros(config.grid_dims) for y in range(40, 61): for x in range(20, 61): terraingrid[y][x] = 1 # gollum lives in this forest for y in range(120, 161): for x in range(60, 101): terraingrid[y][x] = 2 for y in range(20, 141): for x in range(128, 141): terraingrid[y][x] = 3 # Create grid object grid = Grid2D(config, (transition_func, decaygrid, randomgrid, terraingrid, probabilitygrid, windgrid, delaygrid)) #grid = Grid2D(config, transition_func) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object config = setup(sys.argv[1:]) # Create grid object grid = Grid2D(config, transition_func) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): config = setup(sys.argv[1:]) ext_grid = [[ext_val[i] for i in j] for j in start_grid.astype(int)] ext_grid = np.array(ext_grid) ignition_grid = np.zeros((GRID_SIZE, GRID_SIZE)) ignition_grid = ignition_grid.astype(int) grid = Grid2D(config, (transition_function, ext_grid)) timeline = grid.run() config.save() utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) # Create grid object using parameters from config + transition function grid = Grid2D(config, transition_function) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def case(self, gridshape): #fill with random values from 0 - 2 self.config.grid_dims = gridshape self.config.initial_grid = np.random.randint(0,3, gridshape) g = Grid2D(self.config, self.transfunc) self.assertTrue(self.iswrapcorrect(g)) #set outer values to 4 which cannot already be in the grid and verify match again g.grid[0, :] = 4 g.grid[-1, :] = 4 g.grid[:, 0] = 4 g.grid[:, -1] = 4 self.assertFalse(self.iswrapcorrect(g)) g.refresh_wrap() self.assertTrue(self.iswrapcorrect(g))
def main(): # NOTE: set the wind here if doing it programatically # Default: light prevaling wind southward wind_x = 0.0 wind_y = -0.2 # if passed extra command-line args, assumed it's for custom wind if (len(sys.argv) == 4): wind_x = float(sys.argv[2]) wind_y = float(sys.argv[3]) # Open the config object config = setup(sys.argv[1:]) ignition_level = np.zeros((grid_axis, grid_axis)) fuel_level = np.zeros((grid_axis, grid_axis)) #Set fuel resource for each cell based on terrain fuel_level = np.vectorize(terrain_fuel_level.get, otypes=['float64'])(terrain_numbers) #Set ignition Threshold for each cell based on terrain ignition_level = np.vectorize(terrain_ignition_threshold.get, otypes=['float64'])(terrain_numbers) #Set starting point of fire if power_plant: terrain_numbers[0 + offset, 0 + offset] = 5 if incinerator: terrain_numbers[0 + offset, 49 + offset] = 5 #Setup water water drop params ((x1,y1,x2,y2), start_timestep, end_timestep) water_drops = [ ((5 + offset, 0 + offset, 15 + offset, 8 + offset), 97, 107), ((20 + offset, 10 + offset, 25 + offset, 20 + offset), 230, 240) ] timestep = np.array([0]) # Create grid object grid = Grid2D(config, (get_transition_func( wind_x, wind_y), ignition_level, fuel_level, water_drops, timestep)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # declare global grids information global fuel_grid, ignition_grid, neighbour_multipliers, counter counter = 0 print("Start of new simulation") # Get the config object from set up config = setup(sys.argv[1:]) # Create grid object using parameters from config + transition function grid = Grid2D(config, transition_function) # create grid containing all cells' fuel capacities fn_fuel = partial(switcheroo, value_key="fuel_capacity", default=1) fuel_grid = grid_mapper(fn_fuel, grid.grid) # create grid containing all cells' ignition thresholds # (or flammability values) fn_ignition = partial(switcheroo, value_key="ignition_threshold", default=0) ignition_grid = grid_mapper(fn_ignition, grid.grid) # set the maximum value of neighbours for the fire spread multiplier neighbour_multipliers = np.zeros((GRID_SIZE, GRID_SIZE)) neighbour_multipliers.fill(6) neighbour_multipliers[0].fill(4) neighbour_multipliers[GRID_SIZE - 1].fill(4) for row in range(0, GRID_SIZE): if row == 0 or row == GRID_SIZE - 1: neighbour_multipliers[row][0] = 2.5 neighbour_multipliers[row][GRID_SIZE - 1] = 2.5 else: neighbour_multipliers[row][0] = 4 neighbour_multipliers[row][GRID_SIZE - 1] = 4 # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): #take the config path config = setup(sys.argv[1:]) #Create grid object grid = Grid2D(gridsize=config.grid_dims, states=config.states, neighbourhood=config.neighbourhood(), transition_func=transition_func, initial_grid=config.initial_grid) #Run the CA, save grid state every generation to timeline timeline = grid.run(config.num_generations) #save updated config to file config.save() #save timeline to file utils.save(timeline, config.timeline_path)
def run_iter(fire_start=(0, 0)): config = setup(["temp/config.pkl"]) # config.initial_grid[0][0] = 0 # config.initial_grid[0][-1] = 0 config.initial_grid[fire_start[0]][fire_start[1]] = 4 initial = config.initial_grid dgrid = fuelConfig(initial, config) fgrid = flamConfig(initial, config) mgrid = moisConfig(initial, config) grid = Grid2D(config, (transition_function, dgrid, fgrid, mgrid)) i = 0 while grid.grid[-1, 0] != 4: grid.step() i += 1 return i
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) # Create grid object using parameters from config + transition function decaygrid = np.zeros(config.grid_dims) decaygrid.fill(4000) firegrid = np.zeros(config.grid_dims) firegrid.fill(1) grid = Grid2D(config, (transition_function, decaygrid, firegrid)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) initial = config.initial_grid decaygrid = fuelConfig(initial, config) fgrid = flamConfig(initial, config) mgrid = moisConfig(initial, config) # Create grid object using parameters from config + transition function grid = Grid2D(config, (transition_function, decaygrid, fgrid, mgrid)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object windSpeed = 2 # initial arbitrary value config = setup(sys.argv[1:]) fuelCount = np.zeros(config.grid_dims) fuelCount.fill(-1) windBias = np.zeros(config.grid_dims) moisture = np.zeros(config.grid_dims) # Create grid object grid = Grid2D(config, (transition_func, fuelCount, windBias, windSpeed, moisture)) #fuelCount = np.zeros(grid.shape[0], grid.shape[1]) #print("GRID", type(grid)) # Run the CA, save grid state every generation to timeline timeline = grid.run() #print("TIMELINE", timeline) # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): config = setup(sys.argv[1:]) s = -10000 decay_grid = [[decay_values[i] for i in row] for row in initial_grid.astype(int)] decay_grid = np.array(decay_grid) water_decay_values = [s, s, s, s, s] water_decay_grid = np.array([[water_decay_values[i] for i in row] for row in initial_grid.astype(int)]) #Select section of grid to drop water water_decay_grid[120:160, 80:120] = 0 #drop water after this time ignition_grid = np.zeros((grid_size, grid_size)) ignition_grid = ignition_grid.astype(int) grid = Grid2D(config, (transition_function, decay_grid, water_decay_grid)) # Create grid object using parameters from config + transition function # Run the CA, save grid state every generation to timeline timeline = grid.run() config.save() # Save updated config to file utils.save(timeline, config.timeline_path) # Save timeline to file
def main(): # Open the config object config = setup(sys.argv[1:]) #create intial matrix values numValues = np.zeros(config.grid_dims) initNumValues = np.zeros(config.grid_dims) # setting base numbers forestl, forestr = 60, 30 canl, canr = 10, 64 townl, townr = 98, 0 numValues.fill(0.2) numValues[forestl:forestl + 20, forestr:forestr + 22] = 1.9 numValues[canl:canl + 60, canr:canr + 6] = 1.4 numValues[townl:townl + 2, townr:townr + 5] = -2 initNumValues = numValues #Creating the water drop matrix waterDrop = np.zeros(config.grid_dims) waterDrop.fill(-1) reactionTime = 100 #specify the location and time of the water drop waterDrop[0:40, 20] = reactionTime grid = Grid2D(config, (transition_func, numValues, waterDrop, initNumValues)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object config = setup(sys.argv[1:]) # time until the burning square is burnt out decaygrid_for_chaparral = np.zeros(config.grid_dims) decaygrid_for_chaparral.fill(120) decaygrid_for_grassland = np.zeros(config.grid_dims) decaygrid_for_grassland.fill(250) decaygrid_for_forest = np.zeros(config.grid_dims) decaygrid_for_forest.fill(800) grid = Grid2D(config, (transition_func, decaygrid_for_chaparral, decaygrid_for_grassland, decaygrid_for_forest)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
def main(): """ Main function that sets up, runs and saves CA""" # Get the config object from set up config = setup(sys.argv[1:]) grid_attribs = np.zeros((*config.grid_dims, 5)) # 0: Height - Scalar value # 1: Wind/Magnitude - East to West # 2: Flammability # 3: Humidity? # 4: Fuel grid_attribs[...] = (0, 0.1, 0.1, 0, 1) # Create grid object using parameters from config + transition function grid = Grid2D(config, (transition_function, grid_attribs)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def test(self): config.grid_dims = d g = Grid2D(config, transfunc) self.assertIsInstance(g, Grid2D) self.assertEqual(g.grid.shape, expectedshape)
def test(self): config.grid_dims = d l = lambda c=config: Grid2D(c, transfunc) self.assertRaises(ValueError, l)
def main(): """ Main function that sets up, runs and saves CA""" config = setup(sys.argv[1:]) wind_x = 0.001 wind_y = 0.001 grid_attribs = np.zeros((*config.grid_dims, 20)) time_to_drop = np.array([295]) # 0: Height - Scalar value # 1: Flammability # 2: Humidity? # 3: Fuel # 4-12: wind_spread_weights grid_attribs[:, :, 0] = 0 grid_attribs[:, :, 1] = 1 grid_attribs[:, :, 2] = 0 grid_attribs[:, :, 3] = 20 grid_attribs[:, :, 4:12] = cal_wind_spread_vectors(wind_x, wind_y) config.initial_grid = np.ones(config.grid_dims) size_y, size_x = config.initial_grid.shape #Ariel drop #Pond config.initial_grid[int(0.2 * size_y):int(0.3 * size_y), int(0.1 * size_x):int(0.3 * size_x)] = 6 #Fire config.initial_grid[0, 0] = 4 #Town town_x_coords = [0, int(0.05 * size_x)] town_y_coords = [int(0.95 * size_y), size_y - 1] config.initial_grid[town_y_coords[0]:town_y_coords[1], town_x_coords[0]:town_x_coords[1]] = 5 #Dense Forest d_forest_x_coords = [int(0.3 * size_x), int(0.5 * size_x)] d_forest_y_coords = [int(0.6 * size_y), int(0.81 * size_y)] config.initial_grid[d_forest_y_coords[0]:d_forest_y_coords[1], d_forest_x_coords[0]:d_forest_x_coords[1]] = 2 grid_attribs[d_forest_y_coords[0]:d_forest_y_coords[1], d_forest_x_coords[0]:d_forest_x_coords[1], 1] = 0.2 grid_attribs[d_forest_y_coords[0]:d_forest_y_coords[1], d_forest_x_coords[0]:d_forest_x_coords[1], 3] = 30 #Scrubland scrubland_x_coords = [int(0.65 * size_x), int(0.7 * size_x)] scrubland_y_coords = [int(0.1 * size_y), int(0.7 * size_y)] config.initial_grid[scrubland_y_coords[0]:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1]] = 3 grid_attribs[scrubland_y_coords[0]:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 1] = 3 grid_attribs[scrubland_y_coords[0]:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 3] = 10 #top slope of cayon grid_attribs[scrubland_y_coords[0] + 5:scrubland_y_coords[0], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -1 grid_attribs[scrubland_y_coords[0] + 4:scrubland_y_coords[0], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -125.75 grid_attribs[scrubland_y_coords[0] + 3:scrubland_y_coords[0], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -250.5 grid_attribs[scrubland_y_coords[0] + 2:scrubland_y_coords[0], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -375.25 grid_attribs[scrubland_y_coords[0] + 1:scrubland_y_coords[0], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -500 #bottom slope of cayon grid_attribs[scrubland_y_coords[1] - 1:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -1 grid_attribs[scrubland_y_coords[1] - 2:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -125.75 grid_attribs[scrubland_y_coords[1] - 3:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -250.5 grid_attribs[scrubland_y_coords[1] - 4:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -375.25 grid_attribs[scrubland_y_coords[1] - 5:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -500 #sides of cayon grid_attribs[scrubland_y_coords[0]:scrubland_y_coords[1], scrubland_x_coords[0]:scrubland_x_coords[1], 0] = -500 transitions = [[1, 1], [0, 1], [-1, 1], [1, 0], [0, -1], [1, -1], [0, -1], [-1, -1]] height_neighbours = np.zeros((*config.grid_dims, 8)) for i in range(grid_attribs.shape[0]): for j in range(grid_attribs.shape[1]): for k in range(len(transitions)): x_coord = j - transitions[k][0] y_coord = i - transitions[k][1] if (0 <= x_coord < 200) and (0 <= y_coord < 200): height_neighbours[i][j][k] = grid_attribs[y_coord, x_coord, 0] grid_attribs[:, :, 12:] = height_neighbours # Create grid object using parameters from config + transition function grid = Grid2D(config, (transition_function, time_to_drop, grid_attribs)) # Run the CA, save grid state every generation to timeline timeline = grid.run() # Save updated config to file config.save() # Save timeline to file utils.save(timeline, config.timeline_path)
def main(): # Open the config object config = setup(sys.argv[1:]) fuelCount = np.zeros(config.grid_dims) fuelCount.fill(-1) fuelCount[(config.initial_grid == 1)] = 45000 #windBias = np.zeros(config.grid_dims) #print(config.grid_dims) # low and high wind speed windSpeed = 2 moisture = np.zeros(config.grid_dims) terrainBias = np.zeros(config.grid_dims) #NW, N, NE, W, E, SW, S, SE = neighbourstates w1 = 2 # next closest to wind direction w2 = 3 # in the direction of wind w3 = 0.9 # next closes to opposite w4 = 0.4 # parralel with wind w5 = 0.7 # the opposite from the direction # North #windBias = [w1, w2, w1, w4, w4, w3, w5, w3] # South windBias = [w3, w5, w3, w4, w4, w1, w2, w1] # West #windBias = [w1, w4, w3, w2, w5, w1, w4, w3] #East #windBias = [w3, w4, w1, w5, w2, w3, w4, w1] # NW #windBias = [w2, w1, w4, w1, w3, w4, w3, w5] # NE #windBias = [w4, w1, w2, w3, w1, w5, w3, w4] # SW #windBias = [w4, w3, w5, w1, w3, w2, w1, w4] # SE #windBias = [w5, w3, w4, w3, w1, w4, w1, w2] #windBias = [1,1,1,1,1,1,1,1] #if(wind == 'NE'): #windBias = windBias[-1:] + windBias[:-1] #elif('W'): #windBias = windBias[-2:] + windBias[:-2] #elif('E'): #windBias = windBias[-3:] + windBias[:-3] #elif('SW'): #windBias = windBias[-4:] + windBias[:-4] #elif('S'): #windBias = windBias[-5:] + windBias[:-5] #elif('SE'): #windBias = windBias[-6:] + windBias[:-6] #elif('NW'): #windBias = windBias[-7:] + windBias[:-7] #print(windBias) # Create grid object grid = Grid2D(config, (transition_func, fuelCount, windBias, moisture, config.initial_grid, terrainBias, windSpeed)) #fuelCount = np.zeros(grid.shape[0], grid.shape[1]) #print("GRID", type(grid)) # Run the CA, save grid state every generation to timeline timeline = grid.run() #print("TIMELINE", timeline) # save updated config to file config.save() # save timeline to file utils.save(timeline, config.timeline_path)
return np.exp(0.1783 * speed * np.cos(np.deg2rad(angle))) def main(): config = setup(sys.argv[1:]) s = -10000 decay_grid = [[decay_values[i] for i in row] for row in initial_grid.astype(int)] decay_grid = np.array(decay_grid) water_decay_values = [s, s, s, s, s] water_decay_grid = np.array([[water_decay_values[i] for i in row] for row in initial_grid.astype(int)]) #Select section of grid to drop water water_decay_grid[120:160, 80:120] = 0 #drop water after this time ignition_grid = np.zeros((grid_size, grid_size)) ignition_grid = ignition_grid.astype(int) grid = Grid2D(config, (transition_function, decay_grid, water_decay_grid)) # Create grid object using parameters from config + transition function # Run the CA, save grid state every generation to timeline timeline = grid.run() config.save() # Save updated config to file utils.save(timeline, config.timeline_path) # Save timeline to file if __name__ == "__main__": main()