def main():
logmgr = LogManager("mylog.dat", "w") # , comm=...
# set a run property
logmgr.set_constant("myconst", uniform(0, 1))
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
logmgr.add_quantity(Fifteen("fifteen"))
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
for istep in range(200):
logmgr.tick_before()
dt = uniform(0.01, 0.1)
set_dt(logmgr, dt)
sleep(dt)
# Illustrate custom timers
if istep % 10 == 0:
with vis_timer.start_sub_timer():
sleep(0.05)
# Illustrate warnings capture
if uniform(0, 1) < 0.05:
warn("Oof. Something went awry.")
logmgr.tick_after()
logmgr.close()
def main(write_output=True):
from hedge.backends import guess_run_context
rcon = guess_run_context(
#["cuda"]
)
gamma = 1.4
# at A=1 we have case of isentropic vortex, source terms
# arise for other values
densityA = 2.0
from hedge.tools import EOCRecorder, to_obj_array
eoc_rec = EOCRecorder()
if rcon.is_head_rank:
from hedge.mesh import \
make_rect_mesh, \
make_centered_regular_rect_mesh
refine = 1
mesh = make_centered_regular_rect_mesh((0,-5), (10,5), n=(9,9),
post_refine_factor=refine)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [4,5]:
discr = rcon.make_discretization(mesh_data, order=order,
debug=[#"cuda_no_plan",
#"print_op_code"
],
default_scalar_type=numpy.float64)
from hedge.visualization import SiloVisualizer, VtkVisualizer
#vis = VtkVisualizer(discr, rcon, "vortex-%d" % order)
vis = SiloVisualizer(discr, rcon)
vortex = Vortex(beta=5, gamma=gamma,
center=[5,0],
velocity=[1,0], densityA=densityA)
fields = vortex.volume_interpolant(0, discr)
sources=SourceTerms(beta=5, gamma=gamma,
center=[5,0],
velocity=[1,0], densityA=densityA)
from hedge.models.gas_dynamics import (
GasDynamicsOperator, GammaLawEOS)
from hedge.mesh import TAG_ALL
op = GasDynamicsOperator(dimensions=2,
mu=0.0, prandtl=0.72, spec_gas_const=287.1,
equation_of_state=GammaLawEOS(vortex.gamma),
bc_inflow=vortex, bc_outflow=vortex, bc_noslip=vortex,
inflow_tag=TAG_ALL, source=sources)
euler_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
# limiter setup -------------------------------------------------------
from hedge.models.gas_dynamics import SlopeLimiter1NEuler
limiter = SlopeLimiter1NEuler(discr, gamma, 2, op)
# time stepper --------------------------------------------------------
from hedge.timestep import SSPRK3TimeStepper, RK4TimeStepper
#stepper = SSPRK3TimeStepper(limiter=limiter)
#stepper = SSPRK3TimeStepper()
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "euler-%d.dat" % order
else:
log_file_name = None
logmgr = LogManager(log_file_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
t = 0
#fields = limiter(fields)
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=.1,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: 0.4*op.estimate_timestep(discr,
stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 1 == 0 and write_output:
#if False:
visf = vis.make_file("vortex-%d-%04d" % (order, step))
true_fields = vortex.volume_interpolant(t, discr)
#rhs_fields = rhs(t, fields)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf,
[
("rho", discr.convert_volume(op.rho(fields), kind="numpy")),
("e", discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u", discr.convert_volume(op.rho_u(fields), kind="numpy")),
("u", discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
#("rhs_rho", discr.convert_volume(op.rho(rhs_fields), kind="numpy")),
#("rhs_e", discr.convert_volume(op.e(rhs_fields), kind="numpy")),
#("rhs_rho_u", discr.convert_volume(op.rho_u(rhs_fields), kind="numpy")),
],
expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
("p", "0.4*(e- 0.5*(rho_u*u))"),
],
time=t, step=step
)
visf.close()
fields = stepper(fields, t, dt, rhs)
true_fields = vortex.volume_interpolant(t, discr)
l2_error = discr.norm(fields-true_fields)
l2_error_rho = discr.norm(op.rho(fields)-op.rho(true_fields))
l2_error_e = discr.norm(op.e(fields)-op.e(true_fields))
l2_error_rhou = discr.norm(op.rho_u(fields)-op.rho_u(true_fields))
l2_error_u = discr.norm(op.u(fields)-op.u(true_fields))
eoc_rec.add_data_point(order, l2_error_rho)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
logmgr.set_constant("l2_error_rho", l2_error_rho)
logmgr.set_constant("l2_error_e", l2_error_e)
logmgr.set_constant("l2_error_rhou", l2_error_rhou)
logmgr.set_constant("l2_error_u", l2_error_u)
logmgr.set_constant("refinement", refine)
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
def main(write_output=True):
from pytools import add_python_path_relative_to_script
add_python_path_relative_to_script("..")
from hedge.backends import guess_run_context
rcon = guess_run_context()
from hedge.tools import EOCRecorder
eoc_rec = EOCRecorder()
if rcon.is_head_rank:
from hedge.mesh.generator import \
make_rect_mesh, \
make_centered_regular_rect_mesh
refine = 4
mesh = make_centered_regular_rect_mesh((0,-5), (10,5), n=(9,9),
post_refine_factor=refine)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3, 4, 5]:
from gas_dynamics_initials import Vortex
flow = Vortex()
from hedge.models.gas_dynamics import (
GasDynamicsOperator, PolytropeEOS, GammaLawEOS)
from hedge.mesh import TAG_ALL
# works equally well for GammaLawEOS
op = GasDynamicsOperator(dimensions=2, mu=flow.mu,
prandtl=flow.prandtl, spec_gas_const=flow.spec_gas_const,
equation_of_state=PolytropeEOS(flow.gamma),
bc_inflow=flow, bc_outflow=flow, bc_noslip=flow,
inflow_tag=TAG_ALL, source=None)
discr = rcon.make_discretization(mesh_data, order=order,
default_scalar_type=numpy.float64,
quad_min_degrees={
"gasdyn_vol": 3*order,
"gasdyn_face": 3*order,
},
tune_for=op.op_template(),
debug=["cuda_no_plan"])
from hedge.visualization import SiloVisualizer, VtkVisualizer
vis = VtkVisualizer(discr, rcon, "vortex-%d" % order)
#vis = SiloVisualizer(discr, rcon)
fields = flow.volume_interpolant(0, discr)
euler_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
# limiter ------------------------------------------------------------
from hedge.models.gas_dynamics import SlopeLimiter1NEuler
limiter = SlopeLimiter1NEuler(discr, flow.gamma, 2, op)
from hedge.timestep.runge_kutta import SSP3TimeStepper
#stepper = SSP3TimeStepper(limiter=limiter)
stepper = SSP3TimeStepper(
vector_primitive_factory=discr.get_vector_primitive_factory())
#from hedge.timestep import RK4TimeStepper
#stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "euler-%d.dat" % order
else:
log_file_name = None
logmgr = LogManager(log_file_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
final_time = flow.final_time
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=final_time, logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(discr,
stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
print "run until t=%g" % final_time
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
#if False:
visf = vis.make_file("vortex-%d-%04d" % (order, step))
#true_fields = vortex.volume_interpolant(t, discr)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf,
[
("rho", discr.convert_volume(op.rho(fields), kind="numpy")),
("e", discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u", discr.convert_volume(op.rho_u(fields), kind="numpy")),
("u", discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
#("rhs_rho", discr.convert_volume(op.rho(rhs_fields), kind="numpy")),
#("rhs_e", discr.convert_volume(op.e(rhs_fields), kind="numpy")),
#("rhs_rho_u", discr.convert_volume(op.rho_u(rhs_fields), kind="numpy")),
],
#expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
#("p", "0.4*(e- 0.5*(rho_u*u))"),
#],
time=t, step=step
)
visf.close()
fields = stepper(fields, t, dt, rhs)
#fields = limiter(fields)
assert not numpy.isnan(numpy.sum(fields[0]))
true_fields = flow.volume_interpolant(final_time, discr)
l2_error = discr.norm(fields-true_fields)
l2_error_rho = discr.norm(op.rho(fields)-op.rho(true_fields))
l2_error_e = discr.norm(op.e(fields)-op.e(true_fields))
l2_error_rhou = discr.norm(op.rho_u(fields)-op.rho_u(true_fields))
l2_error_u = discr.norm(op.u(fields)-op.u(true_fields))
eoc_rec.add_data_point(order, l2_error)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
logmgr.set_constant("l2_error_rho", l2_error_rho)
logmgr.set_constant("l2_error_e", l2_error_e)
logmgr.set_constant("l2_error_rhou", l2_error_rhou)
logmgr.set_constant("l2_error_u", l2_error_u)
logmgr.set_constant("refinement", refine)
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
# after order loop
assert eoc_rec.estimate_order_of_convergence()[0,1] > 6
def main():
from hedge.backends import guess_run_context
rcon = guess_run_context(
#["cuda"]
)
from hedge.tools import EOCRecorder, to_obj_array
eoc_rec = EOCRecorder()
def boundary_tagger(vertices, el, face_nr, all_v):
return ["inflow"]
if rcon.is_head_rank:
from hedge.mesh import make_rect_mesh, \
make_centered_regular_rect_mesh
#mesh = make_rect_mesh((0,0), (10,1), max_area=0.01)
refine = 1
mesh = make_centered_regular_rect_mesh(
(0, 0),
(10, 1),
n=(20, 4),
#periodicity=(True, False),
post_refine_factor=refine,
boundary_tagger=boundary_tagger)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3]:
discr = rcon.make_discretization(mesh_data,
order=order,
default_scalar_type=numpy.float64)
from hedge.visualization import SiloVisualizer, VtkVisualizer
#vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order)
vis = SiloVisualizer(discr, rcon)
shearflow = SteadyShearFlow()
fields = shearflow.volume_interpolant(0, discr)
gamma, mu, prandtl, spec_gas_const = shearflow.properties()
from hedge.models.gas_dynamics import GasDynamicsOperator
op = GasDynamicsOperator(dimensions=2,
gamma=gamma,
mu=mu,
prandtl=prandtl,
spec_gas_const=spec_gas_const,
bc_inflow=shearflow,
bc_outflow=shearflow,
bc_noslip=shearflow,
inflow_tag="inflow",
outflow_tag="outflow",
noslip_tag="noslip")
navierstokes_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = navierstokes_ex(t, q)
max_eigval[0] = speed
return ode_rhs
# needed to get first estimate of maximum eigenvalue
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep import RK4TimeStepper
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
logmgr = LogManager("navierstokes-cpu-%d-%d.dat" % (order, refine),
"w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=0.3,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 10 == 0:
#if False:
visf = vis.make_file("shearflow-%d-%04d" % (order, step))
#true_fields = shearflow.volume_interpolant(t, discr)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(
visf,
[
("rho",
discr.convert_volume(op.rho(fields),
kind="numpy")),
("e",
discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u",
discr.convert_volume(op.rho_u(fields),
kind="numpy")),
("u",
discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
],
expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
("p", "0.4*(e- 0.5*(rho_u*u))"),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
true_fields = shearflow.volume_interpolant(t, discr)
l2_error = discr.norm(op.u(fields) - op.u(true_fields))
eoc_rec.add_data_point(order, l2_error)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
finally:
vis.close()
logmgr.save()
discr.close()
def main(write_output=True):
from pytools import add_python_path_relative_to_script
add_python_path_relative_to_script("..")
from hedge.backends import guess_run_context
rcon = guess_run_context()
from hedge.tools import EOCRecorder
eoc_rec = EOCRecorder()
if rcon.is_head_rank:
from hedge.mesh.generator import \
make_rect_mesh, \
make_centered_regular_rect_mesh
refine = 4
mesh = make_centered_regular_rect_mesh((0, -5), (10, 5),
n=(9, 9),
post_refine_factor=refine)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3, 4, 5]:
from gas_dynamics_initials import Vortex
flow = Vortex()
from hedge.models.gas_dynamics import (GasDynamicsOperator,
PolytropeEOS, GammaLawEOS)
from hedge.mesh import TAG_ALL
# works equally well for GammaLawEOS
op = GasDynamicsOperator(dimensions=2,
mu=flow.mu,
prandtl=flow.prandtl,
spec_gas_const=flow.spec_gas_const,
equation_of_state=PolytropeEOS(flow.gamma),
bc_inflow=flow,
bc_outflow=flow,
bc_noslip=flow,
inflow_tag=TAG_ALL,
source=None)
discr = rcon.make_discretization(mesh_data,
order=order,
default_scalar_type=numpy.float64,
quad_min_degrees={
"gasdyn_vol": 3 * order,
"gasdyn_face": 3 * order,
},
tune_for=op.op_template(),
debug=["cuda_no_plan"])
from hedge.visualization import SiloVisualizer, VtkVisualizer
vis = VtkVisualizer(discr, rcon, "vortex-%d" % order)
#vis = SiloVisualizer(discr, rcon)
fields = flow.volume_interpolant(0, discr)
euler_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
# limiter ------------------------------------------------------------
from hedge.models.gas_dynamics import SlopeLimiter1NEuler
limiter = SlopeLimiter1NEuler(discr, flow.gamma, 2, op)
from hedge.timestep.runge_kutta import SSP3TimeStepper
#stepper = SSP3TimeStepper(limiter=limiter)
stepper = SSP3TimeStepper(
vector_primitive_factory=discr.get_vector_primitive_factory())
#from hedge.timestep import RK4TimeStepper
#stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "euler-%d.dat" % order
else:
log_file_name = None
logmgr = LogManager(log_file_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
final_time = flow.final_time
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=final_time,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
print "run until t=%g" % final_time
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
#if False:
visf = vis.make_file("vortex-%d-%04d" % (order, step))
#true_fields = vortex.volume_interpolant(t, discr)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(
visf,
[
("rho",
discr.convert_volume(op.rho(fields),
kind="numpy")),
("e",
discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u",
discr.convert_volume(op.rho_u(fields),
kind="numpy")),
("u",
discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
#("rhs_rho", discr.convert_volume(op.rho(rhs_fields), kind="numpy")),
#("rhs_e", discr.convert_volume(op.e(rhs_fields), kind="numpy")),
#("rhs_rho_u", discr.convert_volume(op.rho_u(rhs_fields), kind="numpy")),
],
#expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
#("p", "0.4*(e- 0.5*(rho_u*u))"),
#],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
#fields = limiter(fields)
assert not numpy.isnan(numpy.sum(fields[0]))
true_fields = flow.volume_interpolant(final_time, discr)
l2_error = discr.norm(fields - true_fields)
l2_error_rho = discr.norm(op.rho(fields) - op.rho(true_fields))
l2_error_e = discr.norm(op.e(fields) - op.e(true_fields))
l2_error_rhou = discr.norm(
op.rho_u(fields) - op.rho_u(true_fields))
l2_error_u = discr.norm(op.u(fields) - op.u(true_fields))
eoc_rec.add_data_point(order, l2_error)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
logmgr.set_constant("l2_error_rho", l2_error_rho)
logmgr.set_constant("l2_error_e", l2_error_e)
logmgr.set_constant("l2_error_rhou", l2_error_rhou)
logmgr.set_constant("l2_error_u", l2_error_u)
logmgr.set_constant("refinement", refine)
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
# after order loop
assert eoc_rec.estimate_order_of_convergence()[0, 1] > 6
def main(write_output=True):
from pytools import add_python_path_relative_to_script
add_python_path_relative_to_script("..")
from hedge.backends import guess_run_context
rcon = guess_run_context()
from hedge.tools import EOCRecorder
eoc_rec = EOCRecorder()
if rcon.is_head_rank:
from hedge.mesh.generator import \
make_rect_mesh, \
make_centered_regular_rect_mesh
refine = 4
mesh = make_centered_regular_rect_mesh((0,-5), (10,5), n=(9,9),
post_refine_factor=refine)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
# a second mesh to regrid to
if rcon.is_head_rank:
from hedge.mesh.generator import \
make_rect_mesh, \
make_centered_regular_rect_mesh
refine = 4
mesh2 = make_centered_regular_rect_mesh((0,-5), (10,5), n=(8,8),
post_refine_factor=refine)
mesh_data2 = rcon.distribute_mesh(mesh2)
else:
mesh_data2 = rcon.receive_mesh()
for order in [3,4]:
discr = rcon.make_discretization(mesh_data, order=order,
default_scalar_type=numpy.float64,
quad_min_degrees={
"gasdyn_vol": 3*order,
"gasdyn_face": 3*order,
})
discr2 = rcon.make_discretization(mesh_data2, order=order,
default_scalar_type=numpy.float64,
quad_min_degrees={
"gasdyn_vol": 3*order,
"gasdyn_face": 3*order,
})
from hedge.visualization import SiloVisualizer, VtkVisualizer
vis = VtkVisualizer(discr, rcon, "vortex-%d" % order)
#vis = SiloVisualizer(discr, rcon)
from gas_dynamics_initials import Vortex
vortex = Vortex()
fields = vortex.volume_interpolant(0, discr)
from hedge.models.gas_dynamics import GasDynamicsOperator
from hedge.mesh import TAG_ALL
op = GasDynamicsOperator(dimensions=2, gamma=vortex.gamma, mu=vortex.mu,
prandtl=vortex.prandtl, spec_gas_const=vortex.spec_gas_const,
bc_inflow=vortex, bc_outflow=vortex, bc_noslip=vortex,
inflow_tag=TAG_ALL, source=None)
euler_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements for mesh 1 =", len(mesh.elements)
print "#elements for mesh 2 =", len(mesh2.elements)
# limiter ------------------------------------------------------------
from hedge.models.gas_dynamics import SlopeLimiter1NEuler
limiter = SlopeLimiter1NEuler(discr, vortex.gamma, 2, op)
from hedge.timestep import SSPRK3TimeStepper
#stepper = SSPRK3TimeStepper(limiter=limiter)
stepper = SSPRK3TimeStepper()
#from hedge.timestep import RK4TimeStepper
#stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "euler-%d.dat" % order
else:
log_file_name = None
logmgr = LogManager(log_file_name, "w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
final_time = 0.2
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=final_time, logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(discr,
stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
#if False:
visf = vis.make_file("vortex-%d-%04d" % (order, step))
#true_fields = vortex.volume_interpolant(t, discr)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf,
[
("rho", discr.convert_volume(op.rho(fields), kind="numpy")),
("e", discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u", discr.convert_volume(op.rho_u(fields), kind="numpy")),
("u", discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
#("rhs_rho", discr.convert_volume(op.rho(rhs_fields), kind="numpy")),
#("rhs_e", discr.convert_volume(op.e(rhs_fields), kind="numpy")),
#("rhs_rho_u", discr.convert_volume(op.rho_u(rhs_fields), kind="numpy")),
],
#expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
#("p", "0.4*(e- 0.5*(rho_u*u))"),
#],
time=t, step=step
)
visf.close()
fields = stepper(fields, t, dt, rhs)
#fields = limiter(fields)
#regrid to discr2 at some arbitrary time
if step == 21:
#get interpolated fields
fields = discr.get_regrid_values(fields, discr2, dtype=None, use_btree=True, thresh=1e-8)
#get new stepper (old one has reference to discr
stepper = SSPRK3TimeStepper()
#new bind
euler_ex = op.bind(discr2)
#new rhs
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = euler_ex(t, q)
max_eigval[0] = speed
return ode_rhs
rhs(t+dt, fields)
#add logmanager
#discr2.add_instrumentation(logmgr)
#new step_it
step_it = times_and_steps(
final_time=final_time, logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(discr2,
stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
#new visualization
vis.close()
vis = VtkVisualizer(discr2, rcon, "vortexNewGrid-%d" % order)
discr=discr2
assert not numpy.isnan(numpy.sum(fields[0]))
true_fields = vortex.volume_interpolant(final_time, discr)
l2_error = discr.norm(fields-true_fields)
l2_error_rho = discr.norm(op.rho(fields)-op.rho(true_fields))
l2_error_e = discr.norm(op.e(fields)-op.e(true_fields))
l2_error_rhou = discr.norm(op.rho_u(fields)-op.rho_u(true_fields))
l2_error_u = discr.norm(op.u(fields)-op.u(true_fields))
eoc_rec.add_data_point(order, l2_error)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
logmgr.set_constant("l2_error_rho", l2_error_rho)
logmgr.set_constant("l2_error_e", l2_error_e)
logmgr.set_constant("l2_error_rhou", l2_error_rhou)
logmgr.set_constant("l2_error_u", l2_error_u)
logmgr.set_constant("refinement", refine)
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
def main():
from hedge.backends import guess_run_context
rcon = guess_run_context(
#["cuda"]
)
from hedge.tools import EOCRecorder, to_obj_array
eoc_rec = EOCRecorder()
def boundary_tagger(vertices, el, face_nr, all_v):
return ["inflow"]
if rcon.is_head_rank:
from hedge.mesh import make_rect_mesh, \
make_centered_regular_rect_mesh
#mesh = make_rect_mesh((0,0), (10,1), max_area=0.01)
refine = 1
mesh = make_centered_regular_rect_mesh((0,0), (10,1), n=(20,4),
#periodicity=(True, False),
post_refine_factor=refine,
boundary_tagger=boundary_tagger)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [3]:
discr = rcon.make_discretization(mesh_data, order=order,
default_scalar_type=numpy.float64)
from hedge.visualization import SiloVisualizer, VtkVisualizer
#vis = VtkVisualizer(discr, rcon, "shearflow-%d" % order)
vis = SiloVisualizer(discr, rcon)
shearflow = SteadyShearFlow()
fields = shearflow.volume_interpolant(0, discr)
gamma, mu, prandtl, spec_gas_const = shearflow.properties()
from hedge.models.gas_dynamics import GasDynamicsOperator
op = GasDynamicsOperator(dimensions=2, gamma=gamma, mu=mu,
prandtl=prandtl, spec_gas_const=spec_gas_const,
bc_inflow=shearflow, bc_outflow=shearflow, bc_noslip=shearflow,
inflow_tag="inflow", outflow_tag="outflow", noslip_tag="noslip")
navierstokes_ex = op.bind(discr)
max_eigval = [0]
def rhs(t, q):
ode_rhs, speed = navierstokes_ex(t, q)
max_eigval[0] = speed
return ode_rhs
# needed to get first estimate of maximum eigenvalue
rhs(0, fields)
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep import RK4TimeStepper
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
logmgr = LogManager("navierstokes-cpu-%d-%d.dat" % (order, refine),
"w", rcon.communicator)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
discr.add_instrumentation(logmgr)
stepper.add_instrumentation(logmgr)
logmgr.add_watches(["step.max", "t_sim.max", "t_step.max"])
# timestep loop -------------------------------------------------------
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=0.3,
#max_steps=500,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(discr,
stepper=stepper, t=t, max_eigenvalue=max_eigval[0]))
for step, t, dt in step_it:
if step % 10 == 0:
#if False:
visf = vis.make_file("shearflow-%d-%04d" % (order, step))
#true_fields = shearflow.volume_interpolant(t, discr)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf,
[
("rho", discr.convert_volume(op.rho(fields), kind="numpy")),
("e", discr.convert_volume(op.e(fields), kind="numpy")),
("rho_u", discr.convert_volume(op.rho_u(fields), kind="numpy")),
("u", discr.convert_volume(op.u(fields), kind="numpy")),
#("true_rho", discr.convert_volume(op.rho(true_fields), kind="numpy")),
#("true_e", discr.convert_volume(op.e(true_fields), kind="numpy")),
#("true_rho_u", discr.convert_volume(op.rho_u(true_fields), kind="numpy")),
#("true_u", discr.convert_volume(op.u(true_fields), kind="numpy")),
],
expressions=[
#("diff_rho", "rho-true_rho"),
#("diff_e", "e-true_e"),
#("diff_rho_u", "rho_u-true_rho_u", DB_VARTYPE_VECTOR),
("p", "0.4*(e- 0.5*(rho_u*u))"),
],
time=t, step=step
)
visf.close()
fields = stepper(fields, t, dt, rhs)
true_fields = shearflow.volume_interpolant(t, discr)
l2_error = discr.norm(op.u(fields)-op.u(true_fields))
eoc_rec.add_data_point(order, l2_error)
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
logmgr.set_constant("l2_error", l2_error)
finally:
vis.close()
logmgr.save()
discr.close()
class PICRunner(object):
def __init__(self):
from pyrticle.units import SIUnitsWithNaturalConstants
self.units = units = SIUnitsWithNaturalConstants()
ui = PICCPyUserInterface(units)
setup = self.setup = ui.gather()
from pytools.log import LogManager
import os.path
self.logmgr = LogManager(os.path.join(
setup.output_path, "pic.dat"), "w")
from hedge.backends import guess_run_context
self.rcon = guess_run_context([])
if self.rcon.is_head_rank:
mesh = self.rcon.distribute_mesh(setup.mesh)
else:
mesh = self.rcon.receive_mesh()
self.discr = discr = \
self.rcon.make_discretization(mesh,
order=setup.element_order,
debug=setup.dg_debug)
self.logmgr.set_constant("elements_total", len(setup.mesh.elements))
self.logmgr.set_constant("elements_local", len(mesh.elements))
self.logmgr.set_constant("element_order", setup.element_order)
# em operator ---------------------------------------------------------
maxwell_kwargs = {
"epsilon": units.EPSILON0,
"mu": units.MU0,
"flux_type": setup.maxwell_flux_type,
"bdry_flux_type": setup.maxwell_bdry_flux_type
}
if discr.dimensions == 3:
from hedge.models.em import MaxwellOperator
self.maxwell_op = MaxwellOperator(**maxwell_kwargs)
elif discr.dimensions == 2:
from hedge.models.em import TEMaxwellOperator
self.maxwell_op = TEMaxwellOperator(**maxwell_kwargs)
else:
raise ValueError, "invalid mesh dimension"
if setup.chi is not None:
from pyrticle.hyperbolic import ECleaningMaxwellOperator
self.maxwell_op = ECleaningMaxwellOperator(self.maxwell_op,
chi=setup.chi,
phi_decay=setup.phi_decay)
if setup.phi_filter is not None:
from pyrticle.hyperbolic import PhiFilter
from hedge.discretization import Filter, ExponentialFilterResponseFunction
em_filters.append(
PhiFilter(maxwell_op, Filter(discr,
ExponentialFilterResponseFunction(*setup.phi_filter))))
# timestepping setup --------------------------------------------------
goal_dt = self.maxwell_op.estimate_timestep(discr) * setup.dt_scale
self.nsteps = int(setup.final_time/goal_dt)+1
self.dt = setup.final_time/self.nsteps
self.stepper = setup.timestepper_maker(self.dt)
# particle setup ------------------------------------------------------
from pyrticle.cloud import PicMethod, PicState, \
optimize_shape_bandwidth, \
guess_shape_bandwidth
method = self.method = PicMethod(discr, units,
setup.depositor, setup.pusher,
dimensions_pos=setup.dimensions_pos,
dimensions_velocity=setup.dimensions_velocity,
debug=setup.debug)
self.state = method.make_state()
method.add_particles(
self.state,
setup.distribution.generate_particles(),
setup.nparticles)
self.total_charge = setup.nparticles*setup.distribution.mean()[2][0]
if isinstance(setup.shape_bandwidth, str):
if setup.shape_bandwidth == "optimize":
optimize_shape_bandwidth(method, self.state,
setup.distribution.get_rho_interpolant(
discr, self.total_charge),
setup.shape_exponent)
elif setup.shape_bandwidth == "guess":
guess_shape_bandwidth(method, self.state, setup.shape_exponent)
else:
raise ValueError, "invalid shape bandwidth setting '%s'" % (
setup.shape_bandwidth)
else:
from pyrticle._internal import PolynomialShapeFunction
method.depositor.set_shape_function(
self.state,
PolynomialShapeFunction(
float(setup.shape_bandwidth),
method.mesh_data.dimensions,
setup.shape_exponent,
))
# initial condition ---------------------------------------------------
if "no_ic" in setup.debug:
self.fields = self.maxwell_op.assemble_eh(discr=discr)
else:
from pyrticle.cloud import compute_initial_condition
self.fields = compute_initial_condition(self.rcon, discr, method, self.state,
maxwell_op=self.maxwell_op,
potential_bc=setup.potential_bc,
force_zero=False)
# rhs calculators -----------------------------------------------------
from pyrticle.cloud import \
FieldRhsCalculator, \
FieldToParticleRhsCalculator, \
ParticleRhsCalculator, \
ParticleToFieldRhsCalculator
self.f_rhs_calculator = FieldRhsCalculator(self.method, self.maxwell_op)
self.p_rhs_calculator = ParticleRhsCalculator(self.method, self.maxwell_op)
self.f2p_rhs_calculator = FieldToParticleRhsCalculator(self.method, self.maxwell_op)
self.p2f_rhs_calculator = ParticleToFieldRhsCalculator(self.method, self.maxwell_op)
# instrumentation setup -----------------------------------------------
self.add_instrumentation(self.logmgr)
def add_instrumentation(self, logmgr):
from pytools.log import \
add_simulation_quantities, \
add_general_quantities, \
add_run_info, ETA
from pyrticle.log import add_particle_quantities, add_field_quantities, \
add_beam_quantities, add_currents
setup = self.setup
from pyrticle.log import StateObserver
self.observer = StateObserver(self.method, self.maxwell_op)
self.observer.set_fields_and_state(self.fields, self.state)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
add_particle_quantities(logmgr, self.observer)
add_field_quantities(logmgr, self.observer)
if setup.beam_axis is not None and setup.beam_diag_axis is not None:
add_beam_quantities(logmgr, self.observer,
axis=setup.beam_diag_axis,
beam_axis=setup.beam_axis)
if setup.tube_length is not None:
from hedge.tools import unit_vector
add_currents(logmgr, self.observer,
unit_vector(self.method.dimensions_velocity, setup.beam_axis),
setup.tube_length)
self.method.add_instrumentation(logmgr, self.observer)
self.f_rhs_calculator.add_instrumentation(logmgr)
if hasattr(self.stepper, "add_instrumentation"):
self.stepper.add_instrumentation(logmgr)
mean_beta = self.method.mean_beta(self.state)
gamma = self.method.units.gamma_from_beta(mean_beta)
logmgr.set_constant("dt", self.dt)
logmgr.set_constant("beta", mean_beta)
logmgr.set_constant("gamma", gamma)
logmgr.set_constant("v", mean_beta*self.units.VACUUM_LIGHT_SPEED())
logmgr.set_constant("Q0", self.total_charge)
logmgr.set_constant("n_part_0", setup.nparticles)
logmgr.set_constant("pmass", setup.distribution.mean()[3][0])
logmgr.set_constant("chi", setup.chi)
logmgr.set_constant("phi_decay", setup.phi_decay)
logmgr.set_constant("shape_radius_setup", setup.shape_bandwidth)
logmgr.set_constant("shape_radius", self.method.depositor.shape_function.radius)
logmgr.set_constant("shape_exponent", self.method.depositor.shape_function.exponent)
from pytools.log import IntervalTimer
self.vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(self.vis_timer)
logmgr.add_quantity(ETA(self.nsteps))
logmgr.add_watches(setup.watch_vars)
def inner_run(self):
t = 0
setup = self.setup
setup.hook_startup(self)
vis_order = setup.vis_order
if vis_order is None:
vis_order = setup.element_order
if vis_order != setup.element_order:
vis_discr = self.rcon.make_discretization(self.discr.mesh,
order=vis_order, debug=setup.dg_debug)
from hedge.discretization import Projector
vis_proj = Projector(self.discr, vis_discr)
else:
vis_discr = self.discr
def vis_proj(f):
return f
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(vis_discr)
fields = self.fields
self.observer.set_fields_and_state(fields, self.state)
from hedge.tools import make_obj_array
from pyrticle.cloud import TimesteppablePicState
def visualize(observer):
sub_timer = self.vis_timer.start_sub_timer()
import os.path
visf = vis.make_file(os.path.join(
setup.output_path, setup.vis_pattern % step))
self.method.add_to_vis(vis, visf, observer.state, time=t, step=step)
vis.add_data(visf,
[(name, vis_proj(fld))
for name, fld in setup.hook_vis_quantities(observer)],
time=t, step=step)
setup.hook_visualize(self, vis, visf, observer)
visf.close()
sub_timer.stop().submit()
from hedge.timestep.multirate_ab import TwoRateAdamsBashforthTimeStepper
if not isinstance(self.stepper, TwoRateAdamsBashforthTimeStepper):
def rhs(t, fields_and_state):
fields, ts_state = fields_and_state
state_f = lambda: ts_state.state
fields_f = lambda: fields
fields_rhs = (
self.f_rhs_calculator(t, fields_f, state_f)
+ self.p2f_rhs_calculator(t, fields_f, state_f))
state_rhs = (
self.p_rhs_calculator(t, fields_f, state_f)
+ self.f2p_rhs_calculator(t, fields_f, state_f))
return make_obj_array([fields_rhs, state_rhs])
step_args = (self.dt, rhs)
else:
def add_unwrap(rhs):
def unwrapping_rhs(t, fields, ts_state):
return rhs(t, fields, lambda: ts_state().state)
return unwrapping_rhs
step_args = ((
add_unwrap(self.f_rhs_calculator),
add_unwrap(self.p2f_rhs_calculator),
add_unwrap(self.f2p_rhs_calculator),
add_unwrap(self.p_rhs_calculator),
),)
y = make_obj_array([
fields,
TimesteppablePicState(self.method, self.state)
])
del self.state
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
max_steps=self.nsteps,
logmgr=self.logmgr,
max_dt_getter=lambda t: self.dt)
for step, t, dt in step_it:
self.method.upkeep(y[1].state)
if step % setup.vis_interval == 0:
visualize(self.observer)
y = self.stepper(y, t, *step_args)
fields, ts_state = y
self.observer.set_fields_and_state(fields, ts_state.state)
setup.hook_after_step(self, self.observer)
finally:
vis.close()
self.discr.close()
self.logmgr.save()
setup.hook_when_done(self)
def run(self):
if self.setup.profile_output_filename is not None:
from cProfile import Profile
prof = Profile()
try:
prof.runcall(self.inner_run)
finally:
from lsprofcalltree import KCacheGrind
kg = KCacheGrind(prof)
kg.output(open(self.setup.profile_output_filename, "w"))
else:
self.inner_run()
class PICRunner(object):
def __init__(self):
from pyrticle.units import SIUnitsWithNaturalConstants
self.units = units = SIUnitsWithNaturalConstants()
ui = PICCPyUserInterface(units)
setup = self.setup = ui.gather()
from pytools.log import LogManager
import os.path
self.logmgr = LogManager(os.path.join(setup.output_path, "pic.dat"),
"w")
from hedge.backends import guess_run_context
self.rcon = guess_run_context([])
if self.rcon.is_head_rank:
mesh = self.rcon.distribute_mesh(setup.mesh)
else:
mesh = self.rcon.receive_mesh()
self.discr = discr = \
self.rcon.make_discretization(mesh,
order=setup.element_order,
debug=setup.dg_debug)
self.logmgr.set_constant("elements_total", len(setup.mesh.elements))
self.logmgr.set_constant("elements_local", len(mesh.elements))
self.logmgr.set_constant("element_order", setup.element_order)
# em operator ---------------------------------------------------------
maxwell_kwargs = {
"epsilon": units.EPSILON0,
"mu": units.MU0,
"flux_type": setup.maxwell_flux_type,
"bdry_flux_type": setup.maxwell_bdry_flux_type
}
if discr.dimensions == 3:
from hedge.models.em import MaxwellOperator
self.maxwell_op = MaxwellOperator(**maxwell_kwargs)
elif discr.dimensions == 2:
from hedge.models.em import TEMaxwellOperator
self.maxwell_op = TEMaxwellOperator(**maxwell_kwargs)
else:
raise ValueError, "invalid mesh dimension"
if setup.chi is not None:
from pyrticle.hyperbolic import ECleaningMaxwellOperator
self.maxwell_op = ECleaningMaxwellOperator(
self.maxwell_op, chi=setup.chi, phi_decay=setup.phi_decay)
if setup.phi_filter is not None:
from pyrticle.hyperbolic import PhiFilter
from hedge.discretization import Filter, ExponentialFilterResponseFunction
em_filters.append(
PhiFilter(
maxwell_op,
Filter(
discr,
ExponentialFilterResponseFunction(
*setup.phi_filter))))
# timestepping setup --------------------------------------------------
goal_dt = self.maxwell_op.estimate_timestep(discr) * setup.dt_scale
self.nsteps = int(setup.final_time / goal_dt) + 1
self.dt = setup.final_time / self.nsteps
self.stepper = setup.timestepper_maker(self.dt)
# particle setup ------------------------------------------------------
from pyrticle.cloud import PicMethod, PicState, \
optimize_shape_bandwidth, \
guess_shape_bandwidth
method = self.method = PicMethod(
discr,
units,
setup.depositor,
setup.pusher,
dimensions_pos=setup.dimensions_pos,
dimensions_velocity=setup.dimensions_velocity,
debug=setup.debug)
self.state = method.make_state()
method.add_particles(self.state,
setup.distribution.generate_particles(),
setup.nparticles)
self.total_charge = setup.nparticles * setup.distribution.mean()[2][0]
if isinstance(setup.shape_bandwidth, str):
if setup.shape_bandwidth == "optimize":
optimize_shape_bandwidth(
method, self.state,
setup.distribution.get_rho_interpolant(
discr, self.total_charge), setup.shape_exponent)
elif setup.shape_bandwidth == "guess":
guess_shape_bandwidth(method, self.state, setup.shape_exponent)
else:
raise ValueError, "invalid shape bandwidth setting '%s'" % (
setup.shape_bandwidth)
else:
from pyrticle._internal import PolynomialShapeFunction
method.depositor.set_shape_function(
self.state,
PolynomialShapeFunction(
float(setup.shape_bandwidth),
method.mesh_data.dimensions,
setup.shape_exponent,
))
# initial condition ---------------------------------------------------
if "no_ic" in setup.debug:
self.fields = self.maxwell_op.assemble_eh(discr=discr)
else:
from pyrticle.cloud import compute_initial_condition
self.fields = compute_initial_condition(
self.rcon,
discr,
method,
self.state,
maxwell_op=self.maxwell_op,
potential_bc=setup.potential_bc,
force_zero=False)
# rhs calculators -----------------------------------------------------
from pyrticle.cloud import \
FieldRhsCalculator, \
FieldToParticleRhsCalculator, \
ParticleRhsCalculator, \
ParticleToFieldRhsCalculator
self.f_rhs_calculator = FieldRhsCalculator(self.method,
self.maxwell_op)
self.p_rhs_calculator = ParticleRhsCalculator(self.method,
self.maxwell_op)
self.f2p_rhs_calculator = FieldToParticleRhsCalculator(
self.method, self.maxwell_op)
self.p2f_rhs_calculator = ParticleToFieldRhsCalculator(
self.method, self.maxwell_op)
# instrumentation setup -----------------------------------------------
self.add_instrumentation(self.logmgr)
def add_instrumentation(self, logmgr):
from pytools.log import \
add_simulation_quantities, \
add_general_quantities, \
add_run_info, ETA
from pyrticle.log import add_particle_quantities, add_field_quantities, \
add_beam_quantities, add_currents
setup = self.setup
from pyrticle.log import StateObserver
self.observer = StateObserver(self.method, self.maxwell_op)
self.observer.set_fields_and_state(self.fields, self.state)
add_run_info(logmgr)
add_general_quantities(logmgr)
add_simulation_quantities(logmgr)
add_particle_quantities(logmgr, self.observer)
add_field_quantities(logmgr, self.observer)
if setup.beam_axis is not None and setup.beam_diag_axis is not None:
add_beam_quantities(logmgr,
self.observer,
axis=setup.beam_diag_axis,
beam_axis=setup.beam_axis)
if setup.tube_length is not None:
from hedge.tools import unit_vector
add_currents(
logmgr, self.observer,
unit_vector(self.method.dimensions_velocity, setup.beam_axis),
setup.tube_length)
self.method.add_instrumentation(logmgr, self.observer)
self.f_rhs_calculator.add_instrumentation(logmgr)
if hasattr(self.stepper, "add_instrumentation"):
self.stepper.add_instrumentation(logmgr)
mean_beta = self.method.mean_beta(self.state)
gamma = self.method.units.gamma_from_beta(mean_beta)
logmgr.set_constant("dt", self.dt)
logmgr.set_constant("beta", mean_beta)
logmgr.set_constant("gamma", gamma)
logmgr.set_constant("v", mean_beta * self.units.VACUUM_LIGHT_SPEED())
logmgr.set_constant("Q0", self.total_charge)
logmgr.set_constant("n_part_0", setup.nparticles)
logmgr.set_constant("pmass", setup.distribution.mean()[3][0])
logmgr.set_constant("chi", setup.chi)
logmgr.set_constant("phi_decay", setup.phi_decay)
logmgr.set_constant("shape_radius_setup", setup.shape_bandwidth)
logmgr.set_constant("shape_radius",
self.method.depositor.shape_function.radius)
logmgr.set_constant("shape_exponent",
self.method.depositor.shape_function.exponent)
from pytools.log import IntervalTimer
self.vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(self.vis_timer)
logmgr.add_quantity(ETA(self.nsteps))
logmgr.add_watches(setup.watch_vars)
def inner_run(self):
t = 0
setup = self.setup
setup.hook_startup(self)
vis_order = setup.vis_order
if vis_order is None:
vis_order = setup.element_order
if vis_order != setup.element_order:
vis_discr = self.rcon.make_discretization(self.discr.mesh,
order=vis_order,
debug=setup.dg_debug)
from hedge.discretization import Projector
vis_proj = Projector(self.discr, vis_discr)
else:
vis_discr = self.discr
def vis_proj(f):
return f
from hedge.visualization import SiloVisualizer
vis = SiloVisualizer(vis_discr)
fields = self.fields
self.observer.set_fields_and_state(fields, self.state)
from hedge.tools import make_obj_array
from pyrticle.cloud import TimesteppablePicState
def visualize(observer):
sub_timer = self.vis_timer.start_sub_timer()
import os.path
visf = vis.make_file(
os.path.join(setup.output_path, setup.vis_pattern % step))
self.method.add_to_vis(vis,
visf,
observer.state,
time=t,
step=step)
vis.add_data(
visf, [(name, vis_proj(fld))
for name, fld in setup.hook_vis_quantities(observer)],
time=t,
step=step)
setup.hook_visualize(self, vis, visf, observer)
visf.close()
sub_timer.stop().submit()
from hedge.timestep.multirate_ab import TwoRateAdamsBashforthTimeStepper
if not isinstance(self.stepper, TwoRateAdamsBashforthTimeStepper):
def rhs(t, fields_and_state):
fields, ts_state = fields_and_state
state_f = lambda: ts_state.state
fields_f = lambda: fields
fields_rhs = (self.f_rhs_calculator(t, fields_f, state_f) +
self.p2f_rhs_calculator(t, fields_f, state_f))
state_rhs = (self.p_rhs_calculator(t, fields_f, state_f) +
self.f2p_rhs_calculator(t, fields_f, state_f))
return make_obj_array([fields_rhs, state_rhs])
step_args = (self.dt, rhs)
else:
def add_unwrap(rhs):
def unwrapping_rhs(t, fields, ts_state):
return rhs(t, fields, lambda: ts_state().state)
return unwrapping_rhs
step_args = ((
add_unwrap(self.f_rhs_calculator),
add_unwrap(self.p2f_rhs_calculator),
add_unwrap(self.f2p_rhs_calculator),
add_unwrap(self.p_rhs_calculator),
), )
y = make_obj_array(
[fields, TimesteppablePicState(self.method, self.state)])
del self.state
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(max_steps=self.nsteps,
logmgr=self.logmgr,
max_dt_getter=lambda t: self.dt)
for step, t, dt in step_it:
self.method.upkeep(y[1].state)
if step % setup.vis_interval == 0:
visualize(self.observer)
y = self.stepper(y, t, *step_args)
fields, ts_state = y
self.observer.set_fields_and_state(fields, ts_state.state)
setup.hook_after_step(self, self.observer)
finally:
vis.close()
self.discr.close()
self.logmgr.save()
setup.hook_when_done(self)
def run(self):
if self.setup.profile_output_filename is not None:
from cProfile import Profile
prof = Profile()
try:
prof.runcall(self.inner_run)
finally:
from lsprofcalltree import KCacheGrind
kg = KCacheGrind(prof)
kg.output(open(self.setup.profile_output_filename, "w"))
else:
self.inner_run()
