sheath_flux_bc Namespace Reference

Variables
str	torder = 'SSPRK3'
str	sorder = 'thirdOrder'
float	cfl = 0.209
str	mesh_res = '32x192x32'
f	meshfile = f'sheath_mesh_{mesh_res}.inp'
warpy	mesh
float	density_min = 0.01
float	pressure_min = 0.01
float	gamma = 3.0
bool	use_limiter_mr = False
int	limiter_alpha_coefficient = 2.
bool	use_phmaxwell = False
float	phchi = 1.5
float	phgamma = phchi
argparse	parser = argparse.ArgumentParser(description='1d Sheath problem')
	type
	str
	nargs
	help
	default
argparse	args = parser.parse_args()
argparse	model = args.model
list	tf_sds = ['middle']
list	tf_vds = ['left','right']
list	kinetic_sds = ['left','right']
list	kinetic_vds = ['middle']
	else :
float	qe = 1.602177e-19
float	mp = 1.672622e-27
float	mu0 = 1.256637e-6
float	eps0 = 8.854187e-12
int	c_light = 1/(mu0*eps0)**.5
tuple	L_debye = (eps0*qe*1/(1e19*qe**2))**0.5
tuple	L = L_debye
float	ompt = 1.0
float	omct = 3.265e-5
float	c_tilde = ompt/omct
int	skin_depth_norm = 1/omct
float	omega_p_norm = ompt
float	n0 = mp*omct**2/(mu0*L**2*qe**2)
float	tau = ompt*L/(omct*c_light)
float	b0 = mp*c_light*omct**2/(qe*L*ompt)
float	e0 = b0**2/mu0
float	T0 = e0/(n0*qe)
float	Z_i = +1.0
float	Z_e = -1.0
float	mass_ratio = 1836.0
float	A_i = 1.0
float	A_e = A_i / mass_ratio
float	n_i = 1.0
float	n_e = 1.0
float	rho_i = A_i * n_i
float	rho_e = A_e * n_e
float	charge_to_mass_ion = Z_i/A_i
float	charge_to_mass_electron = Z_e/A_e
int	T_i = 10
int	T_e = 10
float	P_i = n_i * T_i
float	P_e = n_e * T_e
math	v_th_i = math.sqrt(P_i/A_i/n_i)
math	v_th_e = math.sqrt(P_e/A_e/n_e)
float	nu_p_tau_bgk = 1.0
float	vth_factor = +6.0
list	v_space_num_elements = [48]
list	min_v_ion = [-vth_factor*v_th_i]
list	dv_ion = [0.25* v_th_i]
list	min_v_electron = [-vth_factor*v_th_e]
list	dv_electron = [0.25* v_th_e]
list	fluid_comps = ['rho', 'px', 'py', 'pz', 'e']
list	field_comps = ['Ex', 'Ey', 'Ez', 'Bx', 'By', 'Bz']
warpy	ions
warpy	electrons
warpy	field
warpy	ion_maxwellian_distribution
warpy	electron_maxwellian_distribution
warpy	ion_positive_maxwellian_flux_moments
warpy	electron_positive_maxwellian_flux_moments
warpy	ion_negative_maxwellian_flux_moments
warpy	electron_negative_maxwellian_flux_moments
warpy	electron_distribution
warpy	ion_distribution
warpy	kinetic_electron_fluid
warpy	kinetic_ion_fluid
warpy	ion_positive_kinetic_flux_moments
warpy	electron_positive_kinetic_flux_moments
warpy	ion_negative_kinetic_flux_moments
warpy	electron_negative_kinetic_flux_moments
warpy	chi_metric_i
warpy	chi_metric_e
tuple	ic_fun_i
tuple	ic_fun_e
tuple	ic_fun_EM
warpy	electron_ic
warpy	ion_ic
warpy	ic_fun_i_va
warpy	ic_fun_e_va
warpy	ic_fun_EM_va
warpy	electron_ic_va
warpy	ion_ic_va
warpy	tf_ic_ha
warpy	field_ic_ha
warpy	distribution_ic_ha
list	ic_ha = []
list	bc_apps = []
list	values_in = [A_e*1e-4,0,0,0,1e-4/(gamma-1)]
list	electron_distribution_wall_bcs = []
list	ion_distribution_wall_bcs = []
list	maxwell_bcs = []
list	virtual_bc_apps_kinetic_ions = []
list	virtual_bc_apps_kinetic_electrons = []
list	applications_moments_ions = []
list	applications_moments_electrons = []
list	applications_2nd_moments_ions = []
list	applications_2nd_moments_electrons = []
list	applications_positive_maxwellian_flux_moments_ions = []
list	applications_negative_maxwellian_flux_moments_ions = []
list	applications_positive_maxwellian_flux_moments_electrons = []
list	applications_negative_maxwellian_flux_moments_electrons = []
list	applications_positive_kinetic_distribution_flux_moments_ions = []
list	applications_negative_kinetic_distribution_flux_moments_ions = []
list	applications_positive_kinetic_distribution_flux_moments_electrons = []
list	applications_negative_kinetic_distribution_flux_moments_electrons = []
list	applications_maxwellian_metric_ions = []
list	applications_maxwellian_metric_electrons = []
list	limiter_apps_electron = []
list	limiter_apps_ion = []
list	variable_adjusters_tf = []
list	variable_adjusters_kinetic = []
list	kinetic_to_tf_va = []
list	tf_to_kinetic_va_ions = []
list	tf_to_kinetic_va_electrons = []
warpy	ion_timestep_start_moment_taker
	add these same moment takers that can be done at the beginning of each timestep before writeout
