def test_kv_with_no_charge(): from random import seed seed(0) from pyrticle.units import SIUnitsWithNaturalConstants units = SIUnitsWithNaturalConstants() # discretization setup ---------------------------------------------------- from hedge.mesh import make_cylinder_mesh from hedge.backends import guess_run_context rcon = guess_run_context([]) tube_length = 100 * units.MM mesh = make_cylinder_mesh(radius=25 * units.MM, height=tube_length, periodic=True) discr = rcon.make_discretization(mesh, order=3) dt = discr.dt_factor(units.VACUUM_LIGHT_SPEED()) / 2 final_time = 1 * units.M / units.VACUUM_LIGHT_SPEED() nsteps = int(final_time / dt) + 1 dt = final_time / nsteps # particles setup --------------------------------------------------------- from pyrticle.cloud import PicMethod from pyrticle.deposition.shape import ShapeFunctionDepositor from pyrticle.pusher import MonomialParticlePusher method = PicMethod(discr, units, ShapeFunctionDepositor(), MonomialParticlePusher(), 3, 3) nparticles = 10000 cloud_charge = 1e-9 * units.C electrons_per_particle = cloud_charge / nparticles / units.EL_CHARGE el_energy = 5.2e6 * units.EV gamma = el_energy / units.EL_REST_ENERGY() beta = (1 - 1 / gamma**2)**0.5 from pyrticle.distribution import KVZIntervalBeam beam = KVZIntervalBeam(units, total_charge=0, p_charge=0, p_mass=electrons_per_particle * units.EL_MASS, radii=2 * [2.5 * units.MM], emittances=2 * [5 * units.MM * units.MRAD], z_length=5 * units.MM, z_pos=10 * units.MM, beta=beta) state = method.make_state() method.add_particles(state, beam.generate_particles(), nparticles) # diagnostics setup ------------------------------------------------------- from pytools.log import LogManager from pyrticle.log import add_beam_quantities, StateObserver observer = StateObserver(method, None) logmgr = LogManager(mode="w") add_beam_quantities(logmgr, observer, axis=0, beam_axis=2) from pyrticle.distribution import KVPredictedRadius logmgr.add_quantity( KVPredictedRadius(dt, beam_v=beta * units.VACUUM_LIGHT_SPEED(), predictor=beam.get_rms_predictor(axis=0), suffix="x_rms")) logmgr.add_quantity( KVPredictedRadius(dt, beam_v=beta * units.VACUUM_LIGHT_SPEED(), predictor=beam.get_total_predictor(axis=0), suffix="x_total")) # timestep loop ----------------------------------------------------------- vel = method.velocities(state) from hedge.tools import join_fields def rhs(t, y): return join_fields([ vel, 0 * vel, 0, # drecon ]) from hedge.timestep.runge_kutta import LSRK4TimeStepper stepper = LSRK4TimeStepper() t = 0 from pyrticle.cloud import TimesteppablePicState ts_state = TimesteppablePicState(method, state) for step in xrange(nsteps): observer.set_fields_and_state(None, ts_state.state) logmgr.tick() ts_state = stepper(ts_state, t, dt, rhs) method.upkeep(ts_state.state) t += dt logmgr.tick() _, _, err_table = logmgr.get_expr_dataset( "(rx_rms-rx_rms_theory)/rx_rms_theory") rel_max_rms_error = max(err for step, err in err_table) assert rel_max_rms_error < 0.01
def main(write_output=True): from hedge.timestep import RK4TimeStepper from hedge.mesh import make_disk_mesh from math import sqrt, pi, exp from hedge.backends import guess_run_context, FEAT_CUDA 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) cylindrical = False periodic = False pml_width = 0.5 #mesh = make_mesh(a=numpy.array((-1,-1,-1)), b=numpy.array((1,1,1)), #mesh = make_mesh(a=numpy.array((-3,-3)), b=numpy.array((3,3)), mesh = make_mesh(a=numpy.array((-1,-1)), b=numpy.array((1,1)), #mesh = make_mesh(a=numpy.array((-2,-2)), b=numpy.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=numpy.float64) omega = 6*c if omega*t > 2*pi: return make_obj_array([result, result, result]) x = make_obj_array(discr.nodes.T) r = numpy.sqrt(numpy.dot(x, x)) idx = r<0.3 result[idx] = (1+numpy.cos(pi*r/0.3))[idx] \ *numpy.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 = RK4TimeStepper() 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): 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 test_kv_with_no_charge(): from random import seed seed(0) from pyrticle.units import SIUnitsWithNaturalConstants units = SIUnitsWithNaturalConstants() # discretization setup ---------------------------------------------------- from hedge.mesh import make_cylinder_mesh from hedge.backends import guess_run_context rcon = guess_run_context([]) tube_length = 100*units.MM mesh = make_cylinder_mesh(radius=25*units.MM, height=tube_length, periodic=True) discr = rcon.make_discretization(mesh, order=3) dt = discr.dt_factor(units.VACUUM_LIGHT_SPEED()) / 2 final_time = 1*units.M/units.VACUUM_LIGHT_SPEED() nsteps = int(final_time/dt)+1 dt = final_time/nsteps # particles setup --------------------------------------------------------- from pyrticle.cloud import PicMethod from pyrticle.deposition.shape import ShapeFunctionDepositor from pyrticle.pusher import MonomialParticlePusher method = PicMethod(discr, units, ShapeFunctionDepositor(), MonomialParticlePusher(), 3, 3) nparticles = 10000 cloud_charge = 1e-9 * units.C electrons_per_particle = cloud_charge/nparticles/units.EL_CHARGE el_energy = 5.2e6 * units.EV gamma = el_energy/units.EL_REST_ENERGY() beta = (1-1/gamma**2)**0.5 from pyrticle.distribution import KVZIntervalBeam beam = KVZIntervalBeam(units, total_charge=0, p_charge=0, p_mass=electrons_per_particle*units.EL_MASS, radii=2*[2.5*units.MM], emittances=2*[5 * units.MM * units.MRAD], z_length=5*units.MM, z_pos=10*units.MM, beta=beta) state = method.make_state() method.add_particles(state, beam.generate_particles(), nparticles) # diagnostics setup ------------------------------------------------------- from pytools.log import LogManager from pyrticle.log import add_beam_quantities, StateObserver observer = StateObserver(method, None) logmgr = LogManager(mode="w") add_beam_quantities(logmgr, observer, axis=0, beam_axis=2) from pyrticle.distribution import KVPredictedRadius logmgr.add_quantity(KVPredictedRadius(dt, beam_v=beta*units.VACUUM_LIGHT_SPEED(), predictor=beam.get_rms_predictor(axis=0), suffix="x_rms")) logmgr.add_quantity(KVPredictedRadius(dt, beam_v=beta*units.VACUUM_LIGHT_SPEED(), predictor=beam.get_total_predictor(axis=0), suffix="x_total")) # timestep loop ----------------------------------------------------------- vel = method.velocities(state) from hedge.tools import join_fields def rhs(t, y): return join_fields([ vel, 0*vel, 0, # drecon ]) from hedge.timestep.runge_kutta import LSRK4TimeStepper stepper = LSRK4TimeStepper() t = 0 from pyrticle.cloud import TimesteppablePicState ts_state = TimesteppablePicState(method, state) for step in xrange(nsteps): observer.set_fields_and_state(None, ts_state.state) logmgr.tick() ts_state = stepper(ts_state, t, dt, rhs) method.upkeep(ts_state.state) t += dt logmgr.tick() _, _, err_table = logmgr.get_expr_dataset("(rx_rms-rx_rms_theory)/rx_rms_theory") rel_max_rms_error = max(err for step, err in err_table) assert rel_max_rms_error < 0.01