コード例 #1
0
ファイル: step0.py プロジェクト: oflebbe/pp4pp
# X[time][ring][cell]
X = np.zeros((tau, rings, ringsize), float)
Y = np.zeros((tau, rings, ringsize), float)
for ring in range(rings):
    for cell in range(ringsize):
        X[0][ring][cell] = X0[cell][ring]
        Y[0][ring][cell] = Y0[cell][ring]

time = np.arange(0, h * N + h, h)

# Loop over all cells and time points
startTime = mytime.time()
for t in range(0, N):
    index = t % tau
    for ring in range(0, rings):
        timestep.timestep(X, Y, cylinderConcPerCell, index, ring, t, tau,
                          omega, Am)

# Generate progress output to standard out
    if t % 5 == 0 and t != 0:
        elapsed = mytime.time() - startTime
        ratio = 1.0 * t / N
        print ('%d/%d, \t %.1f%%, \t elapsed: %.1f \t ETA: %.1f'\
               % (t, N, ratio*100, elapsed, elapsed/ratio-elapsed))

# Write data output to files
    if t % sampleFreq == 0:
        # Write raw data to files
        #        writeCylinder('outputX_F_Dxr_' + str(Dxr) + '_k_' + ':', X, t)
        #        writeCylinder('outputY_F_Dxr_' + str(Dxr) + '_k_' + ':', Y, t)

        # Write X matrix to image file
コード例 #2
0
ファイル: driver.py プロジェクト: cphl/cfd
# Not standard modules: ensure these files are in the current directory
import timestep as ts
import simple_plot as sp
import simple_animate as sa
from matplotlib import pyplot


# Sample initial condition and code for testing
#dx = 0.025
xmax = 2.0
nx = 41
dx = xmax/(nx-1)
nt = 50
test_ic = numpy.zeros((1, nx))  # put at assert to accept 1-by-nx ICs
test_ic[0, 0.5/dx: 1/dx + 1] = 2
test_solution = ts.timestep(test_ic, 'fd')

sp.plot_at(0, test_solution)
sp.plot_at(30, test_solution)
sa.animate_it(test_solution)