warpy	electron_timestep_start_moment_taker
warpy	ion_timestep_start_second_moment_taker
warpy	electron_timestep_start_second_moment_taker
warpy	ion_timestep_start_chi_metric_moment_taker
warpy	electron_timestep_start_chi_metric_moment_taker
list	extra_timestep_start_writer = []
warpy	moment_takers_timestep_start_ha
warpy	fluid_ions_to_maxwellian_function
warpy	fluid_electrons_to_maxwellian_function
list	maxwellian_evaluation_timestep_start_va = []
	add these maxwellian conversions that can be done at the beginning of each timestep before writeout
warpy	maxwellian_evaluation_timestep_start_ha
list	solver_apps_tf = []
list	solver_apps_maxwell_flux = []
list	solver_apps_maxwell_tf_fluid_source = []
list	solver_apps_maxwell_kinetic_fluid_source = []
list	apps_kinetic_ions = []
list	apps_kinetic_electrons = []
warpy	spatial_solver_tf
	Spatial solver.
warpy	spatial_solver_kinetic_ions
warpy	spatial_solver_kinetic_electrons
warpy	spatial_solver_kinetic_field
list	ss_s = [spatial_solver_tf]
list	va_s = variable_adjusters_tf
warpy	time_integrator = warpy.host_actions.erk(name="ti", scheme=torder, spatial_solvers=ss_s, variable_adjusters=va_s)
list	write_vars = [ions, electrons, field]
warpy	writer
int	dt = 1e-4
	Simulation (dg) dt = 1e-6.
tuple	ompe = (1e19*qe**2/(eps0*A_e*mp))**0.5
float	t_final = 20.0/ompe/tau
warpy	dt_controller = warpy.dt_calc.stability_dt(dt)
int	write_steps = 100
datetime	now = datetime.datetime.now().strftime("%Y_%m_%d")
f	sim_name = f'sheath_fm_{v_space_num_elements[0]}_{mesh_res}_{model}'
warpy	config_args = warpy.load_configs()
warpy	case_loc = config_args['test_rundir'](f'hybrid/sheath/{now}', '')
f	sim_param
warpy	sim
	gen_xdmf
	Run Simulation ...
	detect_nonscalar

Variable Documentation

A_e

float sheath_flux_bc.A_e = A_i / mass_ratio

A_i

float sheath_flux_bc.A_i = 1.0

applications_2nd_moments_electrons

list sheath_flux_bc.applications_2nd_moments_electrons = []

applications_2nd_moments_ions

list sheath_flux_bc.applications_2nd_moments_ions = []

applications_maxwellian_metric_electrons

list sheath_flux_bc.applications_maxwellian_metric_electrons = []

applications_maxwellian_metric_ions

list sheath_flux_bc.applications_maxwellian_metric_ions = []

applications_moments_electrons

list sheath_flux_bc.applications_moments_electrons = []

applications_moments_ions

list sheath_flux_bc.applications_moments_ions = []

applications_negative_kinetic_distribution_flux_moments_electrons

list sheath_flux_bc.applications_negative_kinetic_distribution_flux_moments_electrons = []

applications_negative_kinetic_distribution_flux_moments_ions

list sheath_flux_bc.applications_negative_kinetic_distribution_flux_moments_ions = []

applications_negative_maxwellian_flux_moments_electrons

list sheath_flux_bc.applications_negative_maxwellian_flux_moments_electrons = []

applications_negative_maxwellian_flux_moments_ions

list sheath_flux_bc.applications_negative_maxwellian_flux_moments_ions = []

applications_positive_kinetic_distribution_flux_moments_electrons

list sheath_flux_bc.applications_positive_kinetic_distribution_flux_moments_electrons = []

applications_positive_kinetic_distribution_flux_moments_ions

list sheath_flux_bc.applications_positive_kinetic_distribution_flux_moments_ions = []

applications_positive_maxwellian_flux_moments_electrons

list sheath_flux_bc.applications_positive_maxwellian_flux_moments_electrons = []

applications_positive_maxwellian_flux_moments_ions

list sheath_flux_bc.applications_positive_maxwellian_flux_moments_ions = []

apps_kinetic_electrons

