period=10,
write_dir='.',
warpx_file_prefix='Python_LaserAccelerationMR_plt',
data_list=diag_field_list)
part_diag1 = picmi.ParticleDiagnostic(name='diag1',
period=10,
species=[electrons])
##########################
# simulation setup
##########################
sim = picmi.Simulation(solver=solver,
max_steps=max_steps,
verbose=1,
warpx_current_deposition_algo='esirkepov',
warpx_use_filter=0)
sim.add_species(electrons,
layout=picmi.GriddedLayout(
grid=grid,
n_macroparticle_per_cell=number_per_cell_each_dim))
sim.add_laser(laser, injection_method=laser_antenna)
sim.add_diagnostic(field_diag1)
sim.add_diagnostic(part_diag1)
##########################
# simulation run
write_dir='.',
warpx_file_prefix='Python_restart_eb_plt')
checkpoint = picmi.Checkpoint(name='chkpoint',
period=diagnostic_intervals,
write_dir='.',
warpx_file_min_digits=5,
warpx_file_prefix=f'Python_restart_eb_chk')
##########################
# simulation setup
##########################
sim = picmi.Simulation(solver=solver,
max_steps=max_steps,
warpx_embedded_boundary=embedded_boundary,
verbose=True,
warpx_load_balance_intervals=40,
warpx_load_balance_efficiency_ratio_threshold=0.9)
sim.add_species(electrons,
layout=picmi.GriddedLayout(n_macroparticle_per_cell=[1, 1, 1],
grid=grid))
for arg in sys.argv:
if arg.startswith("amr.restart"):
restart_file_name = arg.split("=")[1]
sim.amr_restart = restart_file_name
sys.argv.remove(arg)
sim.add_diagnostic(field_diag)
sim.add_diagnostic(checkpoint)
field_diag = picmi.FieldDiagnostic(
name = 'diag1',
grid = grid,
period = diagnostic_intervals,
data_list = ['rho_electrons', 'rho_he_ions', 'phi'],
write_dir = '.',
warpx_file_prefix = 'Python_background_mcc_plt'
)
##########################
# simulation setup
##########################
sim = picmi.Simulation(
solver = solver,
time_step_size = DT,
max_steps = max_steps,
warpx_collisions=[mcc_electrons, mcc_ions]
)
sim.add_species(
electrons,
layout = picmi.GriddedLayout(
n_macroparticle_per_cell=number_per_cell_each_dim, grid=grid
)
)
sim.add_species(
ions,
layout = picmi.GriddedLayout(
n_macroparticle_per_cell=number_per_cell_each_dim, grid=grid
)
)
# Electromagnetic solver
solver = picmi.ElectromagneticSolver(grid=grid, method='Yee', cfl=0.7)
# Diagnostics
part_diag1 = picmi.ParticleDiagnostic(
name='diag1',
period=max_steps,
species=[electrons],
data_list=['ux', 'uy', 'uz'],
write_dir='.',
warpx_file_prefix='Python_plasma_lens_plt')
# Set up simulation
sim = picmi.Simulation(solver=solver,
max_steps=max_steps,
verbose=1,
particle_shape='linear',
warpx_serialize_initial_conditions=1,
warpx_do_dynamic_scheduling=0)
# Add plasma electrons
sim.add_species(electrons, layout=None)
# Add the plasma lenses
sim.add_applied_field(plasma_lenses)
# Add diagnostics
sim.add_diagnostic(part_diag1)
# Write input file that can be used to run with the compiled version
#sim.write_input_file(file_name = 'inputs_3d_picmi')
#################################
field_diag = picmi.FieldDiagnostic(name='diag1',
grid=grid,
period=10,
data_list=[],
write_dir='.',
warpx_file_prefix='Python_collisionXZ_plt')
#################################
####### SIMULATION SETUP ########
#################################
sim = picmi.Simulation(
solver=solver,
max_steps=max_steps,
verbose=verbose,
warpx_serialize_initial_conditions=serialize_initial_conditions,
warpx_collisions=[collision1, collision2, collision3])
sim.add_species(electrons,
layout=picmi.PseudoRandomLayout(
n_macroparticles_per_cell=number_per_cell, grid=grid))
sim.add_species(ions,
layout=picmi.PseudoRandomLayout(
n_macroparticles_per_cell=number_per_cell, grid=grid))
sim.add_diagnostic(field_diag)
#################################
##### SIMULATION EXECUTION ######
#################################
grid = picmi.Cartesian3DGrid(
number_of_cells=[nx, ny, nz],
lower_bound=[xmin, ymin, zmin],
upper_bound=[xmax, ymax, zmax],
lower_boundary_conditions=['periodic', 'periodic', 'periodic'],
upper_boundary_conditions=['periodic', 'periodic', 'periodic'],
moving_window_velocity=[0., 0., 0.],
warpx_max_grid_size=32)
solver = picmi.ElectromagneticSolver(grid=grid, cfl=1.)
sim = picmi.Simulation(solver=solver,
max_steps=40,
verbose=1,
warpx_plot_int=1,
warpx_current_deposition_algo='direct',
warpx_charge_deposition_algo='standard',
warpx_field_gathering_algo='standard',
warpx_particle_pusher_algo='boris')
sim.add_species(electrons,
layout=picmi.GriddedLayout(n_macroparticle_per_cell=[2, 2, 2],
grid=grid))
# write_inputs will create an inputs file that can be used to run
# with the compiled version.
sim.write_input_file(file_name='inputs_from_PICMI')
# Alternatively, sim.step will run WarpX, controlling it from Python
sim.step()
##########################
# diagnostics
##########################
field_diag = picmi.FieldDiagnostic(
name='diag1',
grid=grid,
period=1,
data_list=['Ex', 'Ey', 'Ez', 'phi', 'rho'],
write_dir='.',
warpx_file_prefix='Python_ElectrostaticSphereEB_plt')
##########################
# simulation setup
##########################
sim = picmi.Simulation(solver=solver,
time_step_size=dt,
max_steps=max_steps,
warpx_embedded_boundary=embedded_boundary,
warpx_field_gathering_algo='momentum-conserving')
sim.add_diagnostic(field_diag)
##########################
# simulation run
##########################
sim.step(max_steps)
divE_cleaning=0)
# Diagnostics
diag_field_list = ['B', 'E', 'J', 'rho']
field_diag = picmi.FieldDiagnostic(
name='diag1',
grid=grid,
period=200,
data_list=diag_field_list,
write_dir='.',
warpx_file_prefix='Python_LaserAccelerationMR_plt')
# Set up simulation
sim = picmi.Simulation(solver=solver,
max_steps=max_steps,
verbose=1,
particle_shape='cubic',
warpx_use_filter=1,
warpx_serialize_ics=1)
# Add plasma electrons
sim.add_species(electrons,
layout=picmi.GriddedLayout(grid=grid,
n_macroparticle_per_cell=[1, 1, 1]))
# Add beam electrons
sim.add_species(beam,
layout=picmi.PseudoRandomLayout(grid=grid,
n_macroparticles=100))
# Add laser
sim.add_laser(laser, injection_method=laser_antenna)
field_diag = picmi.FieldDiagnostic(
name = 'diag1',
grid = grid,
period = 10,
data_list = ['phi'],
write_dir = '.',
warpx_file_prefix = f'Python_particle_attr_access_plt_{color}'
)
##########################
# simulation setup
##########################
sim = picmi.Simulation(
solver = solver,
time_step_size = dt,
max_steps = max_steps,
verbose = 1
)
sim.add_species(
electrons,
layout = picmi.GriddedLayout(
n_macroparticle_per_cell=[0, 0], grid=grid
)
)
sim.add_diagnostic(field_diag)
sim.initialize_inputs()
sim.initialize_warpx(mpi_comm=new_comm)
##########################
##########################
field_diag = picmi.FieldDiagnostic(name='diag1',
grid=grid,
period=4,
data_list=['phi'],
write_dir='.',
warpx_file_prefix='Python_dirichletbc_plt')
##########################
# simulation setup
##########################
sim = picmi.Simulation(solver=solver,
time_step_size=dt,
max_steps=max_steps,
particle_shape=None,
verbose=0)
sim.add_diagnostic(field_diag)
##########################
# simulation run
##########################
# write_inputs will create an inputs file that can be used to run
# with the compiled version.
#sim.write_input_file(file_name = 'inputs_from_PICMI')
# Alternatively, sim.step will run WarpX, controlling it from Python
sim.step(max_steps)
species=electrons,
name = 'diag1',
data_list=['previous_positions'],
period = 10,
write_dir = '.',
warpx_file_prefix = 'Python_particle_reflection_plt'
)
##########################
# simulation setup
##########################
sim = picmi.Simulation(
solver = solver,
time_step_size = dt,
max_steps = max_steps,
# warpx_embedded_boundary=embedded_boundary,
verbose = 1
)
sim.add_species(
electrons,
layout = picmi.GriddedLayout(
n_macroparticle_per_cell=[5, 2], grid=grid
)
)
sim.add_diagnostic(field_diag)
##########################
# simulation run
##########################
##########################
field_diag = picmi.FieldDiagnostic(
name='diag1',
grid=grid,
period=1,
data_list=['Ex'],
write_dir='.',
warpx_file_prefix="embedded_boundary_python_API_plt")
##########################
# simulation setup
##########################
sim = picmi.Simulation(solver=solver,
max_steps=max_steps,
warpx_embedded_boundary=embedded_boundary,
verbose=1)
sim.add_diagnostic(field_diag)
sim.initialize_inputs()
sim.step(1)
print("======== Testing sim.extension.get_mesh_edge_lengths =========")
ly_slice_x = np.array(
sim.extension.get_mesh_edge_lengths(
0, 1, include_ghosts=False)[0])[int(nx / 2), :, :]
lz_slice_x = np.array(
sim.extension.get_mesh_edge_lengths(
def setup_run(self):
"""Setup simulation components."""
#######################################################################
# Set geometry and boundary conditions #
#######################################################################
self.grid = picmi.Cartesian1DGrid(
number_of_cells=[self.nz],
warpx_max_grid_size=128,
lower_bound=[0],
upper_bound=[self.gap],
lower_boundary_conditions=['dirichlet'],
upper_boundary_conditions=['dirichlet'],
lower_boundary_conditions_particles=['absorbing'],
upper_boundary_conditions_particles=['absorbing'],
warpx_potential_hi_z=self.voltage,
)
#######################################################################
# Field solver #
#######################################################################
self.solver = picmi.ElectrostaticSolver(grid=self.grid,
method='Multigrid',
required_precision=1e-12,
warpx_self_fields_verbosity=0)
#######################################################################
# Particle types setup #
#######################################################################
self.electrons = picmi.Species(
particle_type='electron',
name='electrons',
initial_distribution=picmi.UniformDistribution(
density=self.plasma_density,
rms_velocity=[
np.sqrt(constants.kb * self.elec_temp / constants.m_e)
] * 3,
))
self.ions = picmi.Species(
particle_type='He',
name='he_ions',
charge='q_e',
mass=self.m_ion,
initial_distribution=picmi.UniformDistribution(
density=self.plasma_density,
rms_velocity=[
np.sqrt(constants.kb * self.gas_temp / self.m_ion)
] * 3,
))
#######################################################################
# Collision initialization #
#######################################################################
cross_sec_direc = '../../../../warpx-data/MCC_cross_sections/He/'
mcc_electrons = picmi.MCCCollisions(
name='coll_elec',
species=self.electrons,
background_density=self.gas_density,
background_temperature=self.gas_temp,
background_mass=self.ions.mass,
scattering_processes={
'elastic': {
'cross_section':
cross_sec_direc + 'electron_scattering.dat'
},
'excitation1': {
'cross_section': cross_sec_direc + 'excitation_1.dat',
'energy': 19.82
},
'excitation2': {
'cross_section': cross_sec_direc + 'excitation_2.dat',
'energy': 20.61
},
'ionization': {
'cross_section': cross_sec_direc + 'ionization.dat',
'energy': 24.55,
'species': self.ions
},
})
mcc_ions = picmi.MCCCollisions(
name='coll_ion',
species=self.ions,
background_density=self.gas_density,
background_temperature=self.gas_temp,
scattering_processes={
'elastic': {
'cross_section': cross_sec_direc + 'ion_scattering.dat'
},
'back': {
'cross_section': cross_sec_direc + 'ion_back_scatter.dat'
},
# 'charge_exchange' : {
# 'cross_section' : cross_sec_direc+'charge_exchange.dat'
# }
})
#######################################################################
# Initialize simulation #
#######################################################################
self.sim = picmi.Simulation(
solver=self.solver,
time_step_size=self.dt,
max_steps=self.max_steps,
warpx_collisions=[mcc_electrons, mcc_ions],
warpx_load_balance_intervals=self.max_steps // 5000,
verbose=self.test)
self.sim.add_species(self.electrons,
layout=picmi.GriddedLayout(
n_macroparticle_per_cell=[self.seed_nppc],
grid=self.grid))
self.sim.add_species(self.ions,
layout=picmi.GriddedLayout(
n_macroparticle_per_cell=[self.seed_nppc],
grid=self.grid))
#######################################################################
# Add diagnostics for the CI test to be happy #
#######################################################################
field_diag = picmi.FieldDiagnostic(
name='diag1',
grid=self.grid,
period=0,
data_list=['rho_electrons', 'rho_he_ions'],
write_dir='.',
warpx_file_prefix='Python_background_mcc_1d_plt')
self.sim.add_diagnostic(field_diag)
def __init__(self):
self.initialized = False
self.simulation = picmi.Simulation(verbose=0)
# make a shorthand for simulation.extension since we use it a lot
self.sim_ext = self.simulation.extension
plasma_distribution = picmi.UniformDistribution(
density=1.e22,
lower_bound=[-200.e-6, -200.e-6, 0.],
upper_bound=[+200.e-6, +200.e-6, None],
fill_in=True)
beam = picmi.Species(particle_type='electron',
name='beam',
initial_distribution=beam_distribution)
plasma = picmi.Species(particle_type='electron',
name='plasma',
initial_distribution=plasma_distribution)
sim = picmi.Simulation(solver=solver,
max_steps=2,
verbose=1,
warpx_current_deposition_algo='esirkepov')
sim.add_species(beam,
layout=picmi.GriddedLayout(
grid=grid,
n_macroparticle_per_cell=number_per_cell_each_dim))
sim.add_species(plasma,
layout=picmi.GriddedLayout(
grid=grid,
n_macroparticle_per_cell=number_per_cell_each_dim))
field_diag = picmi.FieldDiagnostic(
name='diag1',
grid=grid,
period=2,
grid = picmi.CylindricalGrid(
number_of_cells=[nr, nz],
n_azimuthal_modes=3,
lower_bound=[rmin, zmin],
upper_bound=[rmax, zmax],
lower_boundary_conditions=['dirichlet', 'periodic'],
upper_boundary_conditions=['dirichlet', 'periodic'],
moving_window_zvelocity=0.,
warpx_max_grid_size=64)
solver = picmi.ElectromagneticSolver(grid=grid, cfl=1.)
sim = picmi.Simulation(solver=solver,
max_steps=40,
verbose=1,
warpx_plot_int=40,
warpx_current_deposition_algo='esirkepov',
warpx_field_gathering_algo='energy-conserving',
warpx_particle_pusher_algo='boris')
sim.add_species(electrons,
layout=picmi.GriddedLayout(n_macroparticle_per_cell=[2, 16, 2],
grid=grid))
sim.add_species(protons,
layout=picmi.GriddedLayout(n_macroparticle_per_cell=[2, 16, 2],
grid=grid))
# write_inputs will create an inputs file that can be used to run
# with the compiled version.
#sim.write_input_file(file_name='inputsrz_from_PICMI')
grid = picmi.CylindricalGrid(
number_of_cells=[nr, nz],
lower_bound=[rmin, zmin],
upper_bound=[rmax, zmax],
lower_boundary_conditions=['dirichlet', 'periodic'],
upper_boundary_conditions=['dirichlet', 'periodic'],
moving_window_velocity=[0., 0.],
warpx_max_grid_size=32)
solver = picmi.ElectromagneticSolver(grid=grid, cfl=1.)
sim = picmi.Simulation(solver=solver,
max_steps=40,
verbose=1,
warpx_plot_int=1,
warpx_current_deposition_algo=3,
warpx_charge_deposition_algo=0,
warpx_field_gathering_algo=0,
warpx_particle_pusher_algo=0)
sim.add_species(electrons,
layout=picmi.GriddedLayout(n_macroparticle_per_cell=[2, 2],
grid=grid))
# write_inputs will create an inputs file that can be used to run
# with the compiled version.
sim.write_input_file(file_name='inputsrz_from_PICMI')
# Alternatively, sim.step will run WarpX, controlling it from Python
#sim.step()
grid=grid,
period=10,
data_list=args.fields_to_plot,
warpx_format=args.diagformat,
write_dir='.',
warpx_file_prefix='Python_gaussian_beam_plt')
part_diag1 = picmi.ParticleDiagnostic(name='diag1',
period=10,
species=[electrons, protons],
data_list=['weighting', 'momentum'],
warpx_format=args.diagformat)
sim = picmi.Simulation(solver=solver,
max_steps=10,
verbose=1,
warpx_current_deposition_algo='direct',
warpx_use_filter=0)
sim.add_species(
electrons,
layout=picmi.PseudoRandomLayout(n_macroparticles=number_sim_particles))
sim.add_species(
protons,
layout=picmi.PseudoRandomLayout(n_macroparticles=number_sim_particles))
sim.add_diagnostic(field_diag1)
sim.add_diagnostic(part_diag1)
# write_inputs will create an inputs file that can be used to run
# with the compiled version.
name='electrons',
initial_distribution=uniform_plasma)
grid = picmi.Cartesian2DGrid(
number_of_cells=[nx, ny],
lower_bound=[xmin, ymin],
upper_bound=[xmax, ymax],
lower_boundary_conditions=['periodic', 'periodic'],
upper_boundary_conditions=['periodic', 'periodic'],
moving_window_velocity=[0., 0., 0.],
warpx_max_grid_size=32)
solver = picmi.ElectromagneticSolver(grid=grid, cfl=1.)
sim = picmi.Simulation(solver=solver,
max_steps=40,
verbose=1,
warpx_plot_int=1,
warpx_current_deposition_algo='direct')
sim.add_species(electrons,
layout=picmi.GriddedLayout(n_macroparticle_per_cell=[2, 2],
grid=grid))
# write_inputs will create an inputs file that can be used to run
# with the compiled version.
sim.write_input_file(file_name='inputs2d_from_PICMI')
# Alternatively, sim.step will run WarpX, controlling it from Python
#sim.step()
warpx_psatd_update_with_rho=True)
# Initialize diagnostics
diag_field_list = ["E", "B"]
field_diag = picmi.FieldDiagnostic(name='diag1',
grid=grid,
period=10,
write_dir='.',
warpx_file_prefix='Python_wrappers_plt',
data_list=diag_field_list)
# Initialize simulation
sim = picmi.Simulation(solver=solver,
max_steps=max_steps,
verbose=1,
particle_shape='cubic',
warpx_current_deposition_algo='direct',
warpx_particle_pusher_algo='boris',
warpx_field_gathering_algo='energy-conserving',
warpx_use_filter=1)
# Add diagnostics to simulation
sim.add_diagnostic(field_diag)
# Write input file to run with compiled version
sim.write_input_file(file_name='inputs_2d')
# Whether to include guard cells in data returned by Python wrappers
include_ghosts = 1
# Compute min and max of fields data
