def add_instrumentation(self, mgr, observer):
Depositor.add_instrumentation(self, mgr, observer)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.element_activation_counter = EventCounter(
"n_el_activations",
"#Advective rec. elements activated this timestep")
self.element_kill_counter = EventCounter(
"n_el_kills", "#Advective rec. elements retired this timestep")
self.advective_rhs_timer = IntervalTimer(
"t_advective_rhs", "Time spent evaluating advective RHS")
self.active_elements_log = ActiveAdvectiveElements(observer)
mgr.add_quantity(self.element_activation_counter)
mgr.add_quantity(self.element_kill_counter)
mgr.add_quantity(self.advective_rhs_timer)
mgr.add_quantity(self.active_elements_log)
mgr.set_constant("el_activation_threshold", self.activation_threshold)
mgr.set_constant("el_kill_threshold", self.kill_threshold)
mgr.set_constant("adv_upwind_alpha", self.upwind_alpha)
mgr.set_constant("filter_amp", self.filter_amp)
mgr.set_constant("filter_amp", self.filter_order)
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 __init__(self, method, maxwell_op):
self.method = method
self.maxwell_op = maxwell_op
self.bound_maxwell_op = maxwell_op.bind(self.method.discretization)
from pytools.log import IntervalTimer
self.field_solve_timer = IntervalTimer("t_field",
"Time spent in field solver")
class FieldRhsCalculator(object):
def __init__(self, method, maxwell_op):
self.method = method
self.maxwell_op = maxwell_op
self.bound_maxwell_op = maxwell_op.bind(self.method.discretization)
from pytools.log import IntervalTimer
self.field_solve_timer = IntervalTimer(
"t_field",
"Time spent in field solver")
def add_instrumentation(self, mgr):
mgr.add_quantity(self.field_solve_timer)
def __call__(self, t, fields_f, state_f):
# calculate EM right-hand side
sub_timer = self.field_solve_timer.start_sub_timer()
from pyrticle.hyperbolic import CleaningMaxwellOperator
if isinstance(self.maxwell_op, CleaningMaxwellOperator):
rhs_fields = self.bound_maxwell_op(t, fields_f(),
self.method.deposit_rho(state_f()))
else:
rhs_fields = self.bound_maxwell_op(t, fields_f())
sub_timer.stop().submit()
return rhs_fields
def add_instrumentation(self, mgr, observer):
mgr.set_constant("depositor", self.__class__.__name__)
for key, value in self.log_constants.iteritems():
mgr.set_constant(key, value)
from pytools.log import IntervalTimer, EventCounter,\
time_and_count_function
self.deposit_timer = IntervalTimer("t_deposit",
"Time spent depositing")
self.deposit_counter = EventCounter("n_deposit",
"Number of depositions")
self.deposit_densities = time_and_count_function(
self.deposit_densites, self.deposit_timer, self.deposit_counter,
1 + self.method.dimensions_velocity)
self.deposit_j = time_and_count_function(
self.deposit_j, self.deposit_timer, self.deposit_counter,
self.method.dimensions_velocity)
self.deposit_rho = time_and_count_function(self.deposit_rho,
self.deposit_timer,
self.deposit_counter)
mgr.add_quantity(self.deposit_timer)
mgr.add_quantity(self.deposit_counter)
class FieldRhsCalculator(object):
def __init__(self, method, maxwell_op):
self.method = method
self.maxwell_op = maxwell_op
self.bound_maxwell_op = maxwell_op.bind(self.method.discretization)
from pytools.log import IntervalTimer
self.field_solve_timer = IntervalTimer("t_field",
"Time spent in field solver")
def add_instrumentation(self, mgr):
mgr.add_quantity(self.field_solve_timer)
def __call__(self, t, fields_f, state_f):
# calculate EM right-hand side
sub_timer = self.field_solve_timer.start_sub_timer()
from pyrticle.hyperbolic import CleaningMaxwellOperator
if isinstance(self.maxwell_op, CleaningMaxwellOperator):
rhs_fields = self.bound_maxwell_op(
t, fields_f(), self.method.deposit_rho(state_f()))
else:
rhs_fields = self.bound_maxwell_op(t, fields_f())
sub_timer.stop().submit()
return rhs_fields
def add_instrumentation(self, mgr, observer):
Depositor.add_instrumentation(self, mgr, observer)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.element_activation_counter = EventCounter(
"n_el_activations",
"#Advective rec. elements activated this timestep")
self.element_kill_counter = EventCounter(
"n_el_kills",
"#Advective rec. elements retired this timestep")
self.advective_rhs_timer = IntervalTimer(
"t_advective_rhs",
"Time spent evaluating advective RHS")
self.active_elements_log = ActiveAdvectiveElements(observer)
mgr.add_quantity(self.element_activation_counter)
mgr.add_quantity(self.element_kill_counter)
mgr.add_quantity(self.advective_rhs_timer)
mgr.add_quantity(self.active_elements_log)
mgr.set_constant("el_activation_threshold", self.activation_threshold)
mgr.set_constant("el_kill_threshold", self.kill_threshold)
mgr.set_constant("adv_upwind_alpha", self.upwind_alpha)
mgr.set_constant("filter_amp", self.filter_amp)
mgr.set_constant("filter_amp", self.filter_order)
def __init__(self, method, maxwell_op):
self.method = method
self.maxwell_op = maxwell_op
self.bound_maxwell_op = maxwell_op.bind(self.method.discretization)
from pytools.log import IntervalTimer
self.field_solve_timer = IntervalTimer(
"t_field",
"Time spent in field solver")
def __init__(self,
discr,
units,
depositor,
pusher,
dimensions_pos,
dimensions_velocity,
debug=set()):
self.units = units
self.discretization = discr
self.debug = debug
self.depositor = depositor
self.pusher = pusher
self.dimensions_mesh = discr.dimensions
self.dimensions_pos = dimensions_pos
self.dimensions_velocity = dimensions_velocity
dims = (dimensions_pos, dimensions_velocity)
self.mesh_data = _internal.MeshData(discr.dimensions)
self.mesh_data.fill_from_hedge(discr)
# subsystem init
self.depositor.initialize(self)
self.pusher.initialize(self)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.find_el_timer = IntervalTimer("t_find",
"Time spent finding new elements")
self.find_same_counter = EventCounter(
"n_find_same", "#Particles found in same element")
self.find_by_neighbor_counter = EventCounter(
"n_find_neighbor", "#Particles found through neighbor")
self.find_by_vertex_counter = EventCounter(
"n_find_by_vertex", "#Particles found by vertex")
self.find_global_counter = EventCounter(
"n_find_global", "#Particles found by global search")
class Pusher(object):
def __init__(self):
from pytools.log import IntervalTimer, EventCounter
self.force_timer = IntervalTimer(
"t_force",
"Time spent calculating forces")
def initialize(self, method):
self.method = method
def make_state(self, state):
return EmptyPusherState()
def advance_state(self, state):
return state.pusher_state
def add_instrumentation(self, mgr, observer):
mgr.set_constant("pusher", self.__class__.__name__)
mgr.add_quantity(self.force_timer)
def upkeep(self, state):
pass
def _forces(self, state, velocities, *field_args):
return self.backend.forces(
ps=state.particle_state,
velocities=velocities,
vis_listener=state.vis_listener,
*field_args
)
def forces(self, state, velocities, *field_args):
sub_timer = self.force_timer.start_sub_timer()
forces = self._forces(state, velocities, *field_args)
sub_timer.stop().submit()
return forces
def note_move(self, state, orig, dest, size):
pass
def note_change_size(self, state, count):
pass
def __init__(self, discr, units,
depositor, pusher,
dimensions_pos, dimensions_velocity,
debug=set()):
self.units = units
self.discretization = discr
self.debug = debug
self.depositor = depositor
self.pusher = pusher
self.dimensions_mesh = discr.dimensions
self.dimensions_pos = dimensions_pos
self.dimensions_velocity = dimensions_velocity
dims = (dimensions_pos, dimensions_velocity)
self.mesh_data = _internal.MeshData(discr.dimensions)
self.mesh_data.fill_from_hedge(discr)
# subsystem init
self.depositor.initialize(self)
self.pusher.initialize(self)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.find_el_timer = IntervalTimer(
"t_find",
"Time spent finding new elements")
self.find_same_counter = EventCounter(
"n_find_same",
"#Particles found in same element")
self.find_by_neighbor_counter = EventCounter(
"n_find_neighbor",
"#Particles found through neighbor")
self.find_by_vertex_counter = EventCounter(
"n_find_by_vertex",
"#Particles found by vertex")
self.find_global_counter = EventCounter(
"n_find_global",
"#Particles found by global search")
def __init__(self):
from pytools.log import IntervalTimer, EventCounter
self.force_timer = IntervalTimer(
"t_force",
"Time spent calculating forces")
class PicMethod(object):
"""
@arg debug: A set of strings telling what to debug. So far, the
following debug flags are in use:
- depositor: Debug the depositor.
- verbose_vis: Generate E and B fields and force
visualizations at particle locations.
- ic: Check the initial condition when it's generated.
- no_ic: Start with zero fields.
- discretization: (See driver.py.) Turn on debug mode for the
discretization.
- shape_bw: Debug the finding of the optimal shape bandwidth.
- interactive: Allow debug measures that require user interaction.
- vis_files: Allow debug measures that write extra visualization
files.
"""
def __init__(self,
discr,
units,
depositor,
pusher,
dimensions_pos,
dimensions_velocity,
debug=set()):
self.units = units
self.discretization = discr
self.debug = debug
self.depositor = depositor
self.pusher = pusher
self.dimensions_mesh = discr.dimensions
self.dimensions_pos = dimensions_pos
self.dimensions_velocity = dimensions_velocity
dims = (dimensions_pos, dimensions_velocity)
self.mesh_data = _internal.MeshData(discr.dimensions)
self.mesh_data.fill_from_hedge(discr)
# subsystem init
self.depositor.initialize(self)
self.pusher.initialize(self)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.find_el_timer = IntervalTimer("t_find",
"Time spent finding new elements")
self.find_same_counter = EventCounter(
"n_find_same", "#Particles found in same element")
self.find_by_neighbor_counter = EventCounter(
"n_find_neighbor", "#Particles found through neighbor")
self.find_by_vertex_counter = EventCounter(
"n_find_by_vertex", "#Particles found by vertex")
self.find_global_counter = EventCounter(
"n_find_global", "#Particles found by global search")
def make_state(self):
state = PicState(self)
state.particle_number_shift_signaller.subscribe_with_state(
self.depositor)
state.particle_number_shift_signaller.subscribe_with_state(self.pusher)
return state
def get_dimensionality_suffix(self):
return "%dd%dv" % (self.dimensions_pos, self.dimensions_velocity)
def get_shape_function_class(self):
from pyrticle.tools import \
PolynomialShapeFunction, \
CInfinityShapeFunction
from pyrticle._internal import get_shape_function_name
name = get_shape_function_name()
if name == "c_infinity":
return CInfinityShapeFunction
elif name == "polynomial":
return PolynomialShapeFunction
else:
raise ValueError, "unknown shape function class"
def set_ignore_core_warnings(self, ignore):
from pyrticle.tools import WarningForwarder, WarningIgnorer
import pyrticle.tools
del pyrticle.tools.warning_forwarder
if ignore:
pyrticle.tools.warning_forwarder = WarningIgnorer()
else:
pyrticle.tools.warning_forwarder = WarningForwarder()
def add_instrumentation(self, mgr, observer):
mgr.add_quantity(self.find_el_timer)
mgr.add_quantity(self.find_same_counter)
mgr.add_quantity(self.find_by_neighbor_counter)
mgr.add_quantity(self.find_by_vertex_counter)
mgr.add_quantity(self.find_global_counter)
self.depositor.add_instrumentation(mgr, observer)
self.pusher.add_instrumentation(mgr, observer)
def velocities(self, state):
try:
return state.derived_quantity_cache["velocities"]
except KeyError:
result = _internal.get_velocities(state.particle_state,
self.units.VACUUM_LIGHT_SPEED())
state.derived_quantity_cache["velocities"] = result
return result
def mean_beta(self, state):
if len(state):
return numpy.average(self.velocities(state), axis=0) \
/ self.units.VACUUM_LIGHT_SPEED()
else:
return numpy.zeros((self.dimensions_velocity, ))
def add_particles(self, state, iterable, maxcount=None):
"""Add the particles from C{iterable} to the cloud.
C{iterable} is expected to yield tuples
C{(position, velocity, charge, mass)}.
If C{maxcount} is specified, maximally C{maxcount}
particles are obtained from the iterable.
"""
pstate = state.particle_state
if maxcount is not None:
if pstate.particle_count + maxcount >= len(
pstate.containing_elements):
state.resize(pstate.particle_count + maxcount)
for pos, vel, charge, mass in iterable:
if maxcount is not None:
if maxcount == 0:
break
maxcount -= 1
assert len(pos) == self.dimensions_pos
assert len(vel) == self.dimensions_velocity
pos = numpy.asarray(pos)
vel = numpy.asarray(vel)
mom = mass * self.units.gamma_from_v(vel) * vel
cont_el = self.mesh_data.find_containing_element(pos)
if cont_el == MeshData.INVALID_ELEMENT:
print "not in valid element"
continue
if pstate.particle_count >= len(pstate.containing_elements):
state.resize(max(128, 2 * pstate.particle_count))
pstate.containing_elements[pstate.particle_count] = cont_el
pstate.positions[pstate.particle_count] = pos
pstate.momenta[pstate.particle_count] = mom
pstate.charges[pstate.particle_count] = charge
pstate.masses[pstate.particle_count] = mass
pstate.particle_count += 1
self.check_containment(state)
state.particle_number_shift_signaller.note_change_size(
pstate.particle_count)
state.derived_quantity_cache.clear()
def check_containment(self, state):
"""Check that a containing element is known for each particle.
This is a new invariant as of 1/17/08, and violations of this end up
segfaulting, which we should avoid.
"""
assert (state.particle_state.containing_elements[:len(state)] !=
MeshData.INVALID_ELEMENT).all()
def upkeep(self, state):
"""Perform any operations must fall in between timesteps,
such as resampling or deleting particles.
"""
self.depositor.upkeep(state)
self.pusher.upkeep(state)
state.vis_listener.clear()
# deposition ----------------------------------------------------------
def deposit_densities(self, state):
"""Return a tuple (charge_density, current_densities), where
current_densities is an d-by-n array, where d is the number
of velocity dimensions, and n is the discretization nodes.
"""
def all_getter():
rho, j = self.depositor.deposit_densities(state, self.velocities())
j = numpy.asarray(j.T, order="C")
return rho, j
return state.get_derived_quantities_from_cache(
["rho", "j"], [self.deposit_rho, self.deposit_j], all_getter)
def deposit_j(self, state):
"""Return a the current densities as an d-by-n array, where d
is the number of velocity dimensions, and n is the number of
discretization nodes.
"""
def j_getter():
return numpy.asarray(self.depositor.deposit_j(
state, self.velocities(state)).T,
order="C")
return state.get_derived_quantity_from_cache("j", j_getter)
def deposit_rho(self, state):
"""Return a the charge_density as a volume vector."""
def rho_getter():
return self.depositor.deposit_rho(state)
return state.get_derived_quantity_from_cache("rho", rho_getter)
# time advance ------------------------------------------------------------
def advance_state(self, state, dx, dp, ddep):
pstate = state.particle_state
cnt = pstate.particle_count
positions = pstate.positions.copy()
momenta = pstate.momenta.copy()
positions[:cnt] += dx
momenta[:cnt] += dp
new_state = PicState(
self,
particle_count=cnt,
containing_elements=pstate.containing_elements,
positions=positions,
momenta=momenta,
charges=pstate.charges,
masses=pstate.masses,
depositor_state=self.depositor.advance_state(state, ddep),
pusher_state=self.pusher.advance_state(state),
pnss=state.particle_number_shift_signaller,
vis_listener=state.vis_listener,
)
from pyrticle._internal import FindEventCounters
find_counters = FindEventCounters()
class BHitListener(_internal.BoundaryHitListener):
def note_boundary_hit(subself, pn):
_internal.kill_particle(
new_state.particle_state, pn,
new_state.particle_number_shift_signaller)
from pyrticle._internal import update_containing_elements
sub_timer = self.find_el_timer.start_sub_timer()
update_containing_elements(self.mesh_data, new_state.particle_state,
BHitListener(), find_counters)
sub_timer.stop().submit()
self.find_same_counter.transfer(find_counters.find_same)
self.find_by_neighbor_counter.transfer(find_counters.find_by_neighbor)
self.find_by_vertex_counter.transfer(find_counters.find_by_vertex)
self.find_global_counter.transfer(find_counters.find_global)
return new_state
# visualization -----------------------------------------------------------
def get_mesh_vis_vars(self):
return self.vis_listener.mesh_vis_map.items()
def add_to_vis(self,
visualizer,
vis_file,
state,
time=None,
step=None,
beamaxis=None,
vis_listener=None):
from hedge.visualization import VtkVisualizer, SiloVisualizer
if isinstance(visualizer, VtkVisualizer):
return self._add_to_vtk(visualizer, vis_file, state, time, step)
elif isinstance(visualizer, SiloVisualizer):
return self._add_to_silo(visualizer, vis_file, state, time, step,
beamaxis, vis_listener)
else:
raise ValueError, "unknown visualizer type `%s'" % type(visualizer)
def _add_to_silo(self,
visualizer,
db,
state,
time,
step,
beamaxis,
vis_listener=None):
from pylo import DBOPT_DTIME, DBOPT_CYCLE
optlist = {}
if time is not None:
optlist[DBOPT_DTIME] = time
if step is not None:
optlist[DBOPT_CYCLE] = step
pcount = len(state)
if pcount:
# real-space ------------------------------------------------------
db.put_pointmesh("particles",
numpy.asarray(state.positions.T, order="C"),
optlist)
db.put_pointvar1("charge", "particles", state.charges)
db.put_pointvar1("mass", "particles", state.masses)
db.put_pointvar("momentum", "particles",
numpy.asarray(state.momenta.T, order="C"))
db.put_pointvar("velocity", "particles",
numpy.asarray(self.velocities(state).T, order="C"))
if vis_listener is not None:
for name, value in self.vis_listener.particle_vis_map.iteritems(
):
from pyrticle.tools import NumberShiftableVector
value = NumberShiftableVector.unwrap(value)
dim, remainder = divmod(len(value), pcount)
assert remainder == 0, (
"particle vis value '%s' had invalid number of entries: "
"%d (#particles=%d)" % (name, len(value), pcount))
if dim == 1:
db.put_pointvar1(name, "particles", value)
else:
db.put_pointvar(name, "particles",
[value[i::dim] for i in range(dim)])
# phase-space -----------------------------------------------------
axes_names = ["x", "y", "z"]
if beamaxis is not None:
for axis in range(
min(self.dimensions_pos, self.dimensions_velocity)):
if axis == beamaxis:
continue
axname = axes_names[axis]
db.put_defvars("phasespace_%s" % axname, [
("part_%s" % axname, "coord(particles)[%d]" % axis),
("part_%s_prime" % axname,
"momentum[%d]/momentum[%d]" % (axis, beamaxis)),
("part_%s_momentum" % axname, "momentum[%d]" % (axis)),
])
def main(write_output=True,
dir_tag=TAG_NONE,
neu_tag=TAG_NONE,
rad_tag=TAG_ALL,
flux_type_arg="upwind"):
from math import sin, cos, pi, exp, sqrt # noqa
from hedge.backends import guess_run_context
rcon = guess_run_context()
dim = 2
if dim == 1:
if rcon.is_head_rank:
from hedge.mesh.generator import make_uniform_1d_mesh
mesh = make_uniform_1d_mesh(-10, 10, 500)
elif dim == 2:
from hedge.mesh.generator import make_rect_mesh
if rcon.is_head_rank:
mesh = make_rect_mesh(a=(-1, -1), b=(1, 1), max_area=0.003)
elif dim == 3:
if rcon.is_head_rank:
from hedge.mesh.generator import make_ball_mesh
mesh = make_ball_mesh(max_volume=0.0005)
else:
raise RuntimeError("bad number of dimensions")
if rcon.is_head_rank:
print "%d elements" % len(mesh.elements)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
discr = rcon.make_discretization(mesh_data, order=4)
from hedge.timestep.runge_kutta import LSRK4TimeStepper
stepper = LSRK4TimeStepper()
from hedge.visualization import VtkVisualizer
if write_output:
vis = VtkVisualizer(discr, rcon, "fld")
source_center = np.array([0.7, 0.4])
source_width = 1 / 16
source_omega = 3
import hedge.optemplate as sym
sym_x = sym.nodes(2)
sym_source_center_dist = sym_x - source_center
from hedge.models.wave import VariableVelocityStrongWaveOperator
op = VariableVelocityStrongWaveOperator(
c=sym.If(sym.Comparison(np.dot(sym_x, sym_x), "<", 0.4**2), 1, 0.5),
dimensions=discr.dimensions,
source=sym.CFunction("sin")(source_omega * sym.ScalarParameter("t")) *
sym.CFunction("exp")(
-np.dot(sym_source_center_dist, sym_source_center_dist) /
source_width**2),
dirichlet_tag=dir_tag,
neumann_tag=neu_tag,
radiation_tag=rad_tag,
flux_type=flux_type_arg)
from hedge.tools import join_fields
fields = join_fields(
discr.volume_zeros(),
[discr.volume_zeros() for i in range(discr.dimensions)])
# {{{ diagnostics setup
from pytools.log import LogManager, \
add_general_quantities, \
add_simulation_quantities, \
add_run_info
if write_output:
log_file_name = "wave.dat"
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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
stepper.add_instrumentation(logmgr)
from hedge.log import LpNorm
u_getter = lambda: fields[0]
logmgr.add_quantity(LpNorm(u_getter, discr, 1, name="l1_u"))
logmgr.add_quantity(LpNorm(u_getter, discr, name="l2_u"))
logmgr.add_watches(["step.max", "t_sim.max", "l2_u", "t_step.max"])
# }}}
# {{{ timestep loop
rhs = op.bind(discr)
try:
from hedge.timestep.stability import \
approximate_rk4_relative_imag_stability_region
max_dt = (1 / discr.compile(op.max_eigenvalue_expr())() *
discr.dt_non_geometric_factor() *
discr.dt_geometric_factor() *
approximate_rk4_relative_imag_stability_region(stepper))
if flux_type_arg == "central":
max_dt *= 0.25
from hedge.timestep import times_and_steps
step_it = times_and_steps(final_time=3,
logmgr=logmgr,
max_dt_getter=lambda t: max_dt)
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
visf = vis.make_file("fld-%04d" % step)
vis.add_data(visf, [
("u", fields[0]),
("v", fields[1:]),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
assert discr.norm(fields) < 1
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
class AdvectiveDepositor(Depositor):
name = "Advective"
def __init__(self, activation_threshold=1e-5, kill_threshold=1e-3,
filter_amp=None, filter_order=None,
upwind_alpha=1,
):
Depositor.__init__(self)
self.activation_threshold = activation_threshold
self.kill_threshold = kill_threshold
self.upwind_alpha = upwind_alpha
self.shape_function = None
self.filter_amp = filter_amp
self.filter_order = filter_order
if filter_amp is not None:
from hedge.discretization import ExponentialFilterResponseFunction
self.filter_response = ExponentialFilterResponseFunction(
filter_amp, filter_order)
else:
self.filter_response = None
def initialize(self, method):
Depositor.initialize(self, method)
discr = method.discretization
eg, = discr.element_groups
fg, = discr.face_groups
ldis = eg.local_discretization
from hedge.mesh import TAG_ALL
bdry = discr.get_boundary(TAG_ALL)
bdry_fg, = bdry.face_groups
if self.filter_response:
from hedge.discretization import Filter
filter = Filter(discr, self.filter_response)
filter_mat, = filter.filter_matrices
else:
filter_mat = numpy.zeros((0,0))
backend_class = getattr(_internal, "AdvectiveDepositor"
+ method.get_dimensionality_suffix())
self.backend = backend_class(method.mesh_data,
len(ldis.face_indices()),
ldis.node_count(),
ldis.mass_matrix(),
ldis.inverse_mass_matrix(),
filter_mat,
ldis.face_mass_matrix(),
fg,
bdry_fg,
self.activation_threshold,
self.kill_threshold,
self.upwind_alpha)
for i, diffmat in enumerate(ldis.differentiation_matrices()):
self.backend.add_local_diff_matrix(i, diffmat)
def make_state(self, state):
state = self.backend.DepositorState()
from pyrticle.tools import NumberShiftMultiplexer
state.rho_dof_shift_listener = NumberShiftMultiplexer(
name="advective_rho_dofs")
eg, = self.method.discretization.element_groups
ldis = eg.local_discretization
#state.resize_rho(eg.local_discretization.node_count() * 1024)
return state
def add_instrumentation(self, mgr, observer):
Depositor.add_instrumentation(self, mgr, observer)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.element_activation_counter = EventCounter(
"n_el_activations",
"#Advective rec. elements activated this timestep")
self.element_kill_counter = EventCounter(
"n_el_kills",
"#Advective rec. elements retired this timestep")
self.advective_rhs_timer = IntervalTimer(
"t_advective_rhs",
"Time spent evaluating advective RHS")
self.active_elements_log = ActiveAdvectiveElements(observer)
mgr.add_quantity(self.element_activation_counter)
mgr.add_quantity(self.element_kill_counter)
mgr.add_quantity(self.advective_rhs_timer)
mgr.add_quantity(self.active_elements_log)
mgr.set_constant("el_activation_threshold", self.activation_threshold)
mgr.set_constant("el_kill_threshold", self.kill_threshold)
mgr.set_constant("adv_upwind_alpha", self.upwind_alpha)
mgr.set_constant("filter_amp", self.filter_amp)
mgr.set_constant("filter_amp", self.filter_order)
def set_shape_function(self, state, sf):
Depositor.set_shape_function(self, state, sf)
state.depositor_state.clear()
for pn in xrange(len(state)):
self.backend.add_advective_particle(
state.depositor_state,
state.particle_state,
sf, pn)
def note_move(self, state, orig, dest, size):
self.backend.note_move(state.depositor_state, orig, dest, size)
def note_change_size(self, state, new_size):
self.backend.note_change_size(state.depositor_state, new_size)
if (self.shape_function is not None
and new_size > state.depositor_state.count_advective_particles()):
for pn in range(
state.depositor_state.count_advective_particles(),
new_size):
self.backend.add_advective_particle(
state.depositor_state,
state.particle_state,
self.shape_function, pn)
def clear_particles(self):
Depositor.clear_particles(self)
self.cloud.pic_algorithm.clear_advective_particles()
def upkeep(self, state):
self.backend.perform_depositor_upkeep(
state.depositor_state,
state.particle_state)
def rhs(self, state):
from pyrticle.tools import NumberShiftableVector
sub_timer = self.advective_rhs_timer.start_sub_timer()
result = NumberShiftableVector(
self.backend.get_advective_particle_rhs(
state.depositor_state,
state.particle_state,
self.method.velocities(state)),
signaller=state.depositor_state.rho_dof_shift_listener
)
sub_timer.stop()
self.element_activation_counter.transfer(
state.depositor_state.element_activation_counter)
self.element_kill_counter.transfer(
state.depositor_state.element_kill_counter)
return result
def advance_state(self, state, rhs):
# depositor states tend to linger on for a bit--ours here are
# big, so they need to go.
from gc import collect
collect()
from pyrticle.tools import NumberShiftableVector
return self.backend.apply_advective_particle_rhs(
state.depositor_state,
state.particle_state,
NumberShiftableVector.unwrap(rhs),
state.depositor_state.rho_dof_shift_listener)
def main(write_output=True, allow_features=None):
from hedge.timestep import RK4TimeStepper
from hedge.mesh import make_ball_mesh, make_cylinder_mesh, make_box_mesh
from hedge.visualization import \
VtkVisualizer, \
SiloVisualizer, \
get_rank_partition
from math import sqrt, pi
from hedge.backends import guess_run_context
rcon = guess_run_context(allow_features)
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4*pi*1e-7 # N/A**2.
epsilon = 1*epsilon0
mu = 1*mu0
dims = 3
if rcon.is_head_rank:
if dims == 2:
from hedge.mesh import make_rect_mesh
mesh = make_rect_mesh(
a=(-10.5,-1.5),
b=(10.5,1.5),
max_area=0.1
)
elif dims == 3:
from hedge.mesh import make_box_mesh
mesh = make_box_mesh(
a=(-10.5,-1.5,-1.5),
b=(10.5,1.5,1.5),
max_volume=0.1)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
#for order in [1,2,3,4,5,6]:
discr = rcon.make_discretization(mesh_data, order=3)
if write_output:
vis = VtkVisualizer(discr, rcon, "dipole")
from analytic_solutions import DipoleFarField, SphericalFieldAdapter
from hedge.data import ITimeDependentGivenFunction
sph_dipole = DipoleFarField(
q=1, #C
d=1/39,
omega=2*pi*1e8,
epsilon=epsilon0,
mu=mu0,
)
cart_dipole = SphericalFieldAdapter(sph_dipole)
class PointDipoleSource(ITimeDependentGivenFunction):
def __init__(self):
from pyrticle.tools import CInfinityShapeFunction
sf = CInfinityShapeFunction(
0.1*sph_dipole.wavelength,
discr.dimensions)
self.num_sf = discr.interpolate_volume_function(
lambda x, el: sf(x))
self.vol_0 = discr.volume_zeros()
def volume_interpolant(self, t, discr):
from hedge.tools import make_obj_array
return make_obj_array([
self.vol_0,
self.vol_0,
sph_dipole.source_modulation(t)*self.num_sf
])
from hedge.mesh import TAG_ALL, TAG_NONE
if dims == 2:
from hedge.models.em import TMMaxwellOperator as MaxwellOperator
else:
from hedge.models.em import MaxwellOperator
op = MaxwellOperator(
epsilon, mu,
flux_type=1,
pec_tag=TAG_NONE,
absorb_tag=TAG_ALL,
current=PointDipoleSource(),
)
fields = op.assemble_eh(discr=discr)
if rcon.is_head_rank:
print "#elements=", len(mesh.elements)
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "dipole.dat"
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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from hedge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
from pytools.log import PushLogQuantity
relerr_e_q = PushLogQuantity("relerr_e", "1", "Relative error in masked E-field")
relerr_h_q = PushLogQuantity("relerr_h", "1", "Relative error in masked H-field")
logmgr.add_quantity(relerr_e_q)
logmgr.add_quantity(relerr_h_q)
logmgr.add_watches(["step.max", "t_sim.max",
("W_field", "W_el+W_mag"), "t_step.max",
"relerr_e", "relerr_h"])
if write_output:
point_timeseries = [
(open("b-x%d-vs-time.dat" % i, "w"),
open("b-x%d-vs-time-true.dat" % i, "w"),
discr.get_point_evaluator(numpy.array([i,0,0][:dims],
dtype=discr.default_scalar_type)))
for i in range(1,5)
]
# timestep loop -------------------------------------------------------
mask = discr.interpolate_volume_function(sph_dipole.far_field_mask)
def apply_mask(field):
from hedge.tools import log_shape
ls = log_shape(field)
result = discr.volume_empty(ls)
from pytools import indices_in_shape
for i in indices_in_shape(ls):
result[i] = mask * field[i]
return result
rhs = op.bind(discr)
t = 0
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=1e-8, logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(discr,
stepper=stepper, t=t, fields=fields))
for step, t, dt in step_it:
if write_output and step % 10 == 0:
sub_timer = vis_timer.start_sub_timer()
e, h = op.split_eh(fields)
sph_dipole.set_time(t)
true_e, true_h = op.split_eh(
discr.interpolate_volume_function(cart_dipole))
visf = vis.make_file("dipole-%04d" % step)
mask_e = apply_mask(e)
mask_h = apply_mask(h)
mask_true_e = apply_mask(true_e)
mask_true_h = apply_mask(true_h)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf,
[
("e", e),
("h", h),
("true_e", true_e),
("true_h", true_h),
("mask_e", mask_e),
("mask_h", mask_h),
("mask_true_e", mask_true_e),
("mask_true_h", mask_true_h)],
time=t, step=step)
visf.close()
sub_timer.stop().submit()
from hedge.tools import relative_error
relerr_e_q.push_value(
relative_error(
discr.norm(mask_e-mask_true_e),
discr.norm(mask_true_e)))
relerr_h_q.push_value(
relative_error(
discr.norm(mask_h-mask_true_h),
discr.norm(mask_true_h)))
if write_output:
for outf_num, outf_true, evaluator in point_timeseries:
for outf, ev_h in zip([outf_num, outf_true],
[h, true_h]):
outf.write("%g\t%g\n" % (t, op.mu*evaluator(ev_h[1])))
outf.flush()
fields = stepper(fields, t, dt, rhs)
finally:
if write_output:
vis.close()
logmgr.save()
discr.close()
class AdvectiveDepositor(Depositor):
name = "Advective"
def __init__(
self,
activation_threshold=1e-5,
kill_threshold=1e-3,
filter_amp=None,
filter_order=None,
upwind_alpha=1,
):
Depositor.__init__(self)
self.activation_threshold = activation_threshold
self.kill_threshold = kill_threshold
self.upwind_alpha = upwind_alpha
self.shape_function = None
self.filter_amp = filter_amp
self.filter_order = filter_order
if filter_amp is not None:
from hedge.discretization import ExponentialFilterResponseFunction
self.filter_response = ExponentialFilterResponseFunction(
filter_amp, filter_order)
else:
self.filter_response = None
def initialize(self, method):
Depositor.initialize(self, method)
discr = method.discretization
eg, = discr.element_groups
fg, = discr.face_groups
ldis = eg.local_discretization
from hedge.mesh import TAG_ALL
bdry = discr.get_boundary(TAG_ALL)
bdry_fg, = bdry.face_groups
if self.filter_response:
from hedge.discretization import Filter
filter = Filter(discr, self.filter_response)
filter_mat, = filter.filter_matrices
else:
filter_mat = numpy.zeros((0, 0))
backend_class = getattr(
_internal,
"AdvectiveDepositor" + method.get_dimensionality_suffix())
self.backend = backend_class(method.mesh_data,
len(ldis.face_indices()),
ldis.node_count(), ldis.mass_matrix(),
ldis.inverse_mass_matrix(), filter_mat,
ldis.face_mass_matrix(), fg, bdry_fg,
self.activation_threshold,
self.kill_threshold, self.upwind_alpha)
for i, diffmat in enumerate(ldis.differentiation_matrices()):
self.backend.add_local_diff_matrix(i, diffmat)
def make_state(self, state):
state = self.backend.DepositorState()
from pyrticle.tools import NumberShiftMultiplexer
state.rho_dof_shift_listener = NumberShiftMultiplexer(
name="advective_rho_dofs")
eg, = self.method.discretization.element_groups
ldis = eg.local_discretization
#state.resize_rho(eg.local_discretization.node_count() * 1024)
return state
def add_instrumentation(self, mgr, observer):
Depositor.add_instrumentation(self, mgr, observer)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.element_activation_counter = EventCounter(
"n_el_activations",
"#Advective rec. elements activated this timestep")
self.element_kill_counter = EventCounter(
"n_el_kills", "#Advective rec. elements retired this timestep")
self.advective_rhs_timer = IntervalTimer(
"t_advective_rhs", "Time spent evaluating advective RHS")
self.active_elements_log = ActiveAdvectiveElements(observer)
mgr.add_quantity(self.element_activation_counter)
mgr.add_quantity(self.element_kill_counter)
mgr.add_quantity(self.advective_rhs_timer)
mgr.add_quantity(self.active_elements_log)
mgr.set_constant("el_activation_threshold", self.activation_threshold)
mgr.set_constant("el_kill_threshold", self.kill_threshold)
mgr.set_constant("adv_upwind_alpha", self.upwind_alpha)
mgr.set_constant("filter_amp", self.filter_amp)
mgr.set_constant("filter_amp", self.filter_order)
def set_shape_function(self, state, sf):
Depositor.set_shape_function(self, state, sf)
state.depositor_state.clear()
for pn in xrange(len(state)):
self.backend.add_advective_particle(state.depositor_state,
state.particle_state, sf, pn)
def note_move(self, state, orig, dest, size):
self.backend.note_move(state.depositor_state, orig, dest, size)
def note_change_size(self, state, new_size):
self.backend.note_change_size(state.depositor_state, new_size)
if (self.shape_function is not None and
new_size > state.depositor_state.count_advective_particles()):
for pn in range(state.depositor_state.count_advective_particles(),
new_size):
self.backend.add_advective_particle(state.depositor_state,
state.particle_state,
self.shape_function, pn)
def clear_particles(self):
Depositor.clear_particles(self)
self.cloud.pic_algorithm.clear_advective_particles()
def upkeep(self, state):
self.backend.perform_depositor_upkeep(state.depositor_state,
state.particle_state)
def rhs(self, state):
from pyrticle.tools import NumberShiftableVector
sub_timer = self.advective_rhs_timer.start_sub_timer()
result = NumberShiftableVector(
self.backend.get_advective_particle_rhs(
state.depositor_state, state.particle_state,
self.method.velocities(state)),
signaller=state.depositor_state.rho_dof_shift_listener)
sub_timer.stop()
self.element_activation_counter.transfer(
state.depositor_state.element_activation_counter)
self.element_kill_counter.transfer(
state.depositor_state.element_kill_counter)
return result
def advance_state(self, state, rhs):
# depositor states tend to linger on for a bit--ours here are
# big, so they need to go.
from gc import collect
collect()
from pyrticle.tools import NumberShiftableVector
return self.backend.apply_advective_particle_rhs(
state.depositor_state, state.particle_state,
NumberShiftableVector.unwrap(rhs),
state.depositor_state.rho_dof_shift_listener)
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()
def main(write_output=True,
dir_tag=TAG_NONE,
neu_tag=TAG_NONE,
rad_tag=TAG_ALL,
flux_type_arg="upwind",
dtype=np.float64,
debug=[]):
from math import sin, cos, pi, exp, sqrt # noqa
from hedge.backends import guess_run_context
rcon = guess_run_context()
dim = 2
if dim == 1:
if rcon.is_head_rank:
from hedge.mesh.generator import make_uniform_1d_mesh
mesh = make_uniform_1d_mesh(-10, 10, 500)
elif dim == 2:
from hedge.mesh.generator import make_rect_mesh
if rcon.is_head_rank:
mesh = make_rect_mesh(a=(-0.5, -0.5), b=(0.5, 0.5), max_area=0.008)
elif dim == 3:
if rcon.is_head_rank:
from hedge.mesh.generator import make_ball_mesh
mesh = make_ball_mesh(max_volume=0.0005)
else:
raise RuntimeError("bad number of dimensions")
if rcon.is_head_rank:
print "%d elements" % len(mesh.elements)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
from hedge.timestep.runge_kutta import LSRK4TimeStepper
stepper = LSRK4TimeStepper(dtype=dtype)
from hedge.models.wave import StrongWaveOperator
from hedge.mesh import TAG_ALL, TAG_NONE # noqa
source_center = np.array([0.1, 0.22])
source_width = 0.05
source_omega = 3
import hedge.optemplate as sym
sym_x = sym.nodes(2)
sym_source_center_dist = sym_x - source_center
op = StrongWaveOperator(
-1,
dim,
source_f=sym.CFunction("sin")(
source_omega * sym.ScalarParameter("t")) * sym.CFunction("exp")(
-np.dot(sym_source_center_dist, sym_source_center_dist) /
source_width**2),
dirichlet_tag=dir_tag,
neumann_tag=neu_tag,
radiation_tag=rad_tag,
flux_type=flux_type_arg)
discr = rcon.make_discretization(mesh_data,
order=4,
debug=debug,
default_scalar_type=dtype,
tune_for=op.op_template())
from hedge.visualization import VtkVisualizer
if write_output:
vis = VtkVisualizer(discr, rcon, "fld")
from hedge.tools import join_fields
fields = join_fields(
discr.volume_zeros(dtype=dtype),
[discr.volume_zeros(dtype=dtype) for i in range(discr.dimensions)])
# {{{ diagnostics setup
from pytools.log import LogManager, \
add_general_quantities, \
add_simulation_quantities, \
add_run_info
if write_output:
log_file_name = "wave.dat"
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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
stepper.add_instrumentation(logmgr)
from hedge.log import LpNorm
u_getter = lambda: fields[0]
logmgr.add_quantity(LpNorm(u_getter, discr, 1, name="l1_u"))
logmgr.add_quantity(LpNorm(u_getter, discr, name="l2_u"))
logmgr.add_watches(["step.max", "t_sim.max", "l2_u", "t_step.max"])
# }}}
# {{{ timestep loop
rhs = op.bind(discr)
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=4,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, fields=fields))
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
visf = vis.make_file("fld-%04d" % step)
vis.add_data(visf, [
("u", discr.convert_volume(fields[0], kind="numpy")),
("v", discr.convert_volume(fields[1:], kind="numpy")),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
assert discr.norm(fields) < 1
assert fields[0].dtype == dtype
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
def mpi_communication_entrypoint():
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from mpi4py import MPI
comm = MPI.COMM_WORLD
i_local_rank = comm.Get_rank()
num_parts = comm.Get_size()
from meshmode.distributed import MPIMeshDistributor, get_partition_by_pymetis
mesh_dist = MPIMeshDistributor(comm)
dim = 2
dt = 0.04
order = 4
if mesh_dist.is_mananger_rank():
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
n=(16, ) * dim)
part_per_element = get_partition_by_pymetis(mesh, num_parts)
local_mesh = mesh_dist.send_mesh_parts(mesh, part_per_element,
num_parts)
else:
local_mesh = mesh_dist.receive_mesh_part()
vol_discr = DGDiscretizationWithBoundaries(cl_ctx,
local_mesh,
order=order,
mpi_communicator=comm)
source_center = np.array([0.1, 0.22, 0.33])[:local_mesh.dim]
source_width = 0.05
source_omega = 3
sym_x = sym.nodes(local_mesh.dim)
sym_source_center_dist = sym_x - source_center
sym_t = sym.ScalarVariable("t")
from grudge.models.wave import StrongWaveOperator
from meshmode.mesh import BTAG_ALL, BTAG_NONE
op = StrongWaveOperator(
-0.1,
vol_discr.dim,
source_f=(
sym.sin(source_omega * sym_t) *
sym.exp(-np.dot(sym_source_center_dist, sym_source_center_dist) /
source_width**2)),
dirichlet_tag=BTAG_NONE,
neumann_tag=BTAG_NONE,
radiation_tag=BTAG_ALL,
flux_type="upwind")
from pytools.obj_array import join_fields
fields = join_fields(
vol_discr.zeros(queue),
[vol_discr.zeros(queue) for i in range(vol_discr.dim)])
# FIXME
# dt = op.estimate_rk4_timestep(vol_discr, fields=fields)
# FIXME: Should meshmode consider BTAG_PARTITION to be a boundary?
# Fails because: "found faces without boundary conditions"
# op.check_bc_coverage(local_mesh)
from pytools.log import LogManager, \
add_general_quantities, \
add_run_info, \
IntervalTimer, EventCounter
log_filename = None
# NOTE: LogManager hangs when using a file on a shared directory.
# log_filename = 'grudge_log.dat'
logmgr = LogManager(log_filename, "w", comm)
add_run_info(logmgr)
add_general_quantities(logmgr)
log_quantities =\
{"rank_data_swap_timer": IntervalTimer("rank_data_swap_timer",
"Time spent evaluating RankDataSwapAssign"),
"rank_data_swap_counter": EventCounter("rank_data_swap_counter",
"Number of RankDataSwapAssign instructions evaluated"),
"exec_timer": IntervalTimer("exec_timer",
"Total time spent executing instructions"),
"insn_eval_timer": IntervalTimer("insn_eval_timer",
"Time spend evaluating instructions"),
"future_eval_timer": IntervalTimer("future_eval_timer",
"Time spent evaluating futures"),
"busy_wait_timer": IntervalTimer("busy_wait_timer",
"Time wasted doing busy wait")}
for quantity in log_quantities.values():
logmgr.add_quantity(quantity)
# print(sym.pretty(op.sym_operator()))
bound_op = bind(vol_discr, op.sym_operator())
# print(bound_op)
# 1/0
def rhs(t, w):
val, rhs.profile_data = bound_op(queue,
profile_data=rhs.profile_data,
log_quantities=log_quantities,
t=t,
w=w)
return val
rhs.profile_data = {}
dt_stepper = set_up_rk4("w", dt, fields, rhs)
final_t = 4
nsteps = int(final_t / dt)
print("rank=%d dt=%g nsteps=%d" % (i_local_rank, dt, nsteps))
# from grudge.shortcuts import make_visualizer
# vis = make_visualizer(vol_discr, vis_order=order)
step = 0
norm = bind(vol_discr, sym.norm(2, sym.var("u")))
from time import time
t_last_step = time()
logmgr.tick_before()
for event in dt_stepper.run(t_end=final_t):
if isinstance(event, dt_stepper.StateComputed):
assert event.component_id == "w"
step += 1
print(step, event.t, norm(queue, u=event.state_component[0]),
time() - t_last_step)
# if step % 10 == 0:
# vis.write_vtk_file("rank%d-fld-%04d.vtu" % (i_local_rank, step),
# [("u", event.state_component[0]),
# ("v", event.state_component[1:])])
t_last_step = time()
logmgr.tick_after()
logmgr.tick_before()
logmgr.tick_after()
def print_profile_data(data):
print("""execute() for rank %d:
\tInstruction Evaluation: %f%%
\tFuture Evaluation: %f%%
\tBusy Wait: %f%%
\tTotal: %f seconds""" %
(i_local_rank, data['insn_eval_time'] / data['total_time'] * 100,
data['future_eval_time'] / data['total_time'] * 100,
data['busy_wait_time'] / data['total_time'] * 100,
data['total_time']))
print_profile_data(rhs.profile_data)
logmgr.close()
logger.debug("Rank %d exiting", i_local_rank)
def main(write_output=True):
from math import sqrt, pi, exp
from os.path import join
from grudge.backends import guess_run_context
rcon = guess_run_context()
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
output_dir = "maxwell-2d"
import os
if not os.access(output_dir, os.F_OK):
os.makedirs(output_dir)
from grudge.mesh.generator import make_disk_mesh
mesh = make_disk_mesh(r=0.5, max_area=1e-3)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
class CurrentSource:
shape = (3, )
def __call__(self, x, el):
return [0, 0, exp(-80 * la.norm(x))]
order = 3
final_time = 1e-8
discr = rcon.make_discretization(mesh_data,
order=order,
debug=["cuda_no_plan"])
from grudge.visualization import VtkVisualizer
if write_output:
vis = VtkVisualizer(discr, rcon, join(output_dir, "em-%d" % order))
if rcon.is_head_rank:
print("order %d" % order)
print("#elements=", len(mesh.elements))
from grudge.mesh import BTAG_ALL, BTAG_NONE
from grudge.models.em import TMMaxwellOperator
from grudge.data import make_tdep_given, TimeIntervalGivenFunction
op = TMMaxwellOperator(epsilon,
mu,
flux_type=1,
current=TimeIntervalGivenFunction(
make_tdep_given(CurrentSource()),
off_time=final_time / 10),
absorb_tag=BTAG_ALL,
pec_tag=BTAG_NONE)
fields = op.assemble_eh(discr=discr)
from grudge.timestep import LSRK4TimeStepper
stepper = LSRK4TimeStepper()
from time import time
last_tstep = time()
t = 0
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = join(output_dir, "maxwell-%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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from grudge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
logmgr.add_watches(
["step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max"])
# timestep loop -------------------------------------------------------
rhs = op.bind(discr)
try:
from grudge.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, fields=fields))
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
e, h = op.split_eh(fields)
visf = vis.make_file(
join(output_dir, "em-%d-%04d" % (order, step)))
vis.add_data(visf, [
("e", discr.convert_volume(e, "numpy")),
("h", discr.convert_volume(h, "numpy")),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
assert discr.norm(fields) < 0.03
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
def make_timer(self, name, description=None):
from pytools.log import IntervalTimer
return IntervalTimer(name, description)
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)
class PicMethod(object):
"""
@arg debug: A set of strings telling what to debug. So far, the
following debug flags are in use:
- depositor: Debug the depositor.
- verbose_vis: Generate E and B fields and force
visualizations at particle locations.
- ic: Check the initial condition when it's generated.
- no_ic: Start with zero fields.
- discretization: (See driver.py.) Turn on debug mode for the
discretization.
- shape_bw: Debug the finding of the optimal shape bandwidth.
- interactive: Allow debug measures that require user interaction.
- vis_files: Allow debug measures that write extra visualization
files.
"""
def __init__(self, discr, units,
depositor, pusher,
dimensions_pos, dimensions_velocity,
debug=set()):
self.units = units
self.discretization = discr
self.debug = debug
self.depositor = depositor
self.pusher = pusher
self.dimensions_mesh = discr.dimensions
self.dimensions_pos = dimensions_pos
self.dimensions_velocity = dimensions_velocity
dims = (dimensions_pos, dimensions_velocity)
self.mesh_data = _internal.MeshData(discr.dimensions)
self.mesh_data.fill_from_hedge(discr)
# subsystem init
self.depositor.initialize(self)
self.pusher.initialize(self)
# instrumentation
from pytools.log import IntervalTimer, EventCounter
self.find_el_timer = IntervalTimer(
"t_find",
"Time spent finding new elements")
self.find_same_counter = EventCounter(
"n_find_same",
"#Particles found in same element")
self.find_by_neighbor_counter = EventCounter(
"n_find_neighbor",
"#Particles found through neighbor")
self.find_by_vertex_counter = EventCounter(
"n_find_by_vertex",
"#Particles found by vertex")
self.find_global_counter = EventCounter(
"n_find_global",
"#Particles found by global search")
def make_state(self):
state = PicState(self)
state.particle_number_shift_signaller.subscribe_with_state(self.depositor)
state.particle_number_shift_signaller.subscribe_with_state(self.pusher)
return state
def get_dimensionality_suffix(self):
return "%dd%dv" % (self.dimensions_pos, self.dimensions_velocity)
def get_shape_function_class(self):
from pyrticle.tools import \
PolynomialShapeFunction, \
CInfinityShapeFunction
from pyrticle._internal import get_shape_function_name
name = get_shape_function_name()
if name == "c_infinity":
return CInfinityShapeFunction
elif name == "polynomial":
return PolynomialShapeFunction
else:
raise ValueError, "unknown shape function class"
def set_ignore_core_warnings(self, ignore):
from pyrticle.tools import WarningForwarder, WarningIgnorer
import pyrticle.tools
del pyrticle.tools.warning_forwarder
if ignore:
pyrticle.tools.warning_forwarder = WarningIgnorer()
else:
pyrticle.tools.warning_forwarder = WarningForwarder()
def add_instrumentation(self, mgr, observer):
mgr.add_quantity(self.find_el_timer)
mgr.add_quantity(self.find_same_counter)
mgr.add_quantity(self.find_by_neighbor_counter)
mgr.add_quantity(self.find_by_vertex_counter)
mgr.add_quantity(self.find_global_counter)
self.depositor.add_instrumentation(mgr, observer)
self.pusher.add_instrumentation(mgr, observer)
def velocities(self, state):
try:
return state.derived_quantity_cache["velocities"]
except KeyError:
result = _internal.get_velocities(
state.particle_state, self.units.VACUUM_LIGHT_SPEED())
state.derived_quantity_cache["velocities"] = result
return result
def mean_beta(self, state):
if len(state):
return numpy.average(self.velocities(state), axis=0) \
/ self.units.VACUUM_LIGHT_SPEED()
else:
return numpy.zeros((self.dimensions_velocity,))
def add_particles(self, state, iterable, maxcount=None):
"""Add the particles from C{iterable} to the cloud.
C{iterable} is expected to yield tuples
C{(position, velocity, charge, mass)}.
If C{maxcount} is specified, maximally C{maxcount}
particles are obtained from the iterable.
"""
pstate = state.particle_state
if maxcount is not None:
if pstate.particle_count+maxcount >= len(pstate.containing_elements):
state.resize(pstate.particle_count+maxcount)
for pos, vel, charge, mass in iterable:
if maxcount is not None:
if maxcount == 0:
break
maxcount -= 1
assert len(pos) == self.dimensions_pos
assert len(vel) == self.dimensions_velocity
pos = numpy.asarray(pos)
vel = numpy.asarray(vel)
mom = mass*self.units.gamma_from_v(vel)*vel
cont_el = self.mesh_data.find_containing_element(pos)
if cont_el == MeshData.INVALID_ELEMENT:
print "not in valid element"
continue
if pstate.particle_count >= len(pstate.containing_elements):
state.resize(max(128, 2*pstate.particle_count))
pstate.containing_elements[pstate.particle_count] = cont_el
pstate.positions[pstate.particle_count] = pos
pstate.momenta[pstate.particle_count] = mom
pstate.charges[pstate.particle_count] = charge
pstate.masses[pstate.particle_count] = mass
pstate.particle_count += 1
self.check_containment(state)
state.particle_number_shift_signaller.note_change_size(
pstate.particle_count)
state.derived_quantity_cache.clear()
def check_containment(self, state):
"""Check that a containing element is known for each particle.
This is a new invariant as of 1/17/08, and violations of this end up
segfaulting, which we should avoid.
"""
assert (state.particle_state.containing_elements[:len(state)]
!= MeshData.INVALID_ELEMENT).all()
def upkeep(self, state):
"""Perform any operations must fall in between timesteps,
such as resampling or deleting particles.
"""
self.depositor.upkeep(state)
self.pusher.upkeep(state)
state.vis_listener.clear()
# deposition ----------------------------------------------------------
def deposit_densities(self, state):
"""Return a tuple (charge_density, current_densities), where
current_densities is an d-by-n array, where d is the number
of velocity dimensions, and n is the discretization nodes.
"""
def all_getter():
rho, j = self.depositor.deposit_densities(state, self.velocities())
j = numpy.asarray(j.T, order="C")
return rho, j
return state.get_derived_quantities_from_cache(
["rho", "j"],
[self.deposit_rho, self.deposit_j],
all_getter)
def deposit_j(self, state):
"""Return a the current densities as an d-by-n array, where d
is the number of velocity dimensions, and n is the number of
discretization nodes.
"""
def j_getter():
return numpy.asarray(
self.depositor.deposit_j(
state, self.velocities(state))
.T, order="C")
return state.get_derived_quantity_from_cache("j", j_getter)
def deposit_rho(self, state):
"""Return a the charge_density as a volume vector."""
def rho_getter():
return self.depositor.deposit_rho(state)
return state.get_derived_quantity_from_cache("rho", rho_getter)
# time advance ------------------------------------------------------------
def advance_state(self, state, dx, dp, ddep):
pstate = state.particle_state
cnt = pstate.particle_count
positions = pstate.positions.copy()
momenta = pstate.momenta.copy()
positions[:cnt] += dx
momenta[:cnt] += dp
new_state = PicState(
self,
particle_count=cnt,
containing_elements=pstate.containing_elements,
positions=positions,
momenta=momenta,
charges=pstate.charges,
masses=pstate.masses,
depositor_state=self.depositor.advance_state(
state, ddep),
pusher_state=self.pusher.advance_state(state),
pnss=state.particle_number_shift_signaller,
vis_listener=state.vis_listener,
)
from pyrticle._internal import FindEventCounters
find_counters = FindEventCounters()
class BHitListener(_internal.BoundaryHitListener):
def note_boundary_hit(subself, pn):
_internal.kill_particle(
new_state.particle_state,
pn, new_state.particle_number_shift_signaller)
from pyrticle._internal import update_containing_elements
sub_timer = self.find_el_timer.start_sub_timer()
update_containing_elements(
self.mesh_data, new_state.particle_state,
BHitListener(), find_counters)
sub_timer.stop().submit()
self.find_same_counter.transfer(
find_counters.find_same)
self.find_by_neighbor_counter.transfer(
find_counters.find_by_neighbor)
self.find_by_vertex_counter.transfer(
find_counters.find_by_vertex)
self.find_global_counter.transfer(
find_counters.find_global)
return new_state
# visualization -----------------------------------------------------------
def get_mesh_vis_vars(self):
return self.vis_listener.mesh_vis_map.items()
def add_to_vis(self, visualizer, vis_file, state, time=None, step=None, beamaxis=None,
vis_listener=None):
from hedge.visualization import VtkVisualizer, SiloVisualizer
if isinstance(visualizer, VtkVisualizer):
return self._add_to_vtk(visualizer, vis_file, state, time, step)
elif isinstance(visualizer, SiloVisualizer):
return self._add_to_silo(visualizer, vis_file, state, time, step, beamaxis, vis_listener)
else:
raise ValueError, "unknown visualizer type `%s'" % type(visualizer)
def _add_to_silo(self, visualizer, db, state, time, step, beamaxis, vis_listener=None):
from pylo import DBOPT_DTIME, DBOPT_CYCLE
optlist = {}
if time is not None:
optlist[DBOPT_DTIME] = time
if step is not None:
optlist[DBOPT_CYCLE] = step
pcount = len(state)
if pcount:
# real-space ------------------------------------------------------
db.put_pointmesh("particles",
numpy.asarray(state.positions.T, order="C"), optlist)
db.put_pointvar1("charge", "particles", state.charges)
db.put_pointvar1("mass", "particles", state.masses)
db.put_pointvar("momentum", "particles",
numpy.asarray(state.momenta.T, order="C"))
db.put_pointvar("velocity", "particles",
numpy.asarray(self.velocities(state).T, order="C"))
if vis_listener is not None:
for name, value in self.vis_listener.particle_vis_map.iteritems():
from pyrticle.tools import NumberShiftableVector
value = NumberShiftableVector.unwrap(value)
dim, remainder = divmod(len(value), pcount)
assert remainder == 0, (
"particle vis value '%s' had invalid number of entries: "
"%d (#particles=%d)" % (name, len(value), pcount))
if dim == 1:
db.put_pointvar1(name, "particles", value)
else:
db.put_pointvar(name, "particles", [value[i::dim] for i in range(dim)])
# phase-space -----------------------------------------------------
axes_names = ["x", "y", "z"]
if beamaxis is not None:
for axis in range(min(self.dimensions_pos, self.dimensions_velocity)):
if axis == beamaxis:
continue
axname = axes_names[axis]
db.put_defvars("phasespace_%s" % axname,
[
("part_%s" % axname, "coord(particles)[%d]" % axis),
("part_%s_prime" % axname,
"momentum[%d]/momentum[%d]" % (axis, beamaxis)),
("part_%s_momentum" % axname,
"momentum[%d]" % (axis)),
])
def main(write_output=True, allow_features=None, flux_type_arg=1, bdry_flux_type_arg=None, extra_discr_args={}):
from hedge.mesh.generator import make_cylinder_mesh, make_box_mesh
from hedge.tools import EOCRecorder, to_obj_array
from math import sqrt, pi
from analytic_solutions import (
check_time_harmonic_solution,
RealPartAdapter,
SplitComplexAdapter,
CylindricalFieldAdapter,
CylindricalCavityMode,
RectangularWaveguideMode,
RectangularCavityMode,
)
from hedge.models.em import MaxwellOperator
from hedge.backends import guess_run_context
rcon = guess_run_context(allow_features)
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
eoc_rec = EOCRecorder()
cylindrical = False
periodic = False
if cylindrical:
R = 1
d = 2
mode = CylindricalCavityMode(m=1, n=1, p=1, radius=R, height=d, epsilon=epsilon, mu=mu)
r_sol = CylindricalFieldAdapter(RealPartAdapter(mode))
c_sol = SplitComplexAdapter(CylindricalFieldAdapter(mode))
if rcon.is_head_rank:
mesh = make_cylinder_mesh(radius=R, height=d, max_volume=0.01)
else:
if periodic:
mode = RectangularWaveguideMode(epsilon, mu, (3, 2, 1))
periodicity = (False, False, True)
else:
periodicity = None
mode = RectangularCavityMode(epsilon, mu, (1, 2, 2))
if rcon.is_head_rank:
mesh = make_box_mesh(max_volume=0.001, periodicity=periodicity)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [4, 5, 6]:
# for order in [1,2,3,4,5,6]:
extra_discr_args.setdefault("debug", []).extend(["cuda_no_plan", "cuda_dump_kernels"])
op = MaxwellOperator(epsilon, mu, flux_type=flux_type_arg, bdry_flux_type=bdry_flux_type_arg)
discr = rcon.make_discretization(mesh_data, order=order, tune_for=op.op_template(), **extra_discr_args)
from hedge.visualization import VtkVisualizer
if write_output:
vis = VtkVisualizer(discr, rcon, "em-%d" % order)
mode.set_time(0)
def get_true_field():
return discr.convert_volume(
to_obj_array(mode(discr).real.astype(discr.default_scalar_type).copy()), kind=discr.compute_kind
)
fields = get_true_field()
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep.runge_kutta import LSRK4TimeStepper
stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type, rcon=rcon)
# from hedge.timestep.dumka3 import Dumka3TimeStepper
# stepper = Dumka3TimeStepper(3, dtype=discr.default_scalar_type, rcon=rcon)
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, add_simulation_quantities, add_run_info
if write_output:
log_file_name = "maxwell-%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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from hedge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
logmgr.add_watches(["step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max"])
# timestep loop -------------------------------------------------------
rhs = op.bind(discr)
final_time = 0.5e-9
try:
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, fields=fields),
)
for step, t, dt in step_it:
if step % 50 == 0 and write_output:
sub_timer = vis_timer.start_sub_timer()
e, h = op.split_eh(fields)
visf = vis.make_file("em-%d-%04d" % (order, step))
vis.add_data(
visf,
[("e", discr.convert_volume(e, kind="numpy")), ("h", discr.convert_volume(h, kind="numpy"))],
time=t,
step=step,
)
visf.close()
sub_timer.stop().submit()
fields = stepper(fields, t, dt, rhs)
mode.set_time(final_time)
eoc_rec.add_data_point(order, discr.norm(fields - get_true_field()))
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
if rcon.is_head_rank:
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
assert eoc_rec.estimate_order_of_convergence()[0, 1] > 6
def simple_wave_entrypoint(dim=2,
num_elems=256,
order=4,
num_steps=30,
log_filename="grudge.dat"):
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
from mpi4py import MPI
comm = MPI.COMM_WORLD
num_parts = comm.Get_size()
n = int(num_elems**(1. / dim))
from meshmode.distributed import MPIMeshDistributor
mesh_dist = MPIMeshDistributor(comm)
if mesh_dist.is_mananger_rank():
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
n=(n, ) * dim)
from pymetis import part_graph
_, p = part_graph(num_parts,
xadj=mesh.nodal_adjacency.neighbors_starts.tolist(),
adjncy=mesh.nodal_adjacency.neighbors.tolist())
part_per_element = np.array(p)
local_mesh = mesh_dist.send_mesh_parts(mesh, part_per_element,
num_parts)
else:
local_mesh = mesh_dist.receive_mesh_part()
vol_discr = DGDiscretizationWithBoundaries(cl_ctx,
local_mesh,
order=order,
mpi_communicator=comm)
source_center = np.array([0.1, 0.22, 0.33])[:local_mesh.dim]
source_width = 0.05
source_omega = 3
sym_x = sym.nodes(local_mesh.dim)
sym_source_center_dist = sym_x - source_center
sym_t = sym.ScalarVariable("t")
from grudge.models.wave import StrongWaveOperator
from meshmode.mesh import BTAG_ALL, BTAG_NONE
op = StrongWaveOperator(
-0.1,
vol_discr.dim,
source_f=(
sym.sin(source_omega * sym_t) *
sym.exp(-np.dot(sym_source_center_dist, sym_source_center_dist) /
source_width**2)),
dirichlet_tag=BTAG_NONE,
neumann_tag=BTAG_NONE,
radiation_tag=BTAG_ALL,
flux_type="upwind")
from pytools.obj_array import join_fields
fields = join_fields(
vol_discr.zeros(queue),
[vol_discr.zeros(queue) for i in range(vol_discr.dim)])
from pytools.log import LogManager, \
add_general_quantities, \
add_run_info, \
IntervalTimer, EventCounter
# NOTE: LogManager hangs when using a file on a shared directory.
logmgr = LogManager(log_filename, "w", comm)
add_run_info(logmgr)
add_general_quantities(logmgr)
log_quantities =\
{"rank_data_swap_timer": IntervalTimer("rank_data_swap_timer",
"Time spent evaluating RankDataSwapAssign"),
"rank_data_swap_counter": EventCounter("rank_data_swap_counter",
"Number of RankDataSwapAssign instructions evaluated"),
"exec_timer": IntervalTimer("exec_timer",
"Total time spent executing instructions"),
"insn_eval_timer": IntervalTimer("insn_eval_timer",
"Time spend evaluating instructions"),
"future_eval_timer": IntervalTimer("future_eval_timer",
"Time spent evaluating futures"),
"busy_wait_timer": IntervalTimer("busy_wait_timer",
"Time wasted doing busy wait")}
for quantity in log_quantities.values():
logmgr.add_quantity(quantity)
bound_op = bind(vol_discr, op.sym_operator())
def rhs(t, w):
val, rhs.profile_data = bound_op(queue,
profile_data=rhs.profile_data,
log_quantities=log_quantities,
t=t,
w=w)
return val
rhs.profile_data = {}
dt = 0.04
dt_stepper = set_up_rk4("w", dt, fields, rhs)
logmgr.tick_before()
for event in dt_stepper.run(t_end=dt * num_steps):
if isinstance(event, dt_stepper.StateComputed):
logmgr.tick_after()
logmgr.tick_before()
logmgr.tick_after()
def print_profile_data(data):
print("""execute() for rank %d:
\tInstruction Evaluation: %f%%
\tFuture Evaluation: %f%%
\tBusy Wait: %f%%
\tTotal: %f seconds""" %
(comm.Get_rank(), data['insn_eval_time'] / data['total_time'] *
100, data['future_eval_time'] / data['total_time'] * 100,
data['busy_wait_time'] / data['total_time'] * 100,
data['total_time']))
print_profile_data(rhs.profile_data)
logmgr.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()
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 main(write_output=True, allow_features=None):
from grudge.timestep import RK4TimeStepper
from grudge.mesh import make_ball_mesh, make_cylinder_mesh, make_box_mesh
from grudge.visualization import \
VtkVisualizer, \
SiloVisualizer, \
get_rank_partition
from math import sqrt, pi
from grudge.backends import guess_run_context
rcon = guess_run_context(allow_features)
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
dims = 3
if rcon.is_head_rank:
if dims == 2:
from grudge.mesh import make_rect_mesh
mesh = make_rect_mesh(a=(-10.5, -1.5), b=(10.5, 1.5), max_area=0.1)
elif dims == 3:
from grudge.mesh import make_box_mesh
mesh = make_box_mesh(a=(-10.5, -1.5, -1.5),
b=(10.5, 1.5, 1.5),
max_volume=0.1)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
#for order in [1,2,3,4,5,6]:
discr = rcon.make_discretization(mesh_data, order=3)
if write_output:
vis = VtkVisualizer(discr, rcon, "dipole")
from analytic_solutions import DipoleFarField, SphericalFieldAdapter
from grudge.data import ITimeDependentGivenFunction
sph_dipole = DipoleFarField(
q=1, #C
d=1 / 39,
omega=2 * pi * 1e8,
epsilon=epsilon0,
mu=mu0,
)
cart_dipole = SphericalFieldAdapter(sph_dipole)
class PointDipoleSource(ITimeDependentGivenFunction):
def __init__(self):
from pyrticle.tools import CInfinityShapeFunction
sf = CInfinityShapeFunction(0.1 * sph_dipole.wavelength,
discr.dimensions)
self.num_sf = discr.interpolate_volume_function(
lambda x, el: sf(x))
self.vol_0 = discr.volume_zeros()
def volume_interpolant(self, t, discr):
from grudge.tools import make_obj_array
return make_obj_array([
self.vol_0, self.vol_0,
sph_dipole.source_modulation(t) * self.num_sf
])
from grudge.mesh import BTAG_ALL, BTAG_NONE
if dims == 2:
from grudge.models.em import TMMaxwellOperator as MaxwellOperator
else:
from grudge.models.em import MaxwellOperator
op = MaxwellOperator(
epsilon,
mu,
flux_type=1,
pec_tag=BTAG_NONE,
absorb_tag=BTAG_ALL,
current=PointDipoleSource(),
)
fields = op.assemble_eh(discr=discr)
if rcon.is_head_rank:
print("#elements=", len(mesh.elements))
stepper = RK4TimeStepper()
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "dipole.dat"
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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from grudge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
from pytools.log import PushLogQuantity
relerr_e_q = PushLogQuantity("relerr_e", "1",
"Relative error in masked E-field")
relerr_h_q = PushLogQuantity("relerr_h", "1",
"Relative error in masked H-field")
logmgr.add_quantity(relerr_e_q)
logmgr.add_quantity(relerr_h_q)
logmgr.add_watches([
"step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max",
"relerr_e", "relerr_h"
])
if write_output:
point_timeseries = [(open("b-x%d-vs-time.dat" % i,
"w"), open("b-x%d-vs-time-true.dat" % i,
"w"),
discr.get_point_evaluator(
numpy.array([i, 0, 0][:dims],
dtype=discr.default_scalar_type)))
for i in range(1, 5)]
# timestep loop -------------------------------------------------------
mask = discr.interpolate_volume_function(sph_dipole.far_field_mask)
def apply_mask(field):
from grudge.tools import log_shape
ls = log_shape(field)
result = discr.volume_empty(ls)
from pytools import indices_in_shape
for i in indices_in_shape(ls):
result[i] = mask * field[i]
return result
rhs = op.bind(discr)
t = 0
try:
from grudge.timestep import times_and_steps
step_it = times_and_steps(
final_time=1e-8,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, fields=fields))
for step, t, dt in step_it:
if write_output and step % 10 == 0:
sub_timer = vis_timer.start_sub_timer()
e, h = op.split_eh(fields)
sph_dipole.set_time(t)
true_e, true_h = op.split_eh(
discr.interpolate_volume_function(cart_dipole))
visf = vis.make_file("dipole-%04d" % step)
mask_e = apply_mask(e)
mask_h = apply_mask(h)
mask_true_e = apply_mask(true_e)
mask_true_h = apply_mask(true_h)
from pyvisfile.silo import DB_VARTYPE_VECTOR
vis.add_data(visf, [("e", e), ("h", h), ("true_e", true_e),
("true_h", true_h), ("mask_e", mask_e),
("mask_h", mask_h),
("mask_true_e", mask_true_e),
("mask_true_h", mask_true_h)],
time=t,
step=step)
visf.close()
sub_timer.stop().submit()
from grudge.tools import relative_error
relerr_e_q.push_value(
relative_error(discr.norm(mask_e - mask_true_e),
discr.norm(mask_true_e)))
relerr_h_q.push_value(
relative_error(discr.norm(mask_h - mask_true_h),
discr.norm(mask_true_h)))
if write_output:
for outf_num, outf_true, evaluator in point_timeseries:
for outf, ev_h in zip([outf_num, outf_true],
[h, true_h]):
outf.write("%g\t%g\n" %
(t, op.mu * evaluator(ev_h[1])))
outf.flush()
fields = stepper(fields, t, dt, rhs)
finally:
if write_output:
vis.close()
logmgr.save()
discr.close()
def main(write_output=True, allow_features=None, flux_type_arg=1,
bdry_flux_type_arg=None, extra_discr_args={}):
from math import sqrt, pi
from hedge.models.em import TEMaxwellOperator
from hedge.backends import guess_run_context
rcon = guess_run_context(allow_features)
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4*pi*1e-7 # N/A**2.
c = 1/sqrt(mu0*epsilon0)
materials = {"vacuum" : (epsilon0, mu0),
"dielectric" : (2*epsilon0, mu0)}
output_dir = "2d_cavity"
import os
if not os.access(output_dir, os.F_OK):
os.makedirs(output_dir)
# should no tag raise an error or default to free space?
def eps_val(x, el):
for key in materials.keys():
if el in material_elements[key]:
return materials[key][0]
raise ValueError, "Element does not belong to any material"
def mu_val(x, el):
for key in materials.keys():
if el in material_elements[key]:
return materials[key][1]
raise ValueError, "Element does not belong to any material"
# geometry of cavity
d = 100e-3
a = 150e-3
# analytical frequency and transverse wavenumbers of resonance
f0 = 9.0335649907522321e8
h = 2*pi*f0/c
l = -h*sqrt(2)
# substitute the following and change materials for a homogeneous cavity
#h = pi/a
#l =-h
def initial_val(discr):
# the initial solution for the TE_10-like mode
def initial_Hz(x, el):
from math import cos, sin
if el in material_elements["vacuum"]:
return h*cos(h*x[0])
else:
return -l*sin(h*d)/sin(l*(a-d))*cos(l*(a-x[0]))
from hedge.tools import make_obj_array
result_zero = discr.volume_zeros(kind="numpy", dtype=numpy.float64)
H_z = make_tdep_given(initial_Hz).volume_interpolant(0, discr)
return make_obj_array([result_zero, result_zero, H_z])
if rcon.is_head_rank:
from hedge.mesh.reader.gmsh import generate_gmsh
mesh = generate_gmsh(CAVITY_GEOMETRY, 2, force_dimension=2)
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
# Work out which elements belong to each material
material_elements = {}
for key in materials.keys():
material_elements[key] = set(mesh_data.tag_to_elements[key])
order = 3
#extra_discr_args.setdefault("debug", []).append("cuda_no_plan")
#extra_discr_args.setdefault("debug", []).append("dump_optemplate_stages")
from hedge.data import make_tdep_given
from hedge.mesh import TAG_ALL
op = TEMaxwellOperator(epsilon=make_tdep_given(eps_val), mu=make_tdep_given(mu_val), \
flux_type=flux_type_arg, \
bdry_flux_type=bdry_flux_type_arg, dimensions=2, pec_tag=TAG_ALL)
# op = TEMaxwellOperator(epsilon=epsilon0, mu=mu0,
# flux_type=flux_type_arg, \
# bdry_flux_type=bdry_flux_type_arg, dimensions=2, pec_tag=TAG_ALL)
discr = rcon.make_discretization(mesh_data, order=order,
tune_for=op.op_template(),
**extra_discr_args)
# create the initial solution
fields = initial_val(discr)
from hedge.visualization import VtkVisualizer
if write_output:
from os.path import join
vis = VtkVisualizer(discr, rcon, join(output_dir, "cav-%d" % order))
# monitor the solution at a point to find the resonant frequency
try:
point_getter = discr.get_point_evaluator(numpy.array([75e-3, 25e-3, 0])) #[0.25, 0.25, 0.25]))
except RuntimeError:
point_getter = None
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep.runge_kutta import LSRK4TimeStepper
stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type, rcon=rcon)
#from hedge.timestep.dumka3 import Dumka3TimeStepper
#stepper = Dumka3TimeStepper(3, dtype=discr.default_scalar_type, rcon=rcon)
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
from os.path import join
log_file_name = join(output_dir, "cavity-%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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
#from hedge.log import EMFieldGetter, add_em_quantities
#field_getter = EMFieldGetter(discr, op, lambda: fields)
#add_em_quantities(logmgr, op, field_getter)
logmgr.add_watches(
["step.max", "t_sim.max",
#("W_field", "W_el+W_mag"),
"t_step.max"]
)
# timestep loop -------------------------------------------------------
rhs = op.bind(discr)
final_time = 10e-9
if point_getter is not None:
from os.path import join
pointfile = open(join(output_dir, "point.txt"), "wt")
done_dt = False
try:
from hedge.timestep import times_and_steps
from os.path import join
step_it = times_and_steps(
final_time=final_time, logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(discr,
stepper=stepper, t=t, fields=fields))
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
sub_timer = vis_timer.start_sub_timer()
e, h = op.split_eh(fields)
visf = vis.make_file(join(output_dir, "cav-%d-%04d") % (order, step))
vis.add_data(visf,
[
("e",
discr.convert_volume(e, kind="numpy")),
("h",
discr.convert_volume(h, kind="numpy")),],
time=t, step=step
)
visf.close()
sub_timer.stop().submit()
fields = stepper(fields, t, dt, rhs)
if point_getter is not None:
val = point_getter(fields)
#print val
if not done_dt:
pointfile.write("#%g\n" % dt)
done_dt = True
pointfile.write("%g\n" %val[0])
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
if point_getter is not None:
pointfile.close()
def main(write_output=True):
from hedge.timestep.runge_kutta import LSRK4TimeStepper
from math import sqrt, pi, exp
from hedge.backends import guess_run_context
rcon = guess_run_context()
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
c = 1 / sqrt(mu * epsilon)
pml_width = 0.5
#mesh = make_mesh(a=np.array((-1,-1,-1)), b=np.array((1,1,1)),
#mesh = make_mesh(a=np.array((-3,-3)), b=np.array((3,3)),
mesh = make_mesh(
a=np.array((-1, -1)),
b=np.array((1, 1)),
#mesh = make_mesh(a=np.array((-2,-2)), b=np.array((2,2)),
pml_width=pml_width,
max_volume=0.01)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
class Current:
def volume_interpolant(self, t, discr):
from hedge.tools import make_obj_array
result = discr.volume_zeros(kind="numpy", dtype=np.float64)
omega = 6 * c
if omega * t > 2 * pi:
return make_obj_array([result, result, result])
x = make_obj_array(discr.nodes.T)
r = np.sqrt(np.dot(x, x))
idx = r < 0.3
result[idx] = (1+np.cos(pi*r/0.3))[idx] \
*np.sin(omega*t)**3
result = discr.convert_volume(result,
kind=discr.compute_kind,
dtype=discr.default_scalar_type)
return make_obj_array([-result, result, result])
order = 3
discr = rcon.make_discretization(mesh_data,
order=order,
debug=["cuda_no_plan"])
from hedge.visualization import VtkVisualizer
if write_output:
vis = VtkVisualizer(discr, rcon, "em-%d" % order)
from hedge.mesh import TAG_ALL, TAG_NONE
from hedge.data import GivenFunction, TimeHarmonicGivenFunction, TimeIntervalGivenFunction
from hedge.models.em import MaxwellOperator
from hedge.models.pml import \
AbarbanelGottliebPMLMaxwellOperator, \
AbarbanelGottliebPMLTMMaxwellOperator, \
AbarbanelGottliebPMLTEMaxwellOperator
op = AbarbanelGottliebPMLTEMaxwellOperator(epsilon,
mu,
flux_type=1,
current=Current(),
pec_tag=TAG_ALL,
absorb_tag=TAG_NONE,
add_decay=True)
fields = op.assemble_ehpq(discr=discr)
stepper = LSRK4TimeStepper()
if rcon.is_head_rank:
print "order %d" % order
print "#elements=", len(mesh.elements)
# diagnostics setup ---------------------------------------------------
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "maxwell-%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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from hedge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
logmgr.add_watches(
["step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max"])
from hedge.log import LpNorm
class FieldIdxGetter:
def __init__(self, whole_getter, idx):
self.whole_getter = whole_getter
self.idx = idx
def __call__(self):
return self.whole_getter()[self.idx]
# timestep loop -------------------------------------------------------
t = 0
pml_coeff = op.coefficients_from_width(discr, width=pml_width)
rhs = op.bind(discr, pml_coeff)
try:
from hedge.timestep import times_and_steps
step_it = times_and_steps(
final_time=4 / c,
logmgr=logmgr,
max_dt_getter=lambda t: op.estimate_timestep(
discr, stepper=stepper, t=t, fields=fields))
for step, t, dt in step_it:
if step % 10 == 0 and write_output:
e, h, p, q = op.split_ehpq(fields)
visf = vis.make_file("em-%d-%04d" % (order, step))
#pml_rhs_e, pml_rhs_h, pml_rhs_p, pml_rhs_q = \
#op.split_ehpq(rhs(t, fields))
j = Current().volume_interpolant(t, discr)
vis.add_data(
visf,
[
("e", discr.convert_volume(e, "numpy")),
("h", discr.convert_volume(h, "numpy")),
("p", discr.convert_volume(p, "numpy")),
("q", discr.convert_volume(q, "numpy")),
("j", discr.convert_volume(j, "numpy")),
#("pml_rhs_e", pml_rhs_e),
#("pml_rhs_h", pml_rhs_h),
#("pml_rhs_p", pml_rhs_p),
#("pml_rhs_q", pml_rhs_q),
#("max_rhs_e", max_rhs_e),
#("max_rhs_h", max_rhs_h),
#("max_rhs_p", max_rhs_p),
#("max_rhs_q", max_rhs_q),
],
time=t,
step=step)
visf.close()
fields = stepper(fields, t, dt, rhs)
_, _, energies_data = logmgr.get_expr_dataset("W_el+W_mag")
energies = [value for tick_nbr, value in energies_data]
assert energies[-1] < max(energies) * 1e-2
finally:
logmgr.close()
if write_output:
vis.close()
def main(write_output=True,
allow_features=None,
flux_type_arg=1,
bdry_flux_type_arg=None,
extra_discr_args={}):
from hedge.mesh.generator import make_cylinder_mesh, make_box_mesh
from hedge.tools import EOCRecorder, to_obj_array
from math import sqrt, pi # noqa
from analytic_solutions import ( # noqa
RealPartAdapter, SplitComplexAdapter, CylindricalFieldAdapter,
CylindricalCavityMode, RectangularWaveguideMode, RectangularCavityMode)
from hedge.models.em import MaxwellOperator
logging.basicConfig(level=logging.DEBUG)
from hedge.backends import guess_run_context
rcon = guess_run_context(allow_features)
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
eoc_rec = EOCRecorder()
cylindrical = False
periodic = False
if cylindrical:
R = 1
d = 2
mode = CylindricalCavityMode(m=1,
n=1,
p=1,
radius=R,
height=d,
epsilon=epsilon,
mu=mu)
# r_sol = CylindricalFieldAdapter(RealPartAdapter(mode))
# c_sol = SplitComplexAdapter(CylindricalFieldAdapter(mode))
if rcon.is_head_rank:
mesh = make_cylinder_mesh(radius=R, height=d, max_volume=0.01)
else:
if periodic:
mode = RectangularWaveguideMode(epsilon, mu, (3, 2, 1))
periodicity = (False, False, True)
else:
periodicity = None
mode = RectangularCavityMode(epsilon, mu, (1, 2, 2))
if rcon.is_head_rank:
mesh = make_box_mesh(max_volume=0.001, periodicity=periodicity)
if rcon.is_head_rank:
mesh_data = rcon.distribute_mesh(mesh)
else:
mesh_data = rcon.receive_mesh()
for order in [4, 5, 6]:
#for order in [1,2,3,4,5,6]:
extra_discr_args.setdefault("debug", []).extend(
["cuda_no_plan", "cuda_dump_kernels"])
op = MaxwellOperator(epsilon,
mu,
flux_type=flux_type_arg,
bdry_flux_type=bdry_flux_type_arg)
discr = rcon.make_discretization(mesh_data,
order=order,
tune_for=op.op_template(),
**extra_discr_args)
from hedge.visualization import VtkVisualizer
if write_output:
vis = VtkVisualizer(discr, rcon, "em-%d" % order)
mode.set_time(0)
def get_true_field():
return discr.convert_volume(to_obj_array(
mode(discr).real.astype(discr.default_scalar_type).copy()),
kind=discr.compute_kind)
fields = get_true_field()
if rcon.is_head_rank:
print "---------------------------------------------"
print "order %d" % order
print "---------------------------------------------"
print "#elements=", len(mesh.elements)
from hedge.timestep.runge_kutta import LSRK4TimeStepper
stepper = LSRK4TimeStepper(dtype=discr.default_scalar_type, rcon=rcon)
#from hedge.timestep.dumka3 import Dumka3TimeStepper
#stepper = Dumka3TimeStepper(3, dtype=discr.default_scalar_type, rcon=rcon)
# {{{ diagnostics setup
from pytools.log import LogManager, add_general_quantities, \
add_simulation_quantities, add_run_info
if write_output:
log_file_name = "maxwell-%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)
from pytools.log import IntervalTimer
vis_timer = IntervalTimer("t_vis", "Time spent visualizing")
logmgr.add_quantity(vis_timer)
from hedge.log import EMFieldGetter, add_em_quantities
field_getter = EMFieldGetter(discr, op, lambda: fields)
add_em_quantities(logmgr, op, field_getter)
logmgr.add_watches(
["step.max", "t_sim.max", ("W_field", "W_el+W_mag"), "t_step.max"])
# }}}
# {{{ timestep loop
rhs = op.bind(discr)
final_time = 0.5e-9
try:
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, fields=fields))
for step, t, dt in step_it:
if step % 50 == 0 and write_output:
sub_timer = vis_timer.start_sub_timer()
e, h = op.split_eh(fields)
visf = vis.make_file("em-%d-%04d" % (order, step))
vis.add_data(visf, [
("e", discr.convert_volume(e, kind="numpy")),
("h", discr.convert_volume(h, kind="numpy")),
],
time=t,
step=step)
visf.close()
sub_timer.stop().submit()
fields = stepper(fields, t, dt, rhs)
mode.set_time(final_time)
eoc_rec.add_data_point(order,
discr.norm(fields - get_true_field()))
finally:
if write_output:
vis.close()
logmgr.close()
discr.close()
if rcon.is_head_rank:
print
print eoc_rec.pretty_print("P.Deg.", "L2 Error")
# }}}
assert eoc_rec.estimate_order_of_convergence()[0, 1] > 6