list sheath_flux_bc.apps_kinetic_electrons = []

apps_kinetic_ions

list sheath_flux_bc.apps_kinetic_ions = []

args

argparse sheath_flux_bc.args = parser.parse_args()

b0

float sheath_flux_bc.b0 = mp*c_light*omct**2/(qe*L*ompt)

bc_apps

list sheath_flux_bc.bc_apps = []

c_light

int sheath_flux_bc.c_light = 1/(mu0*eps0)**.5

c_tilde

float sheath_flux_bc.c_tilde = ompt/omct

case_loc

warpy sheath_flux_bc.case_loc = config_args['test_rundir'](f'hybrid/sheath/{now}', '')

cfl

float sheath_flux_bc.cfl = 0.209

charge_to_mass_electron

float sheath_flux_bc.charge_to_mass_electron = Z_e/A_e

charge_to_mass_ion

float sheath_flux_bc.charge_to_mass_ion = Z_i/A_i

chi_metric_e

warpy sheath_flux_bc.chi_metric_e

Initial value:

=  warpy.variable(name = 'chi_metric_e',
                              components = ['chi'],
                              basis_array_set = sorder,
                              subdomains = kinetic_sds,
                              virtual_subdomains=kinetic_vds,
                              explodable=False)

chi_metric_i

warpy sheath_flux_bc.chi_metric_i

Initial value:

=  warpy.variable(name = 'chi_metric_i',
                              components = ['chi'],
                              basis_array_set = sorder,
                              subdomains = kinetic_sds,
                              virtual_subdomains=kinetic_vds,
                              explodable=False)

config_args

warpy sheath_flux_bc.config_args = warpy.load_configs()

default

sheath_flux_bc.default

density_min

float sheath_flux_bc.density_min = 0.01

detect_nonscalar

sheath_flux_bc.detect_nonscalar

distribution_ic_ha

warpy sheath_flux_bc.distribution_ic_ha

Initial value:

=  warpy.host_actions.va_runner("distribution_ic_ha",
                                                  variable_adjusters=[electron_ic_va, ion_ic_va])

dt

int sheath_flux_bc.dt = 1e-4

Simulation (dg) dt = 1e-6.

dt_controller

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

dv_electron

list sheath_flux_bc.dv_electron = [0.25* v_th_e]

dv_ion

list sheath_flux_bc.dv_ion = [0.25* v_th_i]

e0

float sheath_flux_bc.e0 = b0**2/mu0

electron_distribution

warpy sheath_flux_bc.electron_distribution

Initial value:

=  warpy.variable(name = 'electron_distribution',
                              components = ['f'],
                              basis_array_set = sorder,
                              phase_space_basis_array_set = sorder,
                              v_space_num_elements = v_space_num_elements,
                              subdomains=kinetic_sds,
                                       virtual_subdomains=kinetic_vds)

electron_distribution_wall_bcs

list sheath_flux_bc.electron_distribution_wall_bcs = []

electron_ic

warpy sheath_flux_bc.electron_ic

Initial value:

=  warpy.apps.functions.kinetics.maxwellian(name='electron_ic',
                                        distribution=electron_distribution,
                                         mass=A_e,
                                         density=n_e*A_e,
                                         velocity=[0,0,0],
                                         pressure=P_e)

electron_ic_va

warpy sheath_flux_bc.electron_ic_va

Initial value:

=  warpy.variable_adjusters.function_evaluation.phase_space_function_evaluator(name="electron_ic_va",
                                                                                             priority=0,
                                                                                             spatial_order=sorder,
                                                                                             phase_space_spatial_order=sorder,
                                                                                             v_space_num_elements = v_space_num_elements,
                                                                                             min_v = min_v_electron,
                                                                                             dv = dv_electron,
                                                                                             on_subdomains=kinetic_sds,
                                                                                             applications=[electron_ic])

electron_maxwellian_distribution

warpy sheath_flux_bc.electron_maxwellian_distribution

Initial value:

=  warpy.variable(name = 'electron_maxwellian_distribution',
                              components = ['f'],
                              basis_array_set = sorder,
                              phase_space_basis_array_set = sorder,
                              v_space_num_elements = v_space_num_elements,
                              subdomains=tf_sds,
                                         virtual_subdomains=tf_vds,
                                         explodable=False)

electron_negative_kinetic_flux_moments

warpy sheath_flux_bc.electron_negative_kinetic_flux_moments

Initial value:

=  warpy.variable(name = 'electron_negative_kinetic_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains =kinetic_sds,
                                                      virtual_subdomains = kinetic_vds,
                                                      explodable = False)

electron_negative_maxwellian_flux_moments

warpy sheath_flux_bc.electron_negative_maxwellian_flux_moments

Initial value:

=  warpy.variable(name = 'electron_negative_maxwellian_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains = tf_sds,
                                                      virtual_subdomains = tf_vds,
                                                      explodable = False)

