advection_squares Namespace Reference

Variables
str	torder = 'RK4'
str	sorder = 'thirdOrder'
list	velocity = [1.0,0.0,0.0]
bool	periodic_boundary_conditions = True
bool	use_limiters = False
float	skin_depth_norm = 1.0
float	omega_p_norm = 1.0
int	charge = 1
int	mass = 1
int	charge_to_mass = charge/mass
float	cfl = 0.8
float	perturbation = 0.01
int	thermal_velocity = 1
float	density = 1.0
list	v_space_num_elements = [40]
list	min_v = [-5]
list	dv = [0.25]
int	num_physical_elements = 40
int	L = 2 * np.pi
warpy	mesh
	Generate a mesh -> vlasov.
warpy	distribution
	Create a variable for the fluid and one for the array Make components array component_names = np.zeros(number_velocity_components) for i in range(number_velocity_components): component_names[i] = 'fe' + str(i)
warpy	field
warpy	fluid
warpy	distribution_ic
	Initial conditions function.
warpy	maxwell_ic
list	applicators
	Initial condition applicator.
list	apps_kinetic
	Applications (consists of equation sets and boundary conditions)
list	apps_physical
list	applications_moments = []
list	variable_adjusters = []
	Variable adjusters.
warpy	writer
	Variable writer.
warpy	spatial_solver_kinetic
	Spatial solver.
warpy	spatial_solver_physical
warpy	temporal_solver
	Temporal solver.
int	dt = 1e-5
	Simulation (dg)