# try a different IC - Double hat
test_ic_2 = test_ic.copy()
test_ic_2[0, 0.7/dx: 0.9/dx] = 0
test_solution_2 = ts.timestep(test_ic_2, 'fd')
sp.plot_at(0, test_solution_2)  # see initial condition
sp.plot_at(24, test_solution_2)  # see intermediate step
sp.plot_at(49, test_solution_2)  # see final state #BUG: clipped
sa.animate_it(test_solution_2)
pyplot.show()  # to make it show after all the previous non-blocking figures
コード例 #3
0
ファイル: preevolve.py プロジェクト: jzuhone/pyro2
def preevolve(my_data):
    """ 
    preevolve is called before we being the timestepping loop.  For
    the incompressible solver, this does an initial projection on the
    velocity field and then goes through the full evolution to get the
    value of phi.  The fluid state (u, v) is then reset to values
    before this evolve.
    """

    myg = my_data.grid

    u = my_data.get_var("x-velocity")
    v = my_data.get_var("y-velocity")

    my_data.fill_BC("x-velocity")
    my_data.fill_BC("y-velocity")

    # 1. do the initial projection.  This makes sure that our original
    # velocity field satisties div U = 0

    # next create the multigrid object.  We want Neumann BCs on phi
    # at solid walls and periodic on phi for periodic BCs
    MG = multigrid.CellCenterMG2d(myg.nx,
                                  myg.ny,
                                  xl_BC_type="periodic",
                                  xr_BC_type="periodic",
                                  yl_BC_type="periodic",
                                  yr_BC_type="periodic",
                                  xmin=myg.xmin,
                                  xmax=myg.xmax,
                                  ymin=myg.ymin,
                                  ymax=myg.ymax,
                                  verbose=0)

    # first compute divU
    divU = MG.soln_grid.scratch_array()

    divU[MG.ilo:MG.ihi+1,MG.jlo:MG.jhi+1] = \
        0.5*(u[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] -
             u[myg.ilo-1:myg.ihi  ,myg.jlo:myg.jhi+1])/myg.dx + \
        0.5*(v[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] -
             v[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi  ])/myg.dy

    # solve L phi = DU

    # initialize our guess to the solution
    MG.init_zeros()

    # setup the RHS of our Poisson equation
    MG.init_RHS(divU)

    # solve
    MG.solve(rtol=1.e-10)

    # store the solution in our my_data object -- include a single
    # ghostcell
    phi = my_data.get_var("phi")
    solution = MG.get_solution()

    phi[myg.ilo-1:myg.ihi+2,myg.jlo-1:myg.jhi+2] = \
        solution[MG.ilo-1:MG.ihi+2,MG.jlo-1:MG.jhi+2]

    # compute the cell-centered gradient of phi and update the
    # velocities
    gradp_x = myg.scratch_array()
    gradp_y = myg.scratch_array()

    gradp_x[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \
        0.5*(phi[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] -
             phi[myg.ilo-1:myg.ihi  ,myg.jlo:myg.jhi+1])/myg.dx

    gradp_y[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \
        0.5*(phi[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] -
             phi[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi  ])/myg.dy

    u[:, :] -= gradp_x
    v[:, :] -= gradp_y

    # fill the ghostcells
    my_data.fill_BC("x-velocity")
    my_data.fill_BC("y-velocity")

    # 2. now get an approximation to gradp at n-1/2 by going through the
    # evolution.

    # store the current solution
    copyData = patch.cell_center_data_clone(my_data)

    # get the timestep
    dt = timestep.timestep(copyData)

    # evolve
    evolve.evolve(copyData, dt)

    # update gradp_x and gradp_y in our main data object
    gp_x = my_data.get_var("gradp_x")
    gp_y = my_data.get_var("gradp_y")

    new_gp_x = copyData.get_var("gradp_x")
    new_gp_y = copyData.get_var("gradp_y")

    gp_x[:, :] = new_gp_x[:, :]
    gp_y[:, :] = new_gp_y[:, :]

    print "done with the pre-evolution"
コード例 #4
0
# correct
C_to = C_tot(num_point, p, p0, C_atm0, f_ocean, freeze, T)

#correct
tau = tau_ir(p, p0, T, freeze)

#tau! BTW correct
infrared = OLR(sigma_SB, T, tau)

# correct
qq = Q(insol, albedo, infrared)

#
ha = hab(num_point, T, freeze, boil)

deltat = timestep(diff, latt, delta_latt, num_point, C_to)
"""

phi += phidot*deltat
diff, deltax, x,  insol[i], f_ice[i],  C_tot[i],  albedo[i], tau_ir[i],infrared[i],Q[i],hab[i] = value_update(T,phi,deltat)

deltat = timestep(diff, x, deltax, nx, C_tot)
phi += phidot*deltat
diff, deltax, x,  insol[i], f_ice[i],  C_tot[i],  albedo[i], tau_ir[i],infrared[i],Q[i],hab[i] = value_update(T,phi,deltat)

T_max = freeze + 0.9*(boil - freeze)

timeyr = time/yr

T_mean_old = np.mean(T)
コード例 #5
0
def simulate(parameters,
             landscape,
             burnInT,
             tf,
             initial_ecosystem=None,
             idxRun=None,
             suffix=None):
    '''
    parameters: 
        dictionary, see script.py for example
    landscape: 
        string, defines the landscape as a string of H and L for high and low-quality habitats
    burnInT: 
        integer, some number of timesteps (generations) to not store in the pickle file
    tf:
        integer, number of timesteps
    idxRun: 
        integer, when multiple runs on the same parameter-set/suffix are run, 
        may want to separate pickled results file by additional suffix, 
        like *_run0.pkl, *_run1.pkl, etc.
    suffix:
        string, the string to identify the pickled results file i.e. ecosystems_suffix_run0.pkl
    '''

    # initialise ecosystem

    if initial_ecosystem == None:

        # random start for individuals
        geneRandFnc = lambda geneType: random.randint(
            0, 2**parameters['genetics'][geneType]['noLoci'] - 1)
        #sexRandFnc = lambda: random.choice( parameters['sexes'] )
        natalHabRandFnc = lambda: random.choice(landscape)

        initial_ecosystem = [{
            'adults': [{
                'sex': 'h',
                'natalHabType': natalHabRandFnc(),
                'genotype': {
                    geneType: geneRandFnc(geneType)
                    for geneType in parameters['genetics'].keys()
                }
            }, {
                'sex': 'h',
                'natalHabType': natalHabRandFnc(),
                'genotype': {
                    geneType: geneRandFnc(geneType)
                    for geneType in parameters['genetics'].keys()
                }
            }],
            'juveniles':
            list(),
        } for habType in landscape]

    ecosystem = copy.deepcopy(
        initial_ecosystem
    )  # make a deep copy so we can store the initial conditions in pickle file

    # simulate ecosystem for burn-in timesteps, but don't record results

    t = 1
    while t <= burnInT and not ecosystemIsEmpty(ecosystem):

        ecosystem, _ = timestep(parameters, ecosystem, landscape)
        t += 1

    # simulate ecosystem for remaining timesteps and record results

    ecosystems = list()  # a place to store the ecosystem at each timestep
    while t <= tf and not ecosystemIsEmpty(ecosystem):

        # one timestep of simulation
        ecosystem, _ = timestep(parameters, ecosystem, landscape)

        # store info
        ecosystems.append(copy.deepcopy(ecosystem))

        t += 1

    # pickle the info

    # build the pickled results file's name
    fName = 'ecosystems'

    if suffix == None:
        suffix = parameters2filesuffix(tf, landscape, parameters)
    fName += suffix

    if idxRun != None:
        fName += '_run' + str(idxRun)

    fName += '.pkl'

    # open the file with the name fName
    f = open(fName, 'wb')

    # a string explaining the pickle file
    path = os.path.dirname(os.path.realpath('simulate.py'))
    ss = 'Created by simulate.py in ' + path + '.\n'
    ss += 'Contains the following:\n'
    ss += '0. ss, string: this string you are reading now.\n'
    ss += '1. burnInT, integer: the number of unrecorded timesteps of burn-in.\n'
    ss += '2. t, integer: the total number up to which timesteps run (so range(burnInT+1,t)).\n'
    ss += '3. tf, integer: the total maximum number up to which timesteps were attempted (if pop did not go extinct, t = tf+1).\n'
    ss += '4. landscape, string: a string defining the landscape habitat type composition (e.g. LLLLHHHLLLL).\n'
    ss += '5. ecosystems, list of lists of dictionaries: the ecosystem at the end of each recorded timestep.\n'
    ss += '6. path, string: the path in which the run was performed.\n'
    ss += '7. parameters, dictionary: the parameter values with which the run was performed.\n'
    ss += '8. initial_ecosystem, list of dictionaries: the initial ecosystem.\n'

    pickle.dump(ss, f)  # 0.
    pickle.dump(burnInT, f)
    pickle.dump(t, f)
    pickle.dump(tf, f)  # 3.
    pickle.dump(landscape, f)
    pickle.dump(ecosystems, f)
    pickle.dump(path, f)  # 6.
    pickle.dump(parameters, f)
    pickle.dump(initial_ecosystem, f)

    f.close()
コード例 #6
0
ファイル: preevolve.py プロジェクト: jzuhone/pyro2
def preevolve(my_data):
    """ 
    preevolve is called before we being the timestepping loop.  For
    the incompressible solver, this does an initial projection on the
    velocity field and then goes through the full evolution to get the
    value of phi.  The fluid state (u, v) is then reset to values
    before this evolve.
    """

    myg = my_data.grid

    u = my_data.get_var("x-velocity")
    v = my_data.get_var("y-velocity")

    my_data.fill_BC("x-velocity")
    my_data.fill_BC("y-velocity")


    # 1. do the initial projection.  This makes sure that our original
    # velocity field satisties div U = 0

    # next create the multigrid object.  We want Neumann BCs on phi
    # at solid walls and periodic on phi for periodic BCs
    MG = multigrid.CellCenterMG2d(myg.nx, myg.ny,
                                  xl_BC_type="periodic", xr_BC_type="periodic",
                                  yl_BC_type="periodic", yr_BC_type="periodic",
                                  xmin=myg.xmin, xmax=myg.xmax,
                                  ymin=myg.ymin, ymax=myg.ymax,
                                  verbose=0)

    # first compute divU
    divU = MG.soln_grid.scratch_array()

    divU[MG.ilo:MG.ihi+1,MG.jlo:MG.jhi+1] = \
        0.5*(u[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] - 
             u[myg.ilo-1:myg.ihi  ,myg.jlo:myg.jhi+1])/myg.dx + \
        0.5*(v[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] - 
             v[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi  ])/myg.dy


    # solve L phi = DU

    # initialize our guess to the solution
    MG.init_zeros()

    # setup the RHS of our Poisson equation
    MG.init_RHS(divU)

    # solve
    MG.solve(rtol=1.e-10)

    # store the solution in our my_data object -- include a single
    # ghostcell
    phi = my_data.get_var("phi")
    solution = MG.get_solution()

    phi[myg.ilo-1:myg.ihi+2,myg.jlo-1:myg.jhi+2] = \
        solution[MG.ilo-1:MG.ihi+2,MG.jlo-1:MG.jhi+2]

    # compute the cell-centered gradient of phi and update the 
    # velocities
    gradp_x = myg.scratch_array()
    gradp_y = myg.scratch_array()

    gradp_x[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \
        0.5*(phi[myg.ilo+1:myg.ihi+2,myg.jlo:myg.jhi+1] -
             phi[myg.ilo-1:myg.ihi  ,myg.jlo:myg.jhi+1])/myg.dx

    gradp_y[myg.ilo:myg.ihi+1,myg.jlo:myg.jhi+1] = \
        0.5*(phi[myg.ilo:myg.ihi+1,myg.jlo+1:myg.jhi+2] -
             phi[myg.ilo:myg.ihi+1,myg.jlo-1:myg.jhi  ])/myg.dy

    u[:,:] -= gradp_x
    v[:,:] -= gradp_y

    # fill the ghostcells
    my_data.fill_BC("x-velocity")
    my_data.fill_BC("y-velocity")


    # 2. now get an approximation to gradp at n-1/2 by going through the
    # evolution.

    # store the current solution
    copyData = patch.cell_center_data_clone(my_data)

    # get the timestep
    dt = timestep.timestep(copyData)

    # evolve
    evolve.evolve(copyData, dt)

    # update gradp_x and gradp_y in our main data object
    gp_x = my_data.get_var("gradp_x")
    gp_y = my_data.get_var("gradp_y")

    new_gp_x = copyData.get_var("gradp_x")
    new_gp_y = copyData.get_var("gradp_y")

    gp_x[:,:] = new_gp_x[:,:]
    gp_y[:,:] = new_gp_y[:,:]


    print "done with the pre-evolution"
コード例 #7
0
ファイル: driver.py プロジェクト: cphl/cfd
import numpy
# Not standard modules: ensure these files are in the current directory
import timestep as ts
import simple_plot as sp
import simple_animate as sa
from matplotlib import pyplot

# Sample initial condition and code for testing
#dx = 0.025
xmax = 2.0
nx = 41
dx = xmax / (nx - 1)
nt = 50
test_ic = numpy.zeros((1, nx))  # put at assert to accept 1-by-nx ICs
test_ic[0, 0.5 / dx:1 / dx + 1] = 2
test_solution = ts.timestep(test_ic, 'fd')

sp.plot_at(0, test_solution)
sp.plot_at(30, test_solution)
sa.animate_it(test_solution)

# try a different IC - Double hat
test_ic_2 = test_ic.copy()
test_ic_2[0, 0.7 / dx:0.9 / dx] = 0
test_solution_2 = ts.timestep(test_ic_2, 'fd')
sp.plot_at(0, test_solution_2)  # see initial condition
sp.plot_at(24, test_solution_2)  # see intermediate step
sp.plot_at(49, test_solution_2)  # see final state #BUG: clipped
sa.animate_it(test_solution_2)
pyplot.show()  # to make it show after all the previous non-blocking figures
コード例 #8
0
def _csv_line_extract_datetime(_line):
    line = timestep(_line)
    return datetime(year=int(line.year), month=int(line.month), day=int(line.day), hour=int(line.hour), \
                                minute=int(line.minute))