electron_positive_kinetic_flux_moments

warpy sheath_flux_bc.electron_positive_kinetic_flux_moments

Initial value:

=  warpy.variable(name = 'electron_positive_kinetic_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains =kinetic_sds,
                                                      virtual_subdomains = kinetic_vds,
                                                      explodable = False)

electron_positive_maxwellian_flux_moments

warpy sheath_flux_bc.electron_positive_maxwellian_flux_moments

Initial value:

=  warpy.variable(name = 'electron_positive_maxwellian_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains = tf_sds,
                                                      virtual_subdomains = tf_vds,
                                                      explodable = False)

electron_timestep_start_chi_metric_moment_taker

warpy sheath_flux_bc.electron_timestep_start_chi_metric_moment_taker

Initial value:

=  warpy.variable_adjusters.moment_takers.velocity_space_moment_taker(name = 'moment_taker_chi_electrons_timestep_start',
                                                                                                                priority = 3,
                                                                                                                spatial_order=sorder,
                                                                                                                phase_space_basis_array_set=sorder,
                                                                                                                v_space_num_elements = v_space_num_elements,
                                                                                                                min_v = min_v_electron,
                                                                                                                dv = dv_electron,
                                                                                                                applications = applications_maxwellian_metric_electrons,
                                                                                                                on_subdomains = kinetic_sds
)

electron_timestep_start_moment_taker

warpy sheath_flux_bc.electron_timestep_start_moment_taker

Initial value:

=  warpy.variable_adjusters.moment_takers.velocity_space_moment_taker(name='moment_taker_electrons_timestep_start',
                                                priority=1,
                                                spatial_order=sorder,
                                                phase_space_basis_array_set = sorder,
                                                v_space_num_elements = v_space_num_elements,
                                                min_v = min_v_electron,
                                                dv = dv_electron,
                                                                                                     applications=applications_moments_electrons,
                                                                                                     on_subdomains=kinetic_sds                                                                                                     
)

electron_timestep_start_second_moment_taker

warpy sheath_flux_bc.electron_timestep_start_second_moment_taker

Initial value:

=  warpy.variable_adjusters.moment_takers.velocity_space_moment_taker(name='second_moment_taker_electrons_timestep_start',
                                                priority=2,
                                                spatial_order=sorder,
                                                phase_space_basis_array_set = sorder,
                                                v_space_num_elements = v_space_num_elements,
                                                min_v = min_v_electron,
                                                dv = dv_electron,
                                                                                                     applications=applications_2nd_moments_electrons,
                                                                                                     on_subdomains=kinetic_sds
)

electrons

warpy sheath_flux_bc.electrons

Initial value:

=  warpy.variable(name='electrons',
                           components=fluid_comps,
                           basis_array_set=sorder,
                           subdomains=tf_sds,
                           virtual_subdomains=tf_vds)

else

sheath_flux_bc.else :

eps0

float sheath_flux_bc.eps0 = 8.854187e-12

extra_timestep_start_writer

list sheath_flux_bc.extra_timestep_start_writer = []

field

warpy sheath_flux_bc.field

Initial value:

=  warpy.variable(name='field',
                       components=field_comps,
                       basis_array_set=sorder,
                       subdomains=['left','middle','right'],
                       virtual_subdomains=None
                       )

field_comps

list sheath_flux_bc.field_comps = ['Ex', 'Ey', 'Ez', 'Bx', 'By', 'Bz']

field_ic_ha

warpy sheath_flux_bc.field_ic_ha

Initial value:

=  warpy.host_actions.va_runner(name="field_ic_ha",
                                           variable_adjusters=[ic_fun_EM_va])

fluid_comps

list sheath_flux_bc.fluid_comps = ['rho', 'px', 'py', 'pz', 'e']

fluid_electrons_to_maxwellian_function

warpy sheath_flux_bc.fluid_electrons_to_maxwellian_function

Initial value:

=  warpy.apps.functions.five_moment_to_kinetic(name='fluid_electrons_to_maxwellian',
                                                                                mass=A_e,
                                                                                gamma=gamma,
                                                                                fluid=electrons,
                                                                                distribution = electron_maxwellian_distribution)

fluid_ions_to_maxwellian_function

warpy sheath_flux_bc.fluid_ions_to_maxwellian_function

Initial value:

=  warpy.apps.functions.five_moment_to_kinetic(name='fluid_ions_to_maxwellian',
                                                                                mass=A_i,
                                                                                gamma=gamma,
                                                                                fluid=ions,
                                                                                distribution = ion_maxwellian_distribution)

gamma

float sheath_flux_bc.gamma = 3.0

gen_xdmf

sheath_flux_bc.gen_xdmf

Run Simulation ...

help

sheath_flux_bc.help

ic_fun_e

tuple sheath_flux_bc.ic_fun_e

Initial value:

