예제 #1
0
def main():
    """
    The basic algorithm for a LinkCA model is as follows:
        
        Initialize
            Set grid size, run duration, and plotting/output parameters
            Set up node states
            Set up link transitions
            Create and initialize the starting grid
            Create the CA model
            Create a CA plotter
            Set up (custom) boundary-control parameters
            Set up any other custom things
            
        Run
            Optionally report output to user in real time
            Figure out when the next interruption will be
            Run until that interruption
            If it's time to plot, do so
            If it's time to control boundaries, do so
            If it's time for file output, do so
            
        Finalize
            Do the last plot, if applicable
            Do any custom post-processing
    """

    # INITIALIZE

    # User-defined parameters: general
    nr = 129
    nc = 129
    opt_screen_display = True
    plot_interval = 1
    opt_file_output = False
    file_output_interval = 1
    run_duration = 127
    report_interval = 5.0  # report interval, in real-time seconds

    # User-defined parameters: boundary control
    boundary_update_interval = 0.1  # interval for baselevel lowering
    initial_hill_height = nr - 3  # must be < nr-1

    # Initialize real time and intervals for reporting, plotting, and file output
    current_real_time = time.time()
    next_report = current_real_time + report_interval
    never = run_duration + 1  # anything that scheduled for later than run_duration never happens!
    if opt_screen_display:
        next_plot = plot_interval
    else:
        next_plot = never
    if opt_file_output:
        next_file_write = file_output_interval
    else:
        next_file_write = never

    # Custom: initialize information for baselevel lowering
    next_boundary_update = boundary_update_interval
    left_edge_alinks = (nc - 2) * (nr - 1) + (nc - 1) * numpy.arange(nr - 2)
    right_edge_alinks = left_edge_alinks + (nc - 2)
    bl_height = initial_hill_height
    bl_left_alink = left_edge_alinks[bl_height - 1]
    bl_right_alink = right_edge_alinks[bl_height - 1]

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)

    # Set up node states and pair transitions
    ns_dict = {0: 'air', 1: 'mobile left', 2: 'mobile right', 3: 'immobile'}
    xn_list = setup_transition_list()

    # Create the node-state map and attach it to the grid
    node_state_grid = mg.add_zeros('node', 'node_state', dtype=int)

    # Custom: set initial values in the node-state grid
    (initial_hill, ) = numpy.where(mg.node_y <= initial_hill_height)
    node_state_grid[initial_hill] = 3

    # Custom: Set the left and right boundary conditions
    left_side_ids = mg.left_edge_node_ids()
    right_side_ids = mg.right_edge_node_ids()

    # Create the CA model
    ca = LinkCellularAutomaton(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 to handle screen display
    if opt_screen_display:
        ca_plotter = CAPlotter(ca)

    # 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

        # Find out when the next interruption (for plotting, boundary control,
        # file I/O, etc.) will be
        next_interrupt = min(next_plot, next_file_write, next_boundary_update,
                             run_duration)

        # Run the model forward in time until the next output step
        ca.run(next_interrupt, ca.node_state,
               plot_each_transition=False)  #, plotter=ca_plotter)

        # Update the current time
        current_time = next_interrupt

        # Plot the current grid
        if current_time >= next_plot:
            ca_plotter.update_plot()
            next_plot += plot_interval

        # Write the current grid to file
        if current_time >= next_file_write:
            print 'FILE OUTPUT NOT YET IMPLEMENTED'
            next_file_write += file_output_interval

        # Custom boundary control: baselevel lowering
        if current_time >= next_boundary_update:
            #print 'doing bl drop at time', current_time
            next_boundary_update += boundary_update_interval
            if bl_height > 0:
                ca.node_state[left_side_ids[
                    bl_height]] = 0  # turn the former baselevel to air
                ca.node_state[right_side_ids[
                    bl_height]] = 0  # turn the former baselevel to air
                ca.update_link_state(bl_left_alink, 0, current_time)
                ca.update_link_state(bl_right_alink, 0, current_time)
                bl_height -= 1
                bl_left_alink = left_edge_alinks[bl_height - 1]
                bl_right_alink = right_edge_alinks[bl_height - 1]

        # 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
    if opt_screen_display:
        ca_plotter.finalize()

    # Custom post-processing
    z = extract_hillslope_profile(mg.node_vector_to_raster(ca.node_state))
    #numpy.savetxt('h0822-01-u125.txt',z)
    print 'PEAK ELEV = ', numpy.amax(z)
예제 #2
0
def main():

    # INITIALIZE

    # User-defined parameters
    nr = 128
    nc = 128
    plot_interval = 5.0
    run_duration = 5000.0
    report_interval = 5.0  # report interval, in real-time seconds
    uplift_interval = 1.

    # Initialize real time
    current_real_time = time.time()
    next_report = current_real_time + report_interval

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)

    # 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 : 'mobile left', 2 : 'mobile right', 3 : 'immobile' }
    ns_dict = {
        0: 'air',
        1: 'mobile left',
        2: 'mobile right',
        3: 'immobile',
        4: 'rock'
    }
    xn_list = setup_transition_list()

    # Create the node-state map and attach it to the grid
    node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
    (lower_half, ) = numpy.where(mg.node_y < nr / 2)
    node_state_grid[lower_half] = 4

    # Set the left and right boundary conditions
    node_state_grid[mg.left_edge_node_ids()] = 0
    node_state_grid[mg.right_edge_node_ids()] = 0

    # Create the CA model
    ca = LinkCellularAutomaton(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

    ca_plotter = CAPlotter(ca)

    # RUN
    BC_type = 2
    #0: Block decay, disabled
    if BC_type == 0:
        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

    elif BC_type == 1:
        # 1: block uplift
        # set all nodes as air, except bottom row:
        ca.node_state[:] = 0
        ca.node_state[mg.bottom_edge_node_ids()[1:-1]] = 3

        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

            #make the uplift
            state_raster = mg.node_vector_to_raster(ca.node_state)
            for i in range(state_raster.shape[0])[::-1][:-2]:
                state_raster[i, 20:-20] = state_raster[i - 1, 20:-20]
            state_raster[:2, 20:-20] = 3
            ca.update_component_data(state_raster.ravel(), (numpy.arange(
                mg.number_of_nodes).reshape(mg.shape))[1, 20:-20], (0, 1))

            # Run the model forward in time until the next output step
            ca.run(current_time + uplift_interval,
                   ca.node_state,
                   plot_each_transition=False)  #, plotter=ca_plotter)
            current_time += uplift_interval

            # Plot the current grid
            ca_plotter.update_plot()

    elif BC_type == 2:
        #2: BC condition lowering
        #set all blocks as solid, except the top 3 rows:
        ca.node_state[:] = 3
        ca.node_state[-3 * mg.shape[1]:] = 0

        current_time = 0.0
        i = 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

            #drop the baselevel
            ca.node_state[mg.left_edge_node_ids()[-(i + 2):]] = 0
            ca.node_state[mg.right_edge_node_ids()[-(i + 2):]] = 0
            ca.assign_link_states_from_node_types()
            ca.push_transitions_to_event_queue()

            # Run the model forward in time until the next output step
            ca.run(current_time + uplift_interval,
                   ca.node_state,
                   plot_each_transition=False)  #, plotter=ca_plotter)
            current_time += uplift_interval
            i += 1

            # Plot the current grid
            ca_plotter.update_plot()

    # FINALIZE

    # Plot
    ca_plotter.finalize()
예제 #3
0
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 = LinkCellularAutomaton(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()
예제 #4
0
def main():
    """
    The basic algorithm for a LinkCA model is as follows:
        
        Initialize
            Set grid size, run duration, and plotting/output parameters
            Set up node states
            Set up link transitions
            Create and initialize the starting grid
            Create the CA model
            Create a CA plotter
            Set up (custom) boundary-control parameters
            Set up any other custom things
            
        Run
            Optionally report output to user in real time
            Figure out when the next interruption will be
            Run until that interruption
            If it's time to plot, do so
            If it's time to control boundaries, do so
            If it's time for file output, do so
            
        Finalize
            Do the last plot, if applicable
            Do any custom post-processing
    """
    
    # INITIALIZE

    # User-defined parameters: general
    nr = 129
    nc = 129
    opt_screen_display = True
    plot_interval = 1
    opt_file_output = False
    file_output_interval = 1
    run_duration = 127
    report_interval = 5.0  # report interval, in real-time seconds
    
    # User-defined parameters: boundary control
    boundary_update_interval = 0.1  # interval for baselevel lowering
    initial_hill_height = nr-3  # must be < nr-1
    
    # Initialize real time and intervals for reporting, plotting, and file output
    current_real_time = time.time()
    next_report = current_real_time + report_interval
    never = run_duration+1  # anything that scheduled for later than run_duration never happens!
    if opt_screen_display:
        next_plot = plot_interval
    else:
        next_plot = never
    if opt_file_output:
        next_file_write = file_output_interval
    else:
        next_file_write = never    
    
    # Custom: initialize information for baselevel lowering
    next_boundary_update = boundary_update_interval
    left_edge_alinks = (nc-2)*(nr-1)+(nc-1)*numpy.arange(nr-2)
    right_edge_alinks = left_edge_alinks + (nc-2)
    bl_height = initial_hill_height
    bl_left_alink = left_edge_alinks[bl_height-1]
    bl_right_alink = right_edge_alinks[bl_height-1]

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)
    
    # Set up node states and pair transitions
    ns_dict = { 0 : 'air', 1 : 'mobile left', 2 : 'mobile right', 3 : 'immobile' }
    xn_list = setup_transition_list()

    # Create the node-state map and attach it to the grid
    node_state_grid = mg.add_zeros('node', 'node_state', dtype=int)
    
    # Custom: set initial values in the node-state grid
    (initial_hill,) = numpy.where(mg.node_y<=initial_hill_height)
    node_state_grid[initial_hill] = 3
    
    # Custom: Set the left and right boundary conditions
    left_side_ids = mg.left_edge_node_ids()
    right_side_ids = mg.right_edge_node_ids()

    # Create the CA model
    ca = LinkCellularAutomaton(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 to handle screen display
    if opt_screen_display:
        ca_plotter = CAPlotter(ca)
    
    
    # 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
            
        # Find out when the next interruption (for plotting, boundary control,
        # file I/O, etc.) will be
        next_interrupt = min(next_plot, next_file_write, next_boundary_update, run_duration)
        
        # Run the model forward in time until the next output step
        ca.run(next_interrupt, ca.node_state, 
               plot_each_transition=False) #, plotter=ca_plotter)
               
        # Update the current time
        current_time = next_interrupt
       
        # Plot the current grid
        if current_time >= next_plot:
            ca_plotter.update_plot()
            next_plot += plot_interval
            
        # Write the current grid to file
        if current_time >= next_file_write:
            print 'FILE OUTPUT NOT YET IMPLEMENTED'
            next_file_write += file_output_interval
            
        # Custom boundary control: baselevel lowering
        if current_time >= next_boundary_update:
            #print 'doing bl drop at time', current_time
            next_boundary_update += boundary_update_interval
            if bl_height>0:
                ca.node_state[left_side_ids[bl_height]] = 0  # turn the former baselevel to air
                ca.node_state[right_side_ids[bl_height]] = 0  # turn the former baselevel to air
                ca.update_link_state(bl_left_alink, 0, current_time)
                ca.update_link_state(bl_right_alink, 0, current_time)
                bl_height -= 1
                bl_left_alink = left_edge_alinks[bl_height-1]
                bl_right_alink = right_edge_alinks[bl_height-1]
            
        # 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
    if opt_screen_display:
        ca_plotter.finalize()
        
    # Custom post-processing
    z = extract_hillslope_profile(mg.node_vector_to_raster(ca.node_state))
    #numpy.savetxt('h0822-01-u125.txt',z)
    print 'PEAK ELEV = ',numpy.amax(z)
예제 #5
0
def main():
    
    # INITIALIZE

    # User-defined parameters
    nr = 64
    nc = 130
    plot_interval = 1
    run_duration = 100
    report_interval = 5.0  # report interval, in real-time seconds
    baselevel_lowering_interval = 1
    initial_hill_height = 60
    
    # Initialize real time
    current_real_time = time.time()
    next_report = current_real_time + report_interval
    
    # Initialize information for baselevel lowering
    next_bl_drop = baselevel_lowering_interval
    left_edge_alinks = (nc-2)*(nr-1)+(nc-1)*numpy.arange(nr-2)
    #print left_edge_alinks
    right_edge_alinks = left_edge_alinks + (nc-2)
    #print right_edge_alinks
    bl_height = initial_hill_height
    bl_left_alink = left_edge_alinks[bl_height-1]
    bl_right_alink = right_edge_alinks[bl_height-1]
    #print 'bllal',bl_left_alink,'blral',bl_right_alink

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)
    
    # 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 : 'mobile left', 2 : 'mobile right', 3 : 'immobile' }
    xn_list = setup_transition_list()

    # Create the node-state map and attach it to the grid
    node_state_grid = mg.add_zeros('node', 'node_state', dtype=int)
    (initial_hill,) = numpy.where(mg.node_y<=initial_hill_height)
    node_state_grid[initial_hill] = 3
    above_dam = numpy.where(mg.node_y>130-mg.node_x)[0]
    node_state_grid[above_dam] = 0
    
    # Set the left and right boundary conditions
    left_side_ids = mg.left_edge_node_ids()
    right_side_ids = mg.right_edge_node_ids()
    #node_state_grid[mg.left_edge_node_ids()] = 0
    #node_state_grid[mg.right_edge_node_ids()] = 0
    
    # Remember the IDs of the lower row of nodes, so we can keep them set to
    # state 3 when we do uplift
    #bottom_row = mg.bottom_edge_node_ids()
    
    # Create the CA model
    ca = LinkCellularAutomaton(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()

    ca_plotter = CAPlotter(ca)
    
    # 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()
        
        # Uplift
        if current_time >= next_bl_drop and bl_height>0:
            #print 'doing bl drop at time', current_time
            next_bl_drop += baselevel_lowering_interval
            ca.node_state[left_side_ids[bl_height]] = 0  # turn the former baselevel to air
            ca.node_state[right_side_ids[bl_height]] = 0  # turn the former baselevel to air
            ca.update_link_state(bl_left_alink, 0, current_time)
            ca.update_link_state(bl_right_alink, 0, current_time)
            bl_height -= 1
            #ca.node_state[left_side_ids[bl_height]] = 3  # turn the new baselevel to regolith
            #ca.node_state[right_side_ids[bl_height]] = 3  # turn the new baselevel to regolith
            bl_left_alink = left_edge_alinks[bl_height-1]
            bl_right_alink = right_edge_alinks[bl_height-1]
            #ca.update_link_state(bl_left_alink, 0, current_time)
            #ca.update_link_state(bl_right_alink, 0, current_time)
            
            #ca.node_state[left_side_ids[:bl_height]] = 3
            #ca.node_state[left_side_ids[bl_height:]] = 0
            #ca.node_state[right_side_ids[:bl_height]] = 3
            #ca.node_state[right_side_ids[bl_height:]] = 0           
            #next_uplift += uplift_interval
            #ca.grid.roll_nodes_ud('node_state', 1, interior_only=True)
            #ca.node_state[bottom_row] = 3
            #print 'after roll:',ca.node_state

        # 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()
    z = extract_hillslope_profile(mg.node_vector_to_raster(ca.node_state))
    numpy.savetxt('h0822-01-u125.txt',z)
    print('PEAK ELEV = ',numpy.amax(z))
예제 #6
0
def main():

    # INITIALIZE

    # User-defined parameters
    nr = 128
    nc = 128
    plot_interval = 5.0
    run_duration = 5000.0
    report_interval = 5.0  # report interval, in real-time seconds
    uplift_interval = 1.

    # Initialize real time
    current_real_time = time.time()
    next_report = current_real_time + report_interval

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)

    # 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 : 'mobile left', 2 : 'mobile right', 3 : 'immobile' }
    ns_dict = { 0 : 'air', 1 : 'mobile left', 2 : 'mobile right', 3 : 'immobile', 4 : 'rock' }
    xn_list = setup_transition_list()

    # Create the node-state map and attach it to the grid
    node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
    (lower_half,) = numpy.where(mg.node_y<nr/2)
    node_state_grid[lower_half] = 4

    # Set the left and right boundary conditions
    node_state_grid[mg.left_edge_node_ids()] = 0
    node_state_grid[mg.right_edge_node_ids()] = 0

    # Create the CA model
    ca = LinkCellularAutomaton(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()

    ca_plotter = CAPlotter(ca)

    # RUN
    BC_type = 2
#0: Block decay, disabled
    if BC_type==0:
        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()

    elif BC_type==1:
        # 1: block uplift
        # set all nodes as air, except bottom row:
        ca.node_state[:] = 0
        ca.node_state[mg.bottom_edge_node_ids()[1:-1]] = 3

        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

            #make the uplift
            state_raster = mg.node_vector_to_raster(ca.node_state)
            for i in range(state_raster.shape[0])[::-1][:-2]:
                state_raster[i,20:-20] = state_raster[i-1,20:-20]
            state_raster[:2,20:-20] = 3
            ca.update_component_data(state_raster.ravel(), (numpy.arange(mg.number_of_nodes).reshape(mg.shape))[1,20:-20], (0,1))

            # Run the model forward in time until the next output step
            ca.run(current_time+uplift_interval, ca.node_state,
                plot_each_transition=False) #, plotter=ca_plotter)
            current_time += uplift_interval

            # Plot the current grid
            ca_plotter.update_plot()

    elif BC_type==2:
        #2: BC condition lowering
        #set all blocks as solid, except the top 3 rows:
        ca.node_state[:] = 3
        ca.node_state[-3*mg.shape[1]:] = 0

        current_time = 0.0
        i = 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

            #drop the baselevel
            ca.node_state[mg.left_edge_node_ids()[-(i+2):]] = 0
            ca.node_state[mg.right_edge_node_ids()[-(i+2):]] = 0
            ca.assign_link_states_from_node_types()
            ca.push_transitions_to_event_queue()

            # Run the model forward in time until the next output step
            ca.run(current_time+uplift_interval, ca.node_state,
                plot_each_transition=False) #, plotter=ca_plotter)
            current_time += uplift_interval
            i += 1

            # Plot the current grid
            ca_plotter.update_plot()


    # FINALIZE

    # Plot
    ca_plotter.finalize()
예제 #7
0
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 = LinkCellularAutomaton(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()
예제 #8
0
def main():

    # INITIALIZE

    # User-defined parameters
    nr = 64
    nc = 130
    plot_interval = 1
    run_duration = 100
    report_interval = 5.0  # report interval, in real-time seconds
    baselevel_lowering_interval = 1
    initial_hill_height = 60

    # Initialize real time
    current_real_time = time.time()
    next_report = current_real_time + report_interval

    # Initialize information for baselevel lowering
    next_bl_drop = baselevel_lowering_interval
    left_edge_alinks = (nc - 2) * (nr - 1) + (nc - 1) * numpy.arange(nr - 2)
    #print left_edge_alinks
    right_edge_alinks = left_edge_alinks + (nc - 2)
    #print right_edge_alinks
    bl_height = initial_hill_height
    bl_left_alink = left_edge_alinks[bl_height - 1]
    bl_right_alink = right_edge_alinks[bl_height - 1]
    #print 'bllal',bl_left_alink,'blral',bl_right_alink

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)

    # 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: 'mobile left', 2: 'mobile right', 3: 'immobile'}
    xn_list = setup_transition_list()

    # Create the node-state map and attach it to the grid
    node_state_grid = mg.add_zeros('node', 'node_state', dtype=int)
    (initial_hill, ) = numpy.where(mg.node_y <= initial_hill_height)
    node_state_grid[initial_hill] = 3
    above_dam = numpy.where(mg.node_y > 130 - mg.node_x)[0]
    node_state_grid[above_dam] = 0

    # Set the left and right boundary conditions
    left_side_ids = mg.left_edge_node_ids()
    right_side_ids = mg.right_edge_node_ids()
    #node_state_grid[mg.left_edge_node_ids()] = 0
    #node_state_grid[mg.right_edge_node_ids()] = 0

    # Remember the IDs of the lower row of nodes, so we can keep them set to
    # state 3 when we do uplift
    #bottom_row = mg.bottom_edge_node_ids()

    # Create the CA model
    ca = LinkCellularAutomaton(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

    ca_plotter = CAPlotter(ca)

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

        # Uplift
        if current_time >= next_bl_drop and bl_height > 0:
            #print 'doing bl drop at time', current_time
            next_bl_drop += baselevel_lowering_interval
            ca.node_state[left_side_ids[
                bl_height]] = 0  # turn the former baselevel to air
            ca.node_state[right_side_ids[
                bl_height]] = 0  # turn the former baselevel to air
            ca.update_link_state(bl_left_alink, 0, current_time)
            ca.update_link_state(bl_right_alink, 0, current_time)
            bl_height -= 1
            #ca.node_state[left_side_ids[bl_height]] = 3  # turn the new baselevel to regolith
            #ca.node_state[right_side_ids[bl_height]] = 3  # turn the new baselevel to regolith
            bl_left_alink = left_edge_alinks[bl_height - 1]
            bl_right_alink = right_edge_alinks[bl_height - 1]
            #ca.update_link_state(bl_left_alink, 0, current_time)
            #ca.update_link_state(bl_right_alink, 0, current_time)

            #ca.node_state[left_side_ids[:bl_height]] = 3
            #ca.node_state[left_side_ids[bl_height:]] = 0
            #ca.node_state[right_side_ids[:bl_height]] = 3
            #ca.node_state[right_side_ids[bl_height:]] = 0
            #next_uplift += uplift_interval
            #ca.grid.roll_nodes_ud('node_state', 1, interior_only=True)
            #ca.node_state[bottom_row] = 3
            #print 'after roll:',ca.node_state

        # 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()
    z = extract_hillslope_profile(mg.node_vector_to_raster(ca.node_state))
    numpy.savetxt('h0822-01-u125.txt', z)
    print 'PEAK ELEV = ', numpy.amax(z)
예제 #9
0
def main():
    
    # INITIALIZE

    # User-defined parameters
    nr = 128
    nc = 128
    plot_interval = 0.25
    run_duration = 4.0
    report_interval = 5.0  # report interval, in real-time seconds
    
    # Initialize real time
    current_real_time = time.time()
    next_report = current_real_time + report_interval

    # Create grid and set up boundaries
    mg = RasterModelGrid(nr, nc, 1.0)
    
    # 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()

    # The initial grid
    node_state_grid = mg.add_zeros('node', 'node_state_map', dtype=int)
    node_state_grid[:] = make_frac_grid(10, model_grid=mg)    
    
    # Create the CA model
    ca = LinkCellularAutomaton(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

    ca_plotter = CAPlotter(ca)
    
    # 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()