int	t_final = 20
warpy	dt_controller = warpy.dt_calc.stability_dt(dt)
int	timesteps = 2000
int	write_steps = 100
warpy	sim
	gen_xdmf
	Run Simulation ... 1 sim.run('kinetic_advection/apr18_2018',.
	detect_nonscalar

Variable Documentation

applications_moments

list advection_squares.applications_moments = []

applicators

list advection_squares.applicators

Initial value:

=  [warpy.applicator(spatial_order = sorder,
                                fun = distribution_ic,
                                var = distribution,
                                spatial_scheme = 'Nodal_Kinetic',
                                phase_space_spatial_order=sorder,
                                v_space_num_elements = v_space_num_elements,
                                min_v = min_v,
                                dv = dv)]

Initial condition applicator.

apps_kinetic

list advection_squares.apps_kinetic

Initial value:

=  [warpy.apps.vlasovmaxwell.vlasovmaxwell(name = 'advection_squares',
                                 pdf_variable = distribution,
                                 field_variable = field,
                                 skin_depth_norm = skin_depth_norm,
                                 charge_to_mass = charge_to_mass)]

Applications (consists of equation sets and boundary conditions)

apps_physical

list advection_squares.apps_physical

Initial value:

=  [warpy.apps.maxwell.flux(name='maxwell',
                                         field=field,
                                         skin_depth_norm=skin_depth_norm,
                                         omega_p_norm=omega_p_norm)]

cfl

float advection_squares.cfl = 0.8

charge

int advection_squares.charge = 1

charge_to_mass

int advection_squares.charge_to_mass = charge/mass

density

float advection_squares.density = 1.0

detect_nonscalar

advection_squares.detect_nonscalar

distribution

warpy advection_squares.distribution

Initial value:

=  warpy.variable(name = 'distribution',
                              components = ['f'],
                              basis_array_set = sorder,
                              phase_space_basis_array_set = sorder,
                              v_space_num_elements = v_space_num_elements)

Create a variable for the fluid and one for the array Make components array component_names = np.zeros(number_velocity_components) for i in range(number_velocity_components): component_names[i] = 'fe' + str(i)

distribution_ic

warpy advection_squares.distribution_ic

Initial value:

=  warpy.functions.custom_vlasov(name = 'distribution_ic',
                                                       thermal_velocity = thermal_velocity,
                                                       density = density,
                                                       perturbation = perturbation)

Initial conditions function.

dt

int advection_squares.dt = 1e-5

Simulation (dg)

dt_controller

warpy advection_squares.dt_controller = warpy.dt_calc.stability_dt(dt)

dv

list advection_squares.dv = [0.25]

field

warpy advection_squares.field

Initial value:

=  warpy.variable(name = 'field',
                       components = ['Ex','Ey','Ez','Bx','By','Bz'],
                       basis_array_set = sorder)

fluid

warpy advection_squares.fluid

Initial value:

=  warpy.variable(name = 'fluid',
                       components = ['n','nvx','nvy','nvz'],
                       basis_array_set = sorder,
                       explodable=False)

gen_xdmf

advection_squares.gen_xdmf

Run Simulation ... 1 sim.run('kinetic_advection/apr18_2018',.

L

int advection_squares.L = 2 * np.pi

mass

int advection_squares.mass = 1

maxwell_ic

warpy advection_squares.maxwell_ic

Initial value:

=  warpy.functions.custom_maxwell('maxwell_ic',
                                            omega_p_tau=omega_p_norm,
                                            skin_depth_norm=skin_depth_norm,
                                            density=density,
                                            charge=charge,
                                            perturbation = perturbation)

mesh

warpy advection_squares.mesh

Initial value:

=  warpy.mesh.block(Bounds = [-L, L],
                        NumCells = [num_physical_elements],
                        NodeSets = ['Left', 'Right'],
                        NumLayers = 1,
                        PeriodicBoundaries = ['Left','Right'] if periodic_boundary_conditions else None,
                        basis_array_set = sorder)

Generate a mesh -> vlasov.

min_v

list advection_squares.min_v = [-5]

num_physical_elements

int advection_squares.num_physical_elements = 40

omega_p_norm

float advection_squares.omega_p_norm = 1.0

periodic_boundary_conditions

bool advection_squares.periodic_boundary_conditions = True

perturbation

float advection_squares.perturbation = 0.01

sim

warpy advection_squares.sim

Initial value:

=  warpy.dg_sim(name = 'test',                                                                           
                   meshes = [mesh],
                   initial_conditions = applicators,
                   temporal_solvers = [temporal_solver],
                   writers = [writer],
                   # writers = [writer_distribution, writer_field],
                   time = [0,t_final],
                   # time = [0,dt*timesteps],                   
                   dt_controller = dt_controller,
                   flexible_writeout = False,
                   write_steps = write_steps,
                   verbosity = 'info',
                   # num_partitions=4
)

skin_depth_norm

float advection_squares.skin_depth_norm = 1.0

sorder

str advection_squares.sorder = 'thirdOrder'

spatial_solver_kinetic

warpy advection_squares.spatial_solver_kinetic

Initial value:

=  warpy.spatial_solvers.dg_kinetic(name="dg_kinetic",
                                                  spatial_order = sorder,
                                                  phase_space_spatial_order = sorder,
                                                  v_space_num_elements = v_space_num_elements,
                                                  min_v = min_v,
                                                  dv = dv,
                                                  applications = apps_kinetic,
                                                  on_subdomains = ['all'],
                                          # phase_space_basis_primitive_id = "WMPRIMITIVE_KINETIC_SQUARE"
                                                  cfl = cfl)

Spatial solver.

spatial_solver_physical

warpy advection_squares.spatial_solver_physical

Initial value:

=  warpy.spatial_solvers.dg(name="dg_physical",
                                                   spatial_order=sorder,
                                                   applications=apps_physical,
                                                   cfl = cfl)

t_final

int advection_squares.t_final = 20

temporal_solver

warpy advection_squares.temporal_solver

Initial value:

=  warpy.host_actions.erk(name = 'rk',
                                         scheme = torder,
                                         # spatial_solvers = [spatial_solver_physical],
                                         spatial_solvers = [spatial_solver_physical,spatial_solver_kinetic],
                                         variable_adjusters = variable_adjusters)

Temporal solver.

thermal_velocity

int advection_squares.thermal_velocity = 1

timesteps

int advection_squares.timesteps = 2000

torder

str advection_squares.torder = 'RK4'

use_limiters

bool advection_squares.use_limiters = False

v_space_num_elements

list advection_squares.v_space_num_elements = [40]

variable_adjusters

list advection_squares.variable_adjusters = []

Variable adjusters.

velocity

list advection_squares.velocity = [1.0,0.0,0.0]

write_steps

int advection_squares.write_steps = 100

writer

warpy advection_squares.writer

Initial value:

=  warpy.host_actions.writer(name = 'writer',
                                   ReadVars = [distribution, field, fluid])

Variable writer.