=  (
  warpy.apps.functions.five_moment.ein_ic_5moment(name='ic_e',
                                 fluid=electrons,
                                 ic_type=2,
                                 var_type=1,
                                 params=[gamma, A_e, n_e, T_e]))

ic_fun_e_va

warpy sheath_flux_bc.ic_fun_e_va

Initial value:

=  warpy.variable_adjusters.function_evaluation.function_evaluator(name='ic_fun_e_va',
                                                                              priority=0,
                                                                              spatial_order=sorder,
                                                                              on_subdomains=tf_sds,
                                                                              applications=[ic_fun_e])

ic_fun_EM

tuple sheath_flux_bc.ic_fun_EM

Initial value:

=  (
  warpy.apps.functions.maxwell.ein_ic_EM_5moment(name='ic_EM',
                                    fields=field,
                                    fields_components=['Ex', 'Ey', 'Ez', 'Bx', 'By', 'Bz'],
                                    ic_type=1))

ic_fun_EM_va

warpy sheath_flux_bc.ic_fun_EM_va

Initial value:

=  warpy.variable_adjusters.function_evaluation.function_evaluator(name='ic_fun_EM_va',
                                                                              priority=0,
                                                                              spatial_order=sorder,
                                                                              on_subdomains=['all'],
                                                                              applications=[ic_fun_EM])

ic_fun_i

tuple sheath_flux_bc.ic_fun_i

Initial value:

=  (
  warpy.apps.functions.five_moment.ein_ic_5moment(name='ic_i',
                                fluid=ions,
                                 ic_type=2,
                                 var_type=2,
                                 params = [gamma, A_i, n_i, T_i]))

ic_fun_i_va

warpy sheath_flux_bc.ic_fun_i_va

Initial value:

=  warpy.variable_adjusters.function_evaluation.function_evaluator(name='ic_fun_i_va',
                                                                              priority=0,
                                                                              spatial_order=sorder,
                                                                              on_subdomains=tf_sds,
                                                                              applications=[ic_fun_i])

ic_ha

list sheath_flux_bc.ic_ha = []

ion_distribution

warpy sheath_flux_bc.ion_distribution

Initial value:

=  warpy.variable(name = 'ion_distribution',
                              components = ['f'],
                              basis_array_set = sorder,
                              phase_space_basis_array_set = sorder,
                              v_space_num_elements = v_space_num_elements,
                              subdomains=kinetic_sds,
                                  virtual_subdomains=kinetic_vds)

ion_distribution_wall_bcs

list sheath_flux_bc.ion_distribution_wall_bcs = []

ion_ic

warpy sheath_flux_bc.ion_ic

Initial value:

=  warpy.apps.functions.kinetics.maxwellian(name='ion_ic',
                                        distribution=ion_distribution,
                                         mass=A_i,
                                         density=n_i*A_i,
                                         velocity=[0,0,0],
                                         pressure=P_i)

ion_ic_va

warpy sheath_flux_bc.ion_ic_va

Initial value:

=  warpy.variable_adjusters.function_evaluation.phase_space_function_evaluator(name="ion_ic_va",
                                                                                             priority=0,
                                                                                             spatial_order=sorder,
                                                                                             phase_space_spatial_order=sorder,
                                                                                             v_space_num_elements = v_space_num_elements,
                                                                                             min_v = min_v_ion,
                                                                                             dv = dv_ion,
                                                                                             on_subdomains=kinetic_sds,
                                                                                             applications=[ion_ic])

ion_maxwellian_distribution

warpy sheath_flux_bc.ion_maxwellian_distribution

Initial value:

=  warpy.variable(name = 'ion_maxwellian_distribution',
                              components = ['f'],
                              basis_array_set = sorder,
                              phase_space_basis_array_set = sorder,
                              v_space_num_elements = v_space_num_elements,
                              subdomains=tf_sds,
                                         virtual_subdomains=tf_vds,
                                         explodable=False)

ion_negative_kinetic_flux_moments

warpy sheath_flux_bc.ion_negative_kinetic_flux_moments

Initial value:

=  warpy.variable(name = 'ion_negative_kinetic_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains =kinetic_sds,
                                                      virtual_subdomains = kinetic_vds,
                                                      explodable = False)

ion_negative_maxwellian_flux_moments

warpy sheath_flux_bc.ion_negative_maxwellian_flux_moments

Initial value:

=  warpy.variable(name = 'ion_negative_maxwellian_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains = tf_sds,
                                                      virtual_subdomains = tf_vds,
                                                      explodable = False)

ion_positive_kinetic_flux_moments

warpy sheath_flux_bc.ion_positive_kinetic_flux_moments

Initial value:

=  warpy.variable(name = 'ion_positive_kinetic_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains =kinetic_sds,
                                                      virtual_subdomains = kinetic_vds,
                                                      explodable = False)

ion_positive_maxwellian_flux_moments

