def main():
# INITIALIZE
# User-defined parameters
nr = 41
nc = 61
g = 0.8
f = 1.0
silo_y0 = 30.0
silo_opening_half_width = 6
plot_interval = 1.0
run_duration = 80.0
report_interval = 5.0 # report interval, in real-time seconds
p_init = 0.4 # probability that a cell is occupied at start
plot_every_transition = False
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0, orientation='vertical', reorient_links=True)
# Set up the states and pair transitions.
# Transition data here represent particles moving on a lattice: one state
# per direction (for 6 directions), plus an empty state, a stationary
# state, and a wall state.
ns_dict = { 0 : 'empty',
1 : 'moving up',
2 : 'moving right and up',
3 : 'moving right and down',
4 : 'moving down',
5 : 'moving left and down',
6 : 'moving left and up',
7 : 'rest',
8 : 'wall'}
xn_list = setup_transition_list(g, f)
# Create data and initialize values.
node_state_grid = hmg.add_zeros('node', 'node_state_grid')
# Make the grid boundary all wall particles
node_state_grid[hmg.boundary_nodes] = 8
# Place wall particles to form the base of the silo, initially closed
tan30deg = numpy.tan(numpy.pi/6.)
rampy1 = silo_y0-hmg.node_x*tan30deg
rampy2 = silo_y0-((nc*0.866-1.)-hmg.node_x)*tan30deg
rampy = numpy.maximum(rampy1, rampy2)
(ramp_nodes, ) = numpy.where(numpy.logical_and(hmg.node_y>rampy-0.5, \
hmg.node_y<rampy+0.5))
node_state_grid[ramp_nodes] = 8
# Seed the grid interior with randomly oriented particles
for i in hmg.core_nodes:
if hmg.node_y[i]>rampy[i] and random.random()<p_init:
node_state_grid[i] = random.randint(1, 7)
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
# Run with closed silo
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=plot_every_transition, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# Open the silo
xmid = nc*0.866*0.5
for i in range(hmg.number_of_nodes):
if node_state_grid[i]==8 and hmg.node_x[i]>(xmid-silo_opening_half_width) \
and hmg.node_x[i]<(xmid+silo_opening_half_width) \
and hmg.node_y[i]>0:
node_state_grid[i]=0
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# Re-run with open silo
current_time = 0.0
while current_time < 5*run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=plot_every_transition, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 128
nc = 128
fracture_spacing = 10 # fracture spacing, cell widths
plot_interval = 0.25
run_duration = 4.0
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create grid
mg = RasterModelGrid(nr, nc, 1.0)
# Set up the states and pair transitions.
# Transition data here represent a body of fractured rock, with rock
# represented by nodes with state 0, and saprolite (weathered rock)
# represented by nodes with state 1. Node pairs (links) with 0-1 or 1-0
# can undergo a transition to 1-1, representing chemical weathering of the
# rock.
ns_dict = { 0 : 'rock', 1 : 'saprolite' }
xn_list = setup_transition_list()
# Create the node-state array and attach it to the grid
node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
# Initialize the node-state array as a "fracture grid" in which randomly
# oriented fractures are represented as lines of saprolite embedded in
# bedrock.
node_state_grid[:] = make_frac_grid(fracture_spacing, model_grid=mg)
# Create the CA model
ca = RasterLCA(mg, ns_dict, xn_list, node_state_grid)
# Debug output if needed
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print('{0:.0f}'.format(ca.node_state[n]), end=' ')
print()
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print('Current sim time',current_time,'(',100*current_time/run_duration,'%)')
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=False) #, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# for debugging
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print('{0:.0f}'.format(ca.node_state[n]), end=' ')
print()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 21
nc = 21
plot_interval = 0.5
run_duration = 25.0
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0, orientation='vertical', reorient_links=True)
# Close the grid boundaries
hmg.set_closed_nodes(hmg.open_boundary_nodes)
# Set up the states and pair transitions.
# Transition data here represent the disease status of a population.
ns_dict = { 0 : 'fluid', 1 : 'grain' }
xn_list = setup_transition_list()
# Create data and initialize values. We start with the 3 middle columns full
# of grains, and the others empty.
node_state_grid = hmg.add_zeros('node', 'node_state_grid')
middle = 0.25*(nc-1)*sqrt(3)
is_middle_cols = logical_and(hmg.node_x<middle+1., hmg.node_x>middle-1.)
node_state_grid[where(is_middle_cols)[0]] = 1
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=False)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 41
nc = 61
g = 0.8
f = 1.0
plot_interval = 1.0
run_duration = 200.0
report_interval = 5.0 # report interval, in real-time seconds
p_init = 0.4 # probability that a cell is occupied at start
plot_every_transition = False
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr,
nc,
1.0,
orientation='vertical',
reorient_links=True)
# Close the grid boundaries
#hmg.set_closed_nodes(hmg.open_boundary_nodes)
# Set up the states and pair transitions.
# Transition data here represent particles moving on a lattice: one state
# per direction (for 6 directions), plus an empty state, a stationary
# state, and a wall state.
ns_dict = {
0: 'empty',
1: 'moving up',
2: 'moving right and up',
3: 'moving right and down',
4: 'moving down',
5: 'moving left and down',
6: 'moving left and up',
7: 'rest',
8: 'wall'
}
xn_list = setup_transition_list(g, f)
# Create data and initialize values.
node_state_grid = hmg.add_zeros('node', 'node_state_grid')
# Make the grid boundary all wall particles
node_state_grid[hmg.boundary_nodes] = 8
# Seed the grid interior with randomly oriented particles
for i in hmg.core_nodes:
if random.random() < p_init:
node_state_grid[i] = random.randint(1, 7)
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time', current_time, '(', 100 * current_time / run_duration, '%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time + plot_interval,
ca.node_state,
plot_each_transition=plot_every_transition,
plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 10
nc = 10
plot_interval = 0.25
run_duration = 40.0
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create grid
mg = RasterModelGrid(nr, nc, 1.0)
mg.set_closed_boundaries_at_grid_edges(True, True, True, True)
# Set up the states and pair transitions.
# Transition data here represent a body of fractured rock, with rock
# represented by nodes with state 0, and saprolite (weathered rock)
# represented by nodes with state 1. Node pairs (links) with 0-1 or 1-0
# can undergo a transition to 1-1, representing chemical weathering of the
# rock.
ns_dict = { 0 : 'air', 1 : 'particle' }
xn_list = setup_transition_list()
# Create the node-state array and attach it to the grid
node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
node_state_grid[where(mg.node_y>nr-3)[0]] = 1
# Create the CA model
ca = OrientedRasterLCA(mg, ns_dict, xn_list, node_state_grid)
#ca = RasterLCA(mg, ns_dict, xn_list, node_state_grid)
# Debug output if needed
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print '{0:.0f}'.format(ca.node_state[n]),
print
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
updated = False
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=False) #, plotter=ca_plotter)
current_time += plot_interval
# Add a bunch of particles
if current_time > run_duration/2. and not updated:
print 'updating...'
node_state_grid[where(ca.grid.node_y>(nc/2.0))[0]] = 1
ca.update_link_states_and_transitions(current_time)
updated = True
# Plot the current grid
ca_plotter.update_plot()
# for debugging
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print '{0:.0f}'.format(ca.node_state[n]),
print
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 80 # number of rows in grid
nc = 50 # number of columns in grid
plot_interval = 0.5 # time interval for plotting, sec
run_duration = 0.0 # duration of run, sec
report_interval = 10.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create grid
mg = RasterModelGrid(nr, nc, 1.0)
# Make the boundaries be walls
mg.set_closed_boundaries_at_grid_edges(True, True, True, True)
# Set up the states and pair transitions.
ns_dict = { 0 : 'fluid', 1 : 'particle' }
xn_list = setup_transition_list()
# Create the node-state array and attach it to the grid
node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
# Initialize the node-state array: here, the initial condition is a pile of
# resting grains at the bottom of a container.
bottom_rows = where(mg.node_y<0.1*nr)[0]
node_state_grid[bottom_rows] = 1
# For visual display purposes, set all boundary nodes to fluid
node_state_grid[mg.closed_boundary_nodes] = 0
# Create the CA model
ca = RasterLCA(mg, ns_dict, xn_list, node_state_grid)
grain = '#5F594D'
fluid = '#D0E4F2'
clist = [fluid,grain]
my_cmap = matplotlib.colors.ListedColormap(clist)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca, cmap=my_cmap)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=False)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 20
nc = 20
plot_interval = 2.0
run_duration = 2.0
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0)
# Set up the states and pair transitions.
# Transition data here represent the disease status of a population.
ns_dict = { 0 : 'susceptible', 1 : 'infectious', 2: 'recovered' }
xn_list = setup_transition_list()
# Create data and initialize values
node_state_grid = hmg.add_zeros('node', 'node_state_grid')
wid = nc-1.0
ht = (nr-1.0)*0.866
is_middle_rows = logical_and(hmg.node_y>=0.4*ht, hmg.node_y<=0.5*ht)
is_middle_cols = logical_and(hmg.node_x>=0.4*wid, hmg.node_x<=0.6*wid)
middle_area = where(logical_and(is_middle_rows, is_middle_cols))[0]
node_state_grid[middle_area] = 1
node_state_grid[0] = 2 # to force full color range, set lower left to 'recovered'
# Create the CA model
ca = HexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print('Current sim time',current_time,'(',100*current_time/run_duration,'%)')
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=True, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 128
nc = 128
fracture_spacing = 10 # fracture spacing, cell widths
plot_interval = 0.25
run_duration = 4.0
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create grid
mg = RasterModelGrid(nr, nc, 1.0)
# Set up the states and pair transitions.
# Transition data here represent a body of fractured rock, with rock
# represented by nodes with state 0, and saprolite (weathered rock)
# represented by nodes with state 1. Node pairs (links) with 0-1 or 1-0
# can undergo a transition to 1-1, representing chemical weathering of the
# rock.
ns_dict = {0: 'rock', 1: 'saprolite'}
xn_list = setup_transition_list()
# Create the node-state array and attach it to the grid
node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
# Initialize the node-state array as a "fracture grid" in which randomly
# oriented fractures are represented as lines of saprolite embedded in
# bedrock.
node_state_grid[:] = make_frac_grid(fracture_spacing, model_grid=mg)
# Create the CA model
ca = RasterLCA(mg, ns_dict, xn_list, node_state_grid)
# Debug output if needed
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print '{0:.0f}'.format(ca.node_state[n]),
print
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time', current_time, '(', 100 * current_time / run_duration, '%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time + plot_interval,
ca.node_state,
plot_each_transition=False) #, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# for debugging
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print '{0:.0f}'.format(ca.node_state[n]),
print
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 20
nc = 20
plot_interval = 2.0
run_duration = 2.0
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0)
# Set up the states and pair transitions.
# Transition data here represent the disease status of a population.
ns_dict = {0: 'susceptible', 1: 'infectious', 2: 'recovered'}
xn_list = setup_transition_list()
# Create data and initialize values
node_state_grid = hmg.add_zeros('node', 'node_state_grid')
wid = nc - 1.0
ht = (nr - 1.0) * 0.866
is_middle_rows = logical_and(hmg.node_y >= 0.4 * ht,
hmg.node_y <= 0.5 * ht)
is_middle_cols = logical_and(hmg.node_x >= 0.4 * wid,
hmg.node_x <= 0.6 * wid)
middle_area = where(logical_and(is_middle_rows, is_middle_cols))[0]
node_state_grid[middle_area] = 1
node_state_grid[
0] = 2 # to force full color range, set lower left to 'recovered'
# Create the CA model
ca = HexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time', current_time, '(', 100 * current_time / run_duration, '%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time + plot_interval,
ca.node_state,
plot_each_transition=True,
plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 41
nc = 61
plot_interval = 1.0
run_duration = 100.0
report_interval = 5.0 # report interval, in real-time seconds
p_init = 0.1 # probability that a cell is occupied at start
plot_every_transition = False
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0, orientation='vertical', reorient_links=True)
# Close the grid boundaries
#hmg.set_closed_nodes(hmg.open_boundary_nodes)
# Set up the states and pair transitions.
# Transition data here represent particles moving on a lattice: one state
# per direction (for 6 directions), plus an empty state, a stationary
# state, and a wall state.
ns_dict = { 0 : 'empty',
1 : 'moving up',
2 : 'moving right and up',
3 : 'moving right and down',
4 : 'moving down',
5 : 'moving left and down',
6 : 'moving left and up',
7 : 'rest',
8 : 'wall'}
xn_list = setup_transition_list()
# Create data and initialize values.
node_state_grid = hmg.add_zeros('node', 'node_state_grid', dtype=int)
# Make the grid boundary all wall particles
node_state_grid[hmg.boundary_nodes] = 8
# Seed the grid interior with randomly oriented particles
for i in hmg.core_nodes:
if random.random()<p_init:
node_state_grid[i] = random.randint(1, 7)
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# Create an array to store the numbers of states at each plot interval
nstates = zeros((9, int(run_duration/plot_interval)))
k = 0
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print('Current sim time',current_time,'(',100*current_time/run_duration,'%)')
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=plot_every_transition, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# Record numbers in each state
nstates[:,k] = bincount(node_state_grid)
k += 1
# FINALIZE
# Plot
ca_plotter.finalize()
# Display the numbers of each state
fig, ax = subplots()
for i in range(1, 8):
plot(arange(plot_interval, run_duration+plot_interval, plot_interval), nstates[i,:], label=ns_dict[i])
ax.legend()
xlabel('Time')
ylabel('Number of particles in state')
title('Particle distribution by state')
axis([0, run_duration, 0, 2*nstates[7,0]])
show()
def main():
# INITIALIZE
# User-defined parameters
nr = 80
nc = 80
plot_interval = 2
run_duration = 200
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create grid
mg = RasterModelGrid(nr, nc, 1.0)
# Make the boundaries be walls
mg.set_closed_boundaries_at_grid_edges(True, True, True, True)
# Set up the states and pair transitions.
ns_dict = {0: 'fluid', 1: 'particle'}
xn_list = setup_transition_list()
# Create the node-state array and attach it to the grid
node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
# Initialize the node-state array
middle_rows = where(
bitwise_and(mg.node_y > 0.45 * nr, mg.node_y < 0.55 * nr))[0]
node_state_grid[middle_rows] = 1
# Create the CA model
ca = OrientedRasterLCA(mg, ns_dict, xn_list, node_state_grid)
# Debug output if needed
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print '{0:.0f}'.format(ca.node_state[n]),
print
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time', current_time, '(', 100 * current_time / run_duration, '%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time + plot_interval,
ca.node_state,
plot_each_transition=False) #, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# for debugging
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print '{0:.0f}'.format(ca.node_state[n]),
print
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 80
nc = 80
plot_interval = 2
run_duration = 200
report_interval = 5.0 # report interval, in real-time seconds
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create grid
mg = RasterModelGrid(nr, nc, 1.0)
# Make the boundaries be walls
mg.set_closed_boundaries_at_grid_edges(True, True, True, True)
# Set up the states and pair transitions.
ns_dict = {0: "fluid", 1: "particle"}
xn_list = setup_transition_list()
# Create the node-state array and attach it to the grid
node_state_grid = mg.add_zeros("node", "node_state_map", dtype=int)
# Initialize the node-state array
middle_rows = where(bitwise_and(mg.node_y > 0.45 * nr, mg.node_y < 0.55 * nr))[0]
node_state_grid[middle_rows] = 1
# Create the CA model
ca = OrientedRasterLCA(mg, ns_dict, xn_list, node_state_grid)
# Debug output if needed
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print("{0:.0f}".format(ca.node_state[n]), end=" ")
print()
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print("Current sim time", current_time, "(", 100 * current_time / run_duration, "%)")
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time + plot_interval, ca.node_state, plot_each_transition=False) # , plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# for debugging
if _DEBUG:
n = ca.grid.number_of_nodes
for r in range(ca.grid.number_of_node_rows):
for c in range(ca.grid.number_of_node_columns):
n -= 1
print("{0:.0f}".format(ca.node_state[n]), end=" ")
print()
# FINALIZE
# Plot
ca_plotter.finalize()
def main():
# INITIALIZE
# User-defined parameters
nr = 41
nc = 61
plot_interval = 1.0
run_duration = 100.0
report_interval = 5.0 # report interval, in real-time seconds
p_init = 0.1 # probability that a cell is occupied at start
plot_every_transition = False
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0, orientation='vertical', reorient_links=True)
# Close the grid boundaries
#hmg.set_closed_nodes(hmg.open_boundary_nodes)
# Set up the states and pair transitions.
# Transition data here represent particles moving on a lattice: one state
# per direction (for 6 directions), plus an empty state, a stationary
# state, and a wall state.
ns_dict = { 0 : 'empty',
1 : 'moving up',
2 : 'moving right and up',
3 : 'moving right and down',
4 : 'moving down',
5 : 'moving left and down',
6 : 'moving left and up',
7 : 'rest',
8 : 'wall'}
xn_list = setup_transition_list()
# Create data and initialize values.
node_state_grid = hmg.add_zeros('node', 'node_state_grid', dtype=int)
# Make the grid boundary all wall particles
node_state_grid[hmg.boundary_nodes] = 8
# Seed the grid interior with randomly oriented particles
for i in hmg.core_nodes:
if random.random()<p_init:
node_state_grid[i] = random.randint(1, 7)
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# Create an array to store the numbers of states at each plot interval
nstates = zeros((9, int(run_duration/plot_interval)))
k = 0
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=plot_every_transition, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# Record numbers in each state
nstates[:,k] = bincount(node_state_grid)
k += 1
# FINALIZE
# Plot
ca_plotter.finalize()
# Display the numbers of each state
fig, ax = subplots()
for i in range(1, 8):
plot(arange(plot_interval, run_duration+plot_interval, plot_interval), nstates[i,:], label=ns_dict[i])
ax.legend()
xlabel('Time')
ylabel('Number of particles in state')
title('Particle distribution by state')
axis([0, run_duration, 0, 2*nstates[7,0]])
show()
def main():
# INITIALIZE
# User-defined parameters
nr = 41
nc = 61
g = 0.8
f = 1.0
plot_interval = 1.0
run_duration = 200.0
report_interval = 5.0 # report interval, in real-time seconds
p_init = 0.4 # probability that a cell is occupied at start
plot_every_transition = False
# Remember the clock time, and calculate when we next want to report
# progress.
current_real_time = time.time()
next_report = current_real_time + report_interval
# Create a grid
hmg = HexModelGrid(nr, nc, 1.0, orientation='vertical', reorient_links=True)
# Close the grid boundaries
#hmg.set_closed_nodes(hmg.open_boundary_nodes)
# Set up the states and pair transitions.
# Transition data here represent particles moving on a lattice: one state
# per direction (for 6 directions), plus an empty state, a stationary
# state, and a wall state.
ns_dict = { 0 : 'empty',
1 : 'moving up',
2 : 'moving right and up',
3 : 'moving right and down',
4 : 'moving down',
5 : 'moving left and down',
6 : 'moving left and up',
7 : 'rest',
8 : 'wall'}
xn_list = setup_transition_list(g, f)
# Create data and initialize values.
node_state_grid = hmg.add_zeros('node', 'node_state_grid')
# Make the grid boundary all wall particles
node_state_grid[hmg.boundary_nodes] = 8
# Seed the grid interior with randomly oriented particles
for i in hmg.core_nodes:
if random.random()<p_init:
node_state_grid[i] = random.randint(1, 7)
# Create the CA model
ca = OrientedHexLCA(hmg, ns_dict, xn_list, node_state_grid)
# Create a CAPlotter object for handling screen display
ca_plotter = CAPlotter(ca)
# Plot the initial grid
ca_plotter.update_plot()
# RUN
current_time = 0.0
while current_time < run_duration:
# Once in a while, print out simulation and real time to let the user
# know that the sim is running ok
current_real_time = time.time()
if current_real_time >= next_report:
print 'Current sim time',current_time,'(',100*current_time/run_duration,'%)'
next_report = current_real_time + report_interval
# Run the model forward in time until the next output step
ca.run(current_time+plot_interval, ca.node_state,
plot_each_transition=plot_every_transition, plotter=ca_plotter)
current_time += plot_interval
# Plot the current grid
ca_plotter.update_plot()
# FINALIZE
# Plot
ca_plotter.finalize()