def initialize(self, extra_vars=None, ng=4):
"""
Initialize the grid and variables for compressible flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=ng)
my_data = self.data_class(my_grid)
# define solver specific boundary condition routines
bnd.define_bc("hse", BC.user, is_solid=False)
bnd.define_bc("ramp", BC.user, is_solid=False) # for double mach reflection problem
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# are we dealing with solid boundaries? we'll use these for
# the Riemann solver
self.solid = bnd.bc_is_solid(bc)
# density and energy
my_data.register_var("density", bc)
my_data.register_var("energy", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
# any extras?
if extra_vars is not None:
for v in extra_vars:
my_data.register_var(v, bc)
# store the EOS gamma as an auxillary quantity so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("gamma", self.rp.get_param("eos.gamma"))
my_data.set_aux("grav", self.rp.get_param("compressible.grav"))
my_data.create()
self.cc_data = my_data
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = self.data_class(my_grid)
aux_data.register_var("ymom_src", bc_yodd)
aux_data.register_var("E_src", bc)
aux_data.create()
self.aux_data = aux_data
# derived variables
self.cc_data.add_derived(derives.derive_primitives)
self.ivars = Variables(my_data)
self.cc_data.add_ivars(self.ivars)
# initial conditions for the problem
problem = importlib.import_module("{}.problems.{}".format(
self.solver_name, self.problem_name))
problem.init_data(self.cc_data, self.rp)
if self.verbose > 0:
print(my_data)
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
my_data = patch.CellCenterData2d(my_grid)
bc = bc_setup(self.rp)[0]
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param(
"particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles,
particle_generator)
# now set the initial conditions for the problem
problem = importlib.import_module("advection.problems.{}".format(
self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for incompressible flow and
set the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(my_grid)
# velocities
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# phi -- used for the projections
my_data.register_var("phi-MAC", bc)
my_data.register_var("phi", bc)
my_data.register_var("gradp_x", bc)
my_data.register_var("gradp_y", bc)
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param("particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator)
# now set the initial conditions for the problem
problem = importlib.import_module("incompressible.problems.{}".format(self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for incompressible flow and
set the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(my_grid)
# velocities
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# phi -- used for the projections
my_data.register_var("phi-MAC", bc)
my_data.register_var("phi", bc)
my_data.register_var("gradp_x", bc)
my_data.register_var("gradp_y", bc)
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param("particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator)
# now set the initial conditions for the problem
problem = importlib.import_module("incompressible.problems.{}".format(self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for incompressible flow and
set the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(my_grid)
# velocities
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# phi -- used for the projections
my_data.register_var("phi-MAC", bc)
my_data.register_var("phi", bc)
my_data.register_var("gradp_x", bc)
my_data.register_var("gradp_y", bc)
my_data.create()
self.cc_data = my_data
# now set the initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.rp)')
def initialize(self, extra_vars=None, ng=4):
"""
Initialize the grid and variables for swe flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=ng)
my_data = self.data_class(my_grid)
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# are we dealing with solid boundaries? we'll use these for
# the Riemann solver
self.solid = bnd.bc_is_solid(bc)
# density and energy
my_data.register_var("height", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
my_data.register_var("fuel", bc)
# any extras?
if extra_vars is not None:
for v in extra_vars:
my_data.register_var(v, bc)
# store the gravitational acceration g as an auxillary quantity
# so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("g", self.rp.get_param("swe.grav"))
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param("particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator)
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = self.data_class(my_grid)
aux_data.register_var("ymom_src", bc_yodd)
aux_data.create()
self.aux_data = aux_data
self.ivars = Variables(my_data)
# derived variables
self.cc_data.add_derived(derives.derive_primitives)
# initial conditions for the problem
problem = importlib.import_module("{}.problems.{}".format(
self.solver_name, self.problem_name))
problem.init_data(self.cc_data, self.rp)
if self.verbose > 0:
print(my_data)
def initialize(self):
"""
Initialize the grid and variables for compressible flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
my_data = patch.CellCenterData2d(my_grid)
# define solver specific boundary condition routines
patch.define_bc("hse", BC.user, is_solid=False)
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# are we dealing with solid boundaries? we'll use these for
# the Riemann solver
self.solid = BCProp(int(patch.bc_props[self.rp.get_param("mesh.xlboundary")]),
int(patch.bc_props[self.rp.get_param("mesh.xrboundary")]),
int(patch.bc_props[self.rp.get_param("mesh.ylboundary")]),
int(patch.bc_props[self.rp.get_param("mesh.yrboundary")]))
# density and energy
my_data.register_var("density", bc)
my_data.register_var("energy", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
# store the EOS gamma as an auxillary quantity so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("gamma", self.rp.get_param("eos.gamma"))
my_data.set_aux("grav", self.rp.get_param("compressible.grav"))
my_data.create()
self.cc_data = my_data
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = patch.CellCenterData2d(my_grid)
aux_data.register_var("ymom_src", bc_yodd)
aux_data.register_var("E_src", bc)
aux_data.create()
self.aux_data = aux_data
self.vars = Variables(idens = my_data.vars.index("density"),
ixmom = my_data.vars.index("x-momentum"),
iymom = my_data.vars.index("y-momentum"),
iener = my_data.vars.index("energy"))
# initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.rp)')
if self.verbose > 0: print(my_data)
def initialize(self):
"""
Initialize the grid and variables for compressible flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
my_data = patch.CellCenterData2d(my_grid)
# define solver specific boundary condition routines
bnd.define_bc("hse", BC.user, is_solid=False)
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# are we dealing with solid boundaries? we'll use these for
# the Riemann solver
self.solid = bnd.BCProp(
int(bnd.bc_solid[self.rp.get_param("mesh.xlboundary")]),
int(bnd.bc_solid[self.rp.get_param("mesh.xrboundary")]),
int(bnd.bc_solid[self.rp.get_param("mesh.ylboundary")]),
int(bnd.bc_solid[self.rp.get_param("mesh.yrboundary")]))
# density and energy
my_data.register_var("density", bc)
my_data.register_var("energy", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
# store the EOS gamma as an auxillary quantity so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("gamma", self.rp.get_param("eos.gamma"))
my_data.set_aux("grav", self.rp.get_param("compressible.grav"))
my_data.create()
self.cc_data = my_data
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = patch.CellCenterData2d(my_grid)
aux_data.register_var("ymom_src", bc_yodd)
aux_data.register_var("E_src", bc)
aux_data.create()
self.aux_data = aux_data
self.vars = Variables(idens=my_data.vars.index("density"),
ixmom=my_data.vars.index("x-momentum"),
iymom=my_data.vars.index("y-momentum"),
iener=my_data.vars.index("energy"))
# initial conditions for the problem
problem = importlib.import_module("compressible.problems.{}".format(
self.problem_name))
problem.init_data(self.cc_data, self.rp)
if self.verbose > 0: print(my_data)
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
def shift(velocity):
"""
Computes the direction of shift for each node for upwind
discretization based on sign of veclocity
"""
shift_vel = np.sign(velocity)
shift_vel[np.where(shift_vel <= 0)] = 0
shift_vel[np.where(shift_vel > 0)] = -1
return shift_vel
my_grid = grid_setup(self.rp, ng=4)
# create the variables
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(my_grid)
# velocities
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# shift
my_data.register_var("x-shift", bc_xodd)
my_data.register_var("y-shift", bc_yodd)
# density
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param(
"particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles,
particle_generator)
# now set the initial conditions for the problem
problem = importlib.import_module(
"advection_nonuniform.problems.{}".format(self.problem_name))
problem.init_data(self.cc_data, self.rp)
# compute the required shift for each node using corresponding velocity at the node
shx = self.cc_data.get_var("x-shift")
shx[:, :] = shift(self.cc_data.get_var("x-velocity"))
shy = self.cc_data.get_var("y-shift")
shy[:, :] = shift(self.cc_data.get_var("y-velocity"))
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
def shift(velocity):
"""
Computes the direction of shift for each node for upwind
discretization based on sign of veclocity
"""
shift_vel = np.sign(velocity)
shift_vel[np.where(shift_vel <= 0)] = 0
shift_vel[np.where(shift_vel > 0)] = -1
return shift_vel
my_grid = grid_setup(self.rp, ng=4)
# create the variables
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(my_grid)
# velocities
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# shift
my_data.register_var("x-shift", bc_xodd)
my_data.register_var("y-shift", bc_yodd)
# density
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param("particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator)
# now set the initial conditions for the problem
problem = importlib.import_module("advection_nonuniform.problems.{}".format(self.problem_name))
problem.init_data(self.cc_data, self.rp)
# compute the required shift for each node using corresponding velocity at the node
shx = self.cc_data.get_var("x-shift")
shx[:, :] = shift(self.cc_data.get_var("x-velocity"))
shy = self.cc_data.get_var("y-shift")
shy[:, :] = shift(self.cc_data.get_var("y-velocity"))
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
my_data = patch.CellCenterData2d(my_grid)
bc = bc_setup(self.rp)[0]
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
# now set the initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.rp)')
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
my_data = patch.CellCenterData2d(my_grid)
bc = bc_setup(self.rp)[0]
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
# now set the initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.rp)')
def initialize(self):
"""
Initialize the grid and variables for compressible flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
my_data = patch.CellCenterData2d(my_grid)
# define solver specific boundary condition routines
patch.define_bc("hse", BC.user)
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# density and energy
my_data.register_var("density", bc)
my_data.register_var("energy", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
# store the EOS gamma as an auxillary quantity so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("gamma", self.rp.get_param("eos.gamma"))
my_data.set_aux("grav", self.rp.get_param("compressible.grav"))
my_data.create()
self.cc_data = my_data
self.vars = Variables(idens = my_data.vars.index("density"),
ixmom = my_data.vars.index("x-momentum"),
iymom = my_data.vars.index("y-momentum"),
iener = my_data.vars.index("energy"))
# initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.rp)')
if self.verbose > 0: print(my_data)
def setup_test(n_particles=50, extra_rp_params=None):
"""
Function for setting up Particles tests. Would use unittest for this, but
it doesn't seem to be possible/easy to pass in options to a setUp function.
Sets up runtime paramters, a blank simulation, fills it with a grid and sets
up the boundary conditions and simulation data.
Parameters
----------
n_particles : int
Number of particles to be generated.
extra_rp_params : dict
Dictionary of extra rp parameters.
"""
rp = runparams.RuntimeParameters()
rp.params["mesh.nx"] = 8
rp.params["mesh.ny"] = 8
rp.params["mesh.xmin"] = 0
rp.params["mesh.xmax"] = 1
rp.params["mesh.ymin"] = 0
rp.params["mesh.ymax"] = 1
rp.params["particles.do_particles"] = 1
n_particles = n_particles
if extra_rp_params is not None:
for param, value in extra_rp_params.items():
rp.params[param] = value
# set up sim
sim = NullSimulation("", "", rp)
# set up grid
my_grid = grid_setup(rp)
my_data = patch.CellCenterData2d(my_grid)
bc = bc_setup(rp)[0]
my_data.create()
sim.cc_data = my_data
return sim.cc_data, bc, n_particles
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
my_data = fv.FV2d(my_grid)
bc = bc_setup(self.rp)[0]
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
# now set the initial conditions for the problem
problem = importlib.import_module("advection_fv4.problems.{}".format(
self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for compressible flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
my_data = patch.CellCenterData2d(my_grid)
# define solver specific boundary condition routines
patch.define_bc("hse", BC.user)
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# density and energy
my_data.register_var("density", bc)
my_data.register_var("energy", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
# store the EOS gamma as an auxillary quantity so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("gamma", self.rp.get_param("eos.gamma"))
my_data.set_aux("grav", self.rp.get_param("compressible.grav"))
my_data.create()
self.cc_data = my_data
self.vars = Variables(idens=my_data.vars.index("density"),
ixmom=my_data.vars.index("x-momentum"),
iymom=my_data.vars.index("y-momentum"),
iener=my_data.vars.index("energy"))
# initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.rp)')
if self.verbose > 0: print(my_data)
def initialize(self):
"""
Initialize the grid and variables for diffusion and set the initial
conditions for the chosen problem.
"""
# setup the grid
my_grid = grid_setup(self.rp, ng=1)
# for MG, we need to be a power of two
if my_grid.nx != my_grid.ny:
msg.fail("need nx = ny for diffusion problems")
n = int(math.log(my_grid.nx) / math.log(2.0))
if 2**n != my_grid.nx:
msg.fail("grid needs to be a power of 2")
# create the variables
# first figure out the boundary conditions -- we allow periodic,
# Dirichlet, and Neumann.
bc, _, _ = bc_setup(self.rp)
for bnd in [bc.xlb, bc.xrb, bc.ylb, bc.yrb]:
if bnd not in ["periodic", "neumann", "dirichlet"]:
msg.fail("invalid BC")
my_data = patch.CellCenterData2d(my_grid)
my_data.register_var("phi", bc)
my_data.create()
self.cc_data = my_data
# now set the initial conditions for the problem
problem = importlib.import_module("diffusion.problems.{}".format(
self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for diffusion and set the initial
conditions for the chosen problem.
"""
# setup the grid
my_grid = grid_setup(self.rp, ng=1)
# for MG, we need to be a power of two
if my_grid.nx != my_grid.ny:
msg.fail("need nx = ny for diffusion problems")
n = int(math.log(my_grid.nx)/math.log(2.0))
if 2**n != my_grid.nx:
msg.fail("grid needs to be a power of 2")
# create the variables
# first figure out the boundary conditions -- we allow periodic,
# Dirichlet, and Neumann.
bc, _, _ = bc_setup(self.rp)
for bnd in [bc.xlb, bc.xrb, bc.ylb, bc.yrb]:
if bnd not in ["periodic", "neumann", "dirichlet"]:
msg.fail("invalid BC")
my_data = patch.CellCenterData2d(my_grid)
my_data.register_var("phi", bc)
my_data.create()
self.cc_data = my_data
# now set the initial conditions for the problem
problem = importlib.import_module("diffusion.problems.{}".format(self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for advection and set the initial
conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=4)
# create the variables
my_data = fv.FV2d(my_grid)
bc = bc_setup(self.rp)[0]
my_data.register_var("density", bc)
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
n_particles = self.rp.get_param("particles.n_particles")
particle_generator = self.rp.get_param("particles.particle_generator")
self.particles = particles.Particles(self.cc_data, bc, n_particles, particle_generator)
# now set the initial conditions for the problem
problem = importlib.import_module("advection_fv4.problems.{}".format(self.problem_name))
problem.init_data(self.cc_data, self.rp)
def initialize(self):
"""
Initialize the grid and variables for low Mach atmospheric flow
and set the initial conditions for the chosen problem.
"""
myg = grid_setup(self.rp, ng=4)
bc_dens, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(myg)
my_data.register_var("density", bc_dens)
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# we'll keep the internal energy around just as a diagnostic
my_data.register_var("eint", bc_dens)
# phi -- used for the projections. The boundary conditions
# here depend on velocity. At a wall or inflow, we already
# have the velocity we want on the boundary, so we want
# Neumann (dphi/dn = 0). For outflow, we want Dirichlet (phi
# = 0) -- this ensures that we do not introduce any tangental
# acceleration.
bcs = []
for bc in [self.rp.get_param("mesh.xlboundary"),
self.rp.get_param("mesh.xrboundary"),
self.rp.get_param("mesh.ylboundary"),
self.rp.get_param("mesh.yrboundary")]:
if bc == "periodic":
bctype = "periodic"
elif bc in ["reflect", "slipwall"]:
bctype = "neumann"
elif bc in ["outflow"]:
bctype = "dirichlet"
bcs.append(bctype)
bc_phi = patch.BCObject(xlb=bcs[0], xrb=bcs[1], ylb=bcs[2], yrb=bcs[3])
my_data.register_var("phi-MAC", bc_phi)
my_data.register_var("phi", bc_phi)
# gradp -- used in the projection and interface states. We'll do the
# same BCs as density
my_data.register_var("gradp_x", bc_dens)
my_data.register_var("gradp_y", bc_dens)
my_data.create()
self.cc_data = my_data
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = patch.CellCenterData2d(myg)
aux_data.register_var("coeff", bc_dens)
aux_data.register_var("source_y", bc_yodd)
aux_data.create()
self.aux_data = aux_data
# we also need storage for the 1-d base state -- we'll store this
# in the main class directly.
self.base["rho0"] = np.zeros((myg.qy), dtype=np.float64)
self.base["p0"] = np.zeros((myg.qy), dtype=np.float64)
# now set the initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.base, self.rp)')
# Construct beta_0
gamma = self.rp.get_param("eos.gamma")
self.base["beta0"] = self.base["p0"]**(1.0/gamma)
# we'll also need beta_0 on vertical edges -- on the domain edges,
# just do piecewise constant
self.base["beta0-edges"] = np.zeros((myg.qy), dtype=np.float64)
self.base["beta0-edges"][myg.jlo+1:myg.jhi+1] = \
0.5*(self.base["beta0"][myg.jlo :myg.jhi] +
self.base["beta0"][myg.jlo+1:myg.jhi+1])
self.base["beta0-edges"][myg.jlo] = self.base["beta0"][myg.jlo]
self.base["beta0-edges"][myg.jhi+1] = self.base["beta0"][myg.jhi]
def initialize(self, extra_vars=None, ng=4):
"""
Initialize the grid and variables for compressible flow and set
the initial conditions for the chosen problem.
"""
my_grid = grid_setup(self.rp, ng=ng)
my_data = self.data_class(my_grid)
# define solver specific boundary condition routines
bnd.define_bc("hse", BC.user, is_solid=False)
bnd.define_bc("ramp", BC.user, is_solid=False) # for double mach reflection problem
bc, bc_xodd, bc_yodd = bc_setup(self.rp)
# are we dealing with solid boundaries? we'll use these for
# the Riemann solver
self.solid = bnd.bc_is_solid(bc)
# density and energy
my_data.register_var("density", bc)
my_data.register_var("energy", bc)
my_data.register_var("x-momentum", bc_xodd)
my_data.register_var("y-momentum", bc_yodd)
# any extras?
if extra_vars is not None:
for v in extra_vars:
my_data.register_var(v, bc)
# store the EOS gamma as an auxillary quantity so we can have a
# self-contained object stored in output files to make plots.
# store grav because we'll need that in some BCs
my_data.set_aux("gamma", self.rp.get_param("eos.gamma"))
my_data.set_aux("grav", self.rp.get_param("compressible.grav"))
my_data.create()
self.cc_data = my_data
if self.rp.get_param("particles.do_particles") == 1:
self.particles = particles.Particles(self.cc_data, bc, self.rp)
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = self.data_class(my_grid)
aux_data.register_var("ymom_src", bc_yodd)
aux_data.register_var("E_src", bc)
aux_data.create()
self.aux_data = aux_data
self.ivars = Variables(my_data)
# derived variables
self.cc_data.add_derived(derives.derive_primitives)
# initial conditions for the problem
problem = importlib.import_module("{}.problems.{}".format(
self.solver_name, self.problem_name))
problem.init_data(self.cc_data, self.rp)
if self.verbose > 0:
print(my_data)
def initialize(self):
"""
Initialize the grid and variables for low Mach atmospheric flow
and set the initial conditions for the chosen problem.
"""
myg = grid_setup(self.rp, ng=4)
bc_dens, bc_xodd, bc_yodd = bc_setup(self.rp)
my_data = patch.CellCenterData2d(myg)
my_data.register_var("density", bc_dens)
my_data.register_var("x-velocity", bc_xodd)
my_data.register_var("y-velocity", bc_yodd)
# we'll keep the internal energy around just as a diagnostic
my_data.register_var("eint", bc_dens)
# phi -- used for the projections. The boundary conditions
# here depend on velocity. At a wall or inflow, we already
# have the velocity we want on the boundary, so we want
# Neumann (dphi/dn = 0). For outflow, we want Dirichlet (phi
# = 0) -- this ensures that we do not introduce any tangental
# acceleration.
bcs = []
for bc in [self.rp.get_param("mesh.xlboundary"),
self.rp.get_param("mesh.xrboundary"),
self.rp.get_param("mesh.ylboundary"),
self.rp.get_param("mesh.yrboundary")]:
if bc == "periodic":
bctype = "periodic"
elif bc in ["reflect", "slipwall"]:
bctype = "neumann"
elif bc in ["outflow"]:
bctype = "dirichlet"
bcs.append(bctype)
bc_phi = patch.BCObject(xlb=bcs[0], xrb=bcs[1], ylb=bcs[2], yrb=bcs[3])
my_data.register_var("phi-MAC", bc_phi)
my_data.register_var("phi", bc_phi)
# gradp -- used in the projection and interface states. We'll do the
# same BCs as density
my_data.register_var("gradp_x", bc_dens)
my_data.register_var("gradp_y", bc_dens)
my_data.create()
self.cc_data = my_data
# some auxillary data that we'll need to fill GC in, but isn't
# really part of the main solution
aux_data = patch.CellCenterData2d(myg)
aux_data.register_var("coeff", bc_dens)
aux_data.register_var("source_y", bc_yodd)
aux_data.create()
self.aux_data = aux_data
# we also need storage for the 1-d base state -- we'll store this
# in the main class directly.
self.base["rho0"] = Basestate(myg.ny, ng=myg.ng)
self.base["p0"] = Basestate(myg.ny, ng=myg.ng)
# now set the initial conditions for the problem
exec(self.problem_name + '.init_data(self.cc_data, self.base, self.rp)')
# Construct beta_0
gamma = self.rp.get_param("eos.gamma")
self.base["beta0"] = Basestate(myg.ny, ng=myg.ng)
self.base["beta0"].d[:] = self.base["p0"].d**(1.0/gamma)
# we'll also need beta_0 on vertical edges -- on the domain edges,
# just do piecewise constant
self.base["beta0-edges"] = Basestate(myg.ny, ng=myg.ng)
self.base["beta0-edges"].jp(1)[:] = \
0.5*(self.base["beta0"].v() + self.base["beta0"].jp(1))
self.base["beta0-edges"].d[myg.jlo] = self.base["beta0"].d[myg.jlo]
self.base["beta0-edges"].d[myg.jhi+1] = self.base["beta0"].d[myg.jhi]