warpy sheath_flux_bc.ion_positive_maxwellian_flux_moments

Initial value:

=  warpy.variable(name = 'ion_positive_maxwellian_flux_moments',
                                                      components = ['nvx', 'nvy', 'nvz',
                                                                    'pfxx', 'pfxy', 'pfxz', 'pfyy', 'pfyz', 'pfzz',
                                                                    'efx', 'efy', 'efz'],
                                                      basis_array_set = sorder,
                                                      subdomains = tf_sds,
                                                      virtual_subdomains = tf_vds,
                                                      explodable = False)

ion_timestep_start_chi_metric_moment_taker

warpy sheath_flux_bc.ion_timestep_start_chi_metric_moment_taker

Initial value:

=  warpy.variable_adjusters.moment_takers.velocity_space_moment_taker(name = 'moment_taker_chi_ions_timestep_start',
                                                                                                                priority = 3,
                                                                                                                spatial_order=sorder,
                                                                                                                phase_space_basis_array_set=sorder,
                                                                                                                v_space_num_elements = v_space_num_elements,
                                                                                                                min_v = min_v_ion,
                                                                                                                dv = dv_ion,
                                                                                                                applications = applications_maxwellian_metric_ions,
                                                                                                                on_subdomains = kinetic_sds
)

ion_timestep_start_moment_taker

warpy sheath_flux_bc.ion_timestep_start_moment_taker

Initial value:

=  warpy.variable_adjusters.moment_takers.velocity_space_moment_taker(name='moment_taker_ions_timestep_start',
                                                priority=1,
                                                spatial_order=sorder,
                                                phase_space_basis_array_set = sorder,
                                                v_space_num_elements = v_space_num_elements,
                                                min_v = min_v_ion,
                                                dv = dv_ion,
                                                applications=applications_moments_ions,
                                                    on_subdomains=kinetic_sds
)

add these same moment takers that can be done at the beginning of each timestep before writeout

ion_timestep_start_second_moment_taker

warpy sheath_flux_bc.ion_timestep_start_second_moment_taker

Initial value:

=  warpy.variable_adjusters.moment_takers.velocity_space_moment_taker(name='second_moment_taker_ions_timestep_start',
                                                priority=2,
                                                spatial_order=sorder,
                                                phase_space_basis_array_set = sorder,
                                                v_space_num_elements = v_space_num_elements,
                                                min_v = min_v_ion,
                                                dv = dv_ion,
                                                                                                     applications=applications_2nd_moments_ions,
                                                                                                     on_subdomains=kinetic_sds
)

ions

warpy sheath_flux_bc.ions

Initial value:

=  warpy.variable(name='ions',
                      components=fluid_comps,
                      basis_array_set=sorder,
                      subdomains=tf_sds,
                      virtual_subdomains=tf_vds)

kinetic_electron_fluid

warpy sheath_flux_bc.kinetic_electron_fluid

Initial value:

=  warpy.variable(name = 'kinetic_electron_fluid',
                       components = ['n','nvx','nvy','nvz','nT'],
                       basis_array_set = sorder,
                       subdomains=kinetic_sds,
                       virtual_subdomains=kinetic_vds,                               
                                        explodable=False)

kinetic_ion_fluid

warpy sheath_flux_bc.kinetic_ion_fluid

Initial value:

=  warpy.variable(name = 'kinetic_ion_fluid',
                       components = ['n','nvx','nvy','nvz','nT'],
                       basis_array_set = sorder,
                       subdomains=kinetic_sds,
                       virtual_subdomains=kinetic_vds,                               
                                   explodable=False)

kinetic_sds

list sheath_flux_bc.kinetic_sds = ['left','right']

kinetic_to_tf_va

list sheath_flux_bc.kinetic_to_tf_va = []

kinetic_vds

None sheath_flux_bc.kinetic_vds = ['middle']

L

tuple sheath_flux_bc.L = L_debye

L_debye

tuple sheath_flux_bc.L_debye = (eps0*qe*1/(1e19*qe**2))**0.5

limiter_alpha_coefficient

int sheath_flux_bc.limiter_alpha_coefficient = 2.

limiter_apps_electron

list sheath_flux_bc.limiter_apps_electron = []

limiter_apps_ion

list sheath_flux_bc.limiter_apps_ion = []

mass_ratio

float sheath_flux_bc.mass_ratio = 1836.0

maxwell_bcs

list sheath_flux_bc.maxwell_bcs = []

maxwellian_evaluation_timestep_start_ha

warpy sheath_flux_bc.maxwellian_evaluation_timestep_start_ha

Initial value:

=  warpy.host_actions.va_runner(name='maxwellian_evaluation_timestep_start_ha',
                                                                           variable_adjusters = maxwellian_evaluation_timestep_start_va)

maxwellian_evaluation_timestep_start_va

list sheath_flux_bc.maxwellian_evaluation_timestep_start_va = []

add these maxwellian conversions that can be done at the beginning of each timestep before writeout

mesh

warpy sheath_flux_bc.mesh

Initial value:

=  warpy.mesh.arbitrary(meshfile,
                            NumLayers=1,
                            basis_array_set=sorder)

mesh_res

str sheath_flux_bc.mesh_res = '32x192x32'

meshfile

f sheath_flux_bc.meshfile = f'sheath_mesh_{mesh_res}.inp'

min_v_electron

list sheath_flux_bc.min_v_electron = [-vth_factor*v_th_e]

min_v_ion

list sheath_flux_bc.min_v_ion = [-vth_factor*v_th_i]

model

argparse sheath_flux_bc.model = args.model

moment_takers_timestep_start_ha

warpy sheath_flux_bc.moment_takers_timestep_start_ha

Initial value:

=  warpy.host_actions.va_runner(name='moment_takers_timestep_start_ha',
                                 variable_adjusters = [ion_timestep_start_moment_taker,
                                                       electron_timestep_start_moment_taker,
                                                       ion_timestep_start_second_moment_taker,
                                                       electron_timestep_start_second_moment_taker,
                                                       ion_timestep_start_chi_metric_moment_taker,
                                                       electron_timestep_start_chi_metric_moment_taker])

mp

float sheath_flux_bc.mp = 1.672622e-27

mu0

float sheath_flux_bc.mu0 = 1.256637e-6

n0

float sheath_flux_bc.n0 = mp*omct**2/(mu0*L**2*qe**2)

n_e

float sheath_flux_bc.n_e = 1.0

n_i

float sheath_flux_bc.n_i = 1.0

nargs

sheath_flux_bc.nargs

now

datetime sheath_flux_bc.now = datetime.datetime.now().strftime("%Y_%m_%d")

nu_p_tau_bgk

float sheath_flux_bc.nu_p_tau_bgk = 1.0

omct

float sheath_flux_bc.omct = 3.265e-5

omega_p_norm

float sheath_flux_bc.omega_p_norm = ompt

ompe

tuple sheath_flux_bc.ompe = (1e19*qe**2/(eps0*A_e*mp))**0.5

ompt

float sheath_flux_bc.ompt = 1.0

P_e

float sheath_flux_bc.P_e = n_e * T_e

P_i

float sheath_flux_bc.P_i = n_i * T_i

parser

argparse sheath_flux_bc.parser = argparse.ArgumentParser(description='1d Sheath problem')

phchi

float sheath_flux_bc.phchi = 1.5

phgamma

float sheath_flux_bc.phgamma = phchi

pressure_min

float sheath_flux_bc.pressure_min = 0.01

qe

float sheath_flux_bc.qe = 1.602177e-19

rho_e

float sheath_flux_bc.rho_e = A_e * n_e

rho_i

float sheath_flux_bc.rho_i = A_i * n_i

sim

warpy sheath_flux_bc.sim

Initial value:

=  warpy.dg_sim(name = sim_name,
                   meshes = [mesh],
                   initial_conditions = ic_ha,
                   temporal_solvers = [time_integrator],
                   writers = extra_timestep_start_writer + [writer],
                   time = [0,t_final],
                   # time = [0,dt*write_steps],
                   # time = [0,t_final/1000],                                      
                   dt_controller = dt_controller,
                   flexible_writeout = False,
                   write_steps = write_steps,
                   verbosity = 'info',
                   # num_partitions=4
)

sim_name

f sheath_flux_bc.sim_name = f'sheath_fm_{v_space_num_elements[0]}_{mesh_res}_{model}'

sim_param

sheath_flux_bc.sim_param

Initial value:

=  \
f'''case_loc={case_loc}
specific_case={sim_name}
start_frame=0
end_frame={write_steps}
domain=left
ion_variable={ion_distribution.name()}
electron_variable={electron_distribution.name()}
v_space_num_vx={v_space_num_elements[0]}
basis_name={sorder}
mass_ion={A_i}
mass_ratio={mass_ratio}
temperature_ion={T_i}
temperature_electron={T_e}
min_vxi_factor={-vth_factor}
max_vxi_factor={vth_factor}
min_vxe_factor={-vth_factor}
max_vxe_factor={vth_factor}
'''

skin_depth_norm

int sheath_flux_bc.skin_depth_norm = 1/omct

solver_apps_maxwell_flux

list sheath_flux_bc.solver_apps_maxwell_flux = []

solver_apps_maxwell_kinetic_fluid_source

list sheath_flux_bc.solver_apps_maxwell_kinetic_fluid_source = []

solver_apps_maxwell_tf_fluid_source

list sheath_flux_bc.solver_apps_maxwell_tf_fluid_source = []

solver_apps_tf

list sheath_flux_bc.solver_apps_tf = []

sorder

str sheath_flux_bc.sorder = 'thirdOrder'

spatial_solver_kinetic_electrons

warpy sheath_flux_bc.spatial_solver_kinetic_electrons

Initial value:

=  warpy.spatial_solvers.dg_kinetic(name="dg_kinetic_electrons",
                                                  spatial_order = sorder,
                                                  phase_space_spatial_order = sorder,
                                                  v_space_num_elements = v_space_num_elements,
                                                  min_v = min_v_electron,
                                                  dv = dv_electron,
                                                  applications = apps_kinetic_electrons,
                                                  on_subdomains = kinetic_sds,
                                                  cfl = cfl)

spatial_solver_kinetic_field

warpy sheath_flux_bc.spatial_solver_kinetic_field

Initial value:

=  warpy.spatial_solvers.dg(name="dg_kinetic_field",
                                                   spatial_order=sorder,
                                                   applications=solver_apps_maxwell_flux + solver_apps_maxwell_kinetic_fluid_source,
                                                        cfl = cfl,
                                                        on_subdomains=kinetic_sds)

spatial_solver_kinetic_ions

warpy sheath_flux_bc.spatial_solver_kinetic_ions

Initial value:

=  warpy.spatial_solvers.dg_kinetic(name="dg_kinetic_ions",
                                                  spatial_order = sorder,
                                                  phase_space_spatial_order = sorder,
                                                  v_space_num_elements = v_space_num_elements,
                                                  min_v = min_v_ion,
                                                  dv = dv_ion,
                                                  applications = apps_kinetic_ions,
                                                  on_subdomains = kinetic_sds,
                                                  cfl = cfl)

spatial_solver_tf

warpy sheath_flux_bc.spatial_solver_tf

Initial value:

=  warpy.spatial_solvers.dg(name="dg_tf",
                                             spatial_order=sorder,
                                             applications=solver_apps_tf + solver_apps_maxwell_flux + solver_apps_maxwell_tf_fluid_source,
                                             cfl = cfl,
                                             on_subdomains=tf_sds)

Spatial solver.

ss_s

list sheath_flux_bc.ss_s = [spatial_solver_tf]

str

sheath_flux_bc.str

T0

float sheath_flux_bc.T0 = e0/(n0*qe)

T_e

int sheath_flux_bc.T_e = 10

t_final

float sheath_flux_bc.t_final = 20.0/ompe/tau

T_i

int sheath_flux_bc.T_i = 10

tau

float sheath_flux_bc.tau = ompt*L/(omct*c_light)

tf_ic_ha

warpy sheath_flux_bc.tf_ic_ha

Initial value:

=  warpy.host_actions.va_runner(name="tf_ic_ha",
                                        variable_adjusters=[ic_fun_i_va, ic_fun_e_va])

tf_sds

None sheath_flux_bc.tf_sds = ['middle']

tf_to_kinetic_va_electrons

list sheath_flux_bc.tf_to_kinetic_va_electrons = []

tf_to_kinetic_va_ions

list sheath_flux_bc.tf_to_kinetic_va_ions = []

tf_vds

None sheath_flux_bc.tf_vds = ['left','right']

time_integrator

warpy sheath_flux_bc.time_integrator = warpy.host_actions.erk(name="ti", scheme=torder, spatial_solvers=ss_s, variable_adjusters=va_s)

torder

str sheath_flux_bc.torder = 'SSPRK3'

type

sheath_flux_bc.type

use_limiter_mr

bool sheath_flux_bc.use_limiter_mr = False

use_phmaxwell

bool sheath_flux_bc.use_phmaxwell = False

v_space_num_elements

list sheath_flux_bc.v_space_num_elements = [48]

v_th_e

math sheath_flux_bc.v_th_e = math.sqrt(P_e/A_e/n_e)

v_th_i

math sheath_flux_bc.v_th_i = math.sqrt(P_i/A_i/n_i)

va_s

list sheath_flux_bc.va_s = variable_adjusters_tf

values_in

list sheath_flux_bc.values_in = [A_e*1e-4,0,0,0,1e-4/(gamma-1)]

variable_adjusters_kinetic

list sheath_flux_bc.variable_adjusters_kinetic = []

variable_adjusters_tf

list sheath_flux_bc.variable_adjusters_tf = []

virtual_bc_apps_kinetic_electrons

list sheath_flux_bc.virtual_bc_apps_kinetic_electrons = []

virtual_bc_apps_kinetic_ions

list sheath_flux_bc.virtual_bc_apps_kinetic_ions = []

vth_factor

float sheath_flux_bc.vth_factor = +6.0

write_steps

int sheath_flux_bc.write_steps = 100

write_vars

list sheath_flux_bc.write_vars = [ions, electrons, field]

writer

warpy sheath_flux_bc.writer

Initial value:

=  warpy.host_actions.writer(name='writer',
                                   ReadVars=write_vars)

Z_e

float sheath_flux_bc.Z_e = -1.0

Z_i

float sheath_flux_bc.Z_i = +1.0