WarpX Class Reference

#include <WarpX.H>

Inheritance diagram for WarpX:

Public Member Functions
	~WarpX () override
	WarpX (WarpX const &)=delete
WarpX &	operator= (WarpX const &)=delete
	WarpX (WarpX &&)=default
WarpX &	operator= (WarpX &&)=default
int	Verbose () const
void	InitData ()
void	Evolve (int numsteps=-1)
void	EvolveImplicitPicardInit (int lev)
void	SaveParticlesAtImplicitStepStart (WarpXParticleContainer &pc, int lev)
void	FinishImplicitParticleUpdate (WarpXParticleContainer &pc, int lev)
void	FinishImplicitFieldUpdate (amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &Efield_fp, amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &Efield_n)
MultiParticleContainer &	GetPartContainer ()
MultiFluidContainer &	GetFluidContainer ()
MacroscopicProperties &	GetMacroscopicProperties ()
HybridPICModel &	GetHybridPICModel ()
HybridPICModel *	get_pointer_HybridPICModel () const
MultiDiagnostics &	GetMultiDiags ()
ParticleBoundaryBuffer &	GetParticleBoundaryBuffer ()
std::string	GetAuthors () const
	If an authors' string is specified in the inputfile, this method returns that string. Otherwise, it returns an empty string. More...
bool	isFieldInitialized (FieldType field_type, int lev, int direction=0) const
	Check if a field is initialized. More...
amrex::MultiFab *	getFieldPointer (FieldType field_type, int lev, int direction=0) const
	Get a pointer to the field data. More...
std::array< const amrex::MultiFab *const, 3 >	getFieldPointerArray (FieldType field_type, int lev) const
	For vector fields, get an array of three pointers to the field data. More...
const amrex::MultiFab &	getField (FieldType field_type, int lev, int direction=0) const
	Get a constant reference to the field data. More...
bool	DoPML () const
bool	DoFluidSpecies () const
const PML_RZ *	getPMLRZ ()
std::vector< bool >	getPMLdirections () const
void	setLoadBalanceEfficiency (int lev, amrex::Real efficiency)
amrex::Real	getLoadBalanceEfficiency (int lev)
void	applyMirrors (amrex::Real time)
void	ComputeDt ()
void	PrintMainPICparameters ()
void	WriteUsedInputsFile () const
void	PrintDtDxDyDz ()
void	ComputeMaxStep ()
	Compute the last time step of the simulation Calls computeMaxStepBoostAccelerator() if required. More...
void	computeMaxStepBoostAccelerator ()
int	MoveWindow (int step, bool move_j)
	Move the moving window. More...
void	ShiftGalileanBoundary ()
	This function shifts the boundary of the grid by 'm_v_galilean*dt'. In doding so, only positions attributes are changed while fields remain unchanged. More...
void	UpdateInjectionPosition (amrex::Real dt)
	Update injection position for continuous injection of particles and lasers (loops over species and lasers). More...
void	ResetProbDomain (const amrex::RealBox &rb)
void	EvolveE (amrex::Real dt)
void	EvolveE (int lev, amrex::Real dt)
void	EvolveB (amrex::Real dt, DtType dt_type)
void	EvolveB (int lev, amrex::Real dt, DtType dt_type)
void	EvolveF (amrex::Real dt, DtType dt_type)
void	EvolveF (int lev, amrex::Real dt, DtType dt_type)
void	EvolveG (amrex::Real dt, DtType dt_type)
void	EvolveG (int lev, amrex::Real dt, DtType dt_type)
void	EvolveB (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type)
void	EvolveE (int lev, PatchType patch_type, amrex::Real dt)
void	EvolveF (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type)
void	EvolveG (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type)
void	MacroscopicEvolveE (amrex::Real dt)
void	MacroscopicEvolveE (int lev, amrex::Real dt)
void	MacroscopicEvolveE (int lev, PatchType patch_type, amrex::Real dt)
void	HybridPICEvolveFields ()
	Hybrid-PIC field evolve function. This function contains the logic involved in evolving the electric and magnetic fields in the hybrid PIC algorithm. More...
void	HybridPICDepositInitialRhoAndJ ()
	Hybrid-PIC initial deposition function. The hybrid-PIC algorithm uses the charge and current density from both the current and previous step when updating the fields. This function deposits the initial ion charge and current (before the first particle push), to be used in the HybridPICEvolveFields() function. More...
void	Hybrid_QED_Push (amrex::Vector< amrex::Real > dt)
void	Hybrid_QED_Push (int lev, amrex::Real dt)
void	Hybrid_QED_Push (int lev, PatchType patch_type, amrex::Real dt)
void	CheckLoadBalance (int step)
void	LoadBalance ()
	perform load balance; compute and communicate new amrex::DistributionMapping More...
void	ResetCosts ()
	resets costs to zero More...
void	RescaleCosts (int step)
utils::parser::IntervalsParser	get_load_balance_intervals () const
	returns the load balance interval More...
void	DampFieldsInGuards (int lev, const std::array< std::unique_ptr< amrex::MultiFab >, 3 > &Efield, const std::array< std::unique_ptr< amrex::MultiFab >, 3 > &Bfield)
	Private function for spectral solver Applies a damping factor in the guards cells that extend beyond the extent of the domain, reducing fluctuations that can appear in parallel simulations. This will be called when FieldBoundaryType is set to damped. Vector version. More...
void	DampFieldsInGuards (int lev, std::unique_ptr< amrex::MultiFab > &mf)
	Private function for spectral solver Applies a damping factor in the guards cells that extend beyond the extent of the domain, reducing fluctuations that can appear in parallel simulations. This will be called when FieldBoundaryType is set to damped. Scalar version. More...
void	ApplyInverseVolumeScalingToCurrentDensity (amrex::MultiFab *Jx, amrex::MultiFab *Jy, amrex::MultiFab *Jz, int lev)
void	ApplyInverseVolumeScalingToChargeDensity (amrex::MultiFab *Rho, int lev)
void	ApplyRhofieldBoundary (int lev, amrex::MultiFab *Rho, PatchType patch_type)
	If a PEC boundary conditions is used the charge density deposited in the guard cells have to be reflected back into the simulation domain. This function performs that logic. More...
void	ApplyJfieldBoundary (int lev, amrex::MultiFab *Jx, amrex::MultiFab *Jy, amrex::MultiFab *Jz, PatchType patch_type)
	If a PEC boundary conditions is used the current density deposited in the guard cells have to be reflected back into the simulation domain. This function performs that logic. More...
void	ApplyEfieldBoundary (int lev, PatchType patch_type)
void	ApplyBfieldBoundary (int lev, PatchType patch_type, DtType dt_type)
void	ApplyFieldBoundaryOnAxis (amrex::MultiFab *Er, amrex::MultiFab *Et, amrex::MultiFab *Ez, int lev) const
void	ApplyElectronPressureBoundary (int lev, PatchType patch_type)
	When the Ohm's law solver is used, the electron pressure values on PEC boundaries are set to enforce a zero derivative Neumann condition, otherwise the E_perp values have large spikes (that grows as 1/dx). This has to be done since the E-field is algebraically calculated instead of evolved which means the 1/dx growth is not avoided by multiplication with dt as happens in the B-field evolve. More...
void	DampPML ()
void	DampPML (int lev)
void	DampPML (int lev, PatchType patch_type)
void	DampPML_Cartesian (int lev, PatchType patch_type)
void	DampJPML ()
void	DampJPML (int lev)
void	DampJPML (int lev, PatchType patch_type)
void	CopyJPML ()
	Copy the current J from the regular grid to the PML. More...
bool	isAnyBoundaryPML ()
PML *	GetPML (int lev)
PML_RZ *	GetPML_RZ (int lev)
void	doFieldIonization ()
void	doFieldIonization (int lev)
void	doQEDEvents ()
void	doQEDEvents (int lev)
void	PushParticlesandDeposit (int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false, PushType push_type=PushType::Explicit)
void	PushParticlesandDeposit (amrex::Real cur_time, bool skip_current=false, PushType push_type=PushType::Explicit)
void	UpdateAuxilaryData ()
void	UpdateAuxilaryDataStagToNodal ()
void	UpdateAuxilaryDataSameType ()
void	UpdateCurrentNodalToStag (amrex::MultiFab &dst, amrex::MultiFab const &src)
	This function is called if warpx.do_current_centering = 1 and it centers the currents from a nodal grid to a staggered grid (Yee) using finite-order interpolation based on the Fornberg coefficients. More...
void	FillBoundaryB (amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryE (amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryB_avg (amrex::IntVect ng)
void	FillBoundaryE_avg (amrex::IntVect ng)
void	FillBoundaryF (amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryG (amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryAux (amrex::IntVect ng)
void	FillBoundaryE (int lev, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryB (int lev, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryE_avg (int lev, amrex::IntVect ng)
void	FillBoundaryB_avg (int lev, amrex::IntVect ng)
void	FillBoundaryF (int lev, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryG (int lev, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryAux (int lev, amrex::IntVect ng)
void	SyncCurrentAndRho ()
	Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels and apply boundary conditions. Contains separate calls to WarpX::SyncCurrent and WarpX::SyncRho. More...
void	SyncCurrent (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_buffer)
	Apply filter and sum guard cells across MR levels. If current centering is used, center the current from a nodal grid to a staggered grid. For each MR level beyond level 0, interpolate the fine-patch current onto the coarse-patch current at the same level. Then, for each MR level, including level 0, apply filter and sum guard cells across levels. More...
void	SyncRho ()
void	SyncRho (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_buffer)
amrex::Vector< int >	getnsubsteps () const
int	getnsubsteps (int lev) const
amrex::Vector< int >	getistep () const
int	getistep (int lev) const
void	setistep (int lev, int ii)
amrex::Vector< amrex::Real >	gett_old () const
amrex::Real	gett_old (int lev) const
amrex::Vector< amrex::Real >	gett_new () const
amrex::Real	gett_new (int lev) const
void	sett_new (int lev, amrex::Real time)
amrex::Vector< amrex::Real >	getdt () const
amrex::Real	getdt (int lev) const
int	getdo_moving_window () const
amrex::Real	getmoving_window_x () const
bool	getis_synchronized () const
int	maxStep () const
void	updateMaxStep (const int new_max_step)
amrex::Real	stopTime () const
void	updateStopTime (const amrex::Real new_stop_time)
void	AverageAndPackFields (amrex::Vector< std::string > &varnames, amrex::Vector< amrex::MultiFab > &mf_avg, amrex::IntVect ngrow) const
void	prepareFields (int step, amrex::Vector< std::string > &varnames, amrex::Vector< amrex::MultiFab > &mf_avg, amrex::Vector< const amrex::MultiFab * > &output_mf, amrex::Vector< amrex::Geometry > &output_geom) const
void	ComputeDivE (amrex::MultiFab &divE, int lev)
amrex::IntVect	getngEB () const
amrex::IntVect	getngF () const
amrex::IntVect	getngUpdateAux () const
amrex::IntVect	get_ng_depos_J () const
amrex::IntVect	get_ng_depos_rho () const
amrex::IntVect	get_ng_fieldgather () const
amrex::IntVect	get_numprocs () const
void	ComputeSpaceChargeField (bool reset_fields)
void	AddBoundaryField ()
void	AddSpaceChargeField (WarpXParticleContainer &pc)
void	AddSpaceChargeFieldLabFrame ()
void	computePhi (const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &rho, amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi, std::array< amrex::Real, 3 > beta={{0, 0, 0}}, amrex::Real required_precision=amrex::Real(1.e-11), amrex::Real absolute_tolerance=amrex::Real(0.0), int max_iters=200, int verbosity=2) const
void	setPhiBC (amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi) const
void	computeE (amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &E, const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi, std::array< amrex::Real, 3 > beta={{0, 0, 0}}) const
void	computeB (amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &B, const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi, std::array< amrex::Real, 3 > beta={{0, 0, 0}}) const
void	computePhiTriDiagonal (const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &rho, amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi) const
void	ComputeMagnetostaticField ()
void	AddMagnetostaticFieldLabFrame ()
void	computeVectorPotential (const amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &curr, amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &A, amrex::Real required_precision=amrex::Real(1.e-11), amrex::Real absolute_tolerance=amrex::Real(0.0), int max_iters=200, int verbosity=2) const
void	setVectorPotentialBC (amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &A) const
void	InitializeExternalFieldsOnGridUsingParser (amrex::MultiFab *mfx, amrex::MultiFab *mfy, amrex::MultiFab *mfz, amrex::ParserExecutor< 3 > const &xfield_parser, amrex::ParserExecutor< 3 > const &yfield_parser, amrex::ParserExecutor< 3 > const &zfield_parser, std::array< std::unique_ptr< amrex::MultiFab >, 3 > const &edge_lengths, std::array< std::unique_ptr< amrex::MultiFab >, 3 > const &face_areas, char field, int lev, PatchType patch_type)
	This function initializes the E and B fields on each level using the parser and the user-defined function for the external fields. The subroutine will parse the x_/y_z_external_grid_function and then, the field multifab is initialized based on the (x,y,z) position on the staggered yee-grid or cell-centered grid, in the interior cells and guard cells. More...
void	LoadExternalFieldsFromFile (int lev)
	Load field values from a user-specified openPMD file, for the fields Ex, Ey, Ez, Bx, By, Bz. More...
void	ReadExternalFieldFromFile (const std::string &read_fields_from_path, amrex::MultiFab *mf, const std::string &F_name, const std::string &F_component)
	Load field values from a user-specified openPMD file for a specific field (specified by F_name) More...
void	InitializeEBGridData (int lev)
	This function initializes and calculates grid quantities used along with EBs such as edge lengths, face areas, distance to EB, etc. It also appropriately communicates EB data to guard cells. More...
void	ComputeCostsHeuristic (amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > > &costs)
	adds particle and cell contributions in cells to compute heuristic cost in each box on each level, and records in costs More...
void	ApplyFilterandSumBoundaryRho (int lev, int glev, amrex::MultiFab &rho, int icomp, int ncomp)
void	ErrorEst (int lev, amrex::TagBoxArray &tags, amrex::Real time, int) final
	Tagging cells for refinement. More...
const AcceleratorLattice &	get_accelerator_lattice (int lev)
void	BuildBufferMasksInBox (amrex::Box tbx, amrex::IArrayBox &buffer_mask, const amrex::IArrayBox &guard_mask, int ng)
	Build buffer mask within given FArrayBox. More...
void	InitEB ()
void	ComputeDistanceToEB ()
	Compute the level set function used for particle-boundary interaction. More...
amrex::Array1D< int, 0, 2 >	CountExtFaces ()
	Auxiliary function to count the amount of faces which still need to be extended. More...
void	ComputeFaceExtensions ()
	Main function computing the cell extension. Where possible it computes one-way extensions and, when this is not possible, it does eight-ways extensions. More...
void	InitBorrowing ()
	Initialize the memory for the FaceInfoBoxes. More...
void	ShrinkBorrowing ()
	Shrink the vectors in the FaceInfoBoxes. More...
void	ComputeOneWayExtensions ()
	Do the one-way extension. More...
void	ComputeEightWaysExtensions ()
	Do the eight-ways extension. More...
void	ApplyBCKCorrection (int idim)
	Whenever an unstable cell cannot be extended we increase its area to be the minimal for stability. This is the method Benkler-Chavannes-Kuster method and it is less accurate than the regular ECT but it still works better than staircasing. (see https://ieeexplore.ieee.org/document/1638381) More...
void	PSATDSubtractCurrentPartialSumsAvg ()
	Subtract the average of the cumulative sums of the preliminary current D from the current J (computed from D according to the Vay deposition scheme) More...
SpectralSolverRZ &	get_spectral_solver_fp (int lev)
FiniteDifferenceSolver *	get_pointer_fdtd_solver_fp (int lev)
Public Member Functions inherited from amrex::AmrCore
	AmrCore ()
	AmrCore (const RealBox *rb, int max_level_in, const Vector< int > &n_cell_in, int coord=-1, Vector< IntVect > ref_ratios=Vector< IntVect >(), const int *is_per=nullptr)
	AmrCore (const RealBox &rb, int max_level_in, const Vector< int > &n_cell_in, int coord, Vector< IntVect > const &ref_ratios, Array< int, AMREX_SPACEDIM > const &is_per)
	AmrCore (Geometry const &level_0_geom, AmrInfo const &amr_info)
	AmrCore (AmrCore &&rhs) noexcept
AmrCore &	operator= (AmrCore &&rhs) noexcept
	AmrCore (const AmrCore &rhs)=delete
AmrCore &	operator= (const AmrCore &rhs)=delete
	~AmrCore () override
void	InitFromScratch (Real time)
virtual void	regrid (int lbase, Real time, bool initial=false)
void	printGridSummary (std::ostream &os, int min_lev, int max_lev) const noexcept
Public Member Functions inherited from amrex::AmrMesh
	AmrMesh ()
	AmrMesh (const RealBox *rb, int max_level_in, const Vector< int > &n_cell_in, int coord=-1, Vector< IntVect > refrat=Vector< IntVect >(), const int *is_per=nullptr)
	AmrMesh (const RealBox &rb, int max_level_in, const Vector< int > &n_cell_in, int coord, Vector< IntVect > const &a_refrat, Array< int, AMREX_SPACEDIM > const &is_per)
	AmrMesh (Geometry const &level_0_geom, AmrInfo const &amr_info)
	AmrMesh (const AmrMesh &rhs)=delete
AmrMesh &	operator= (const AmrMesh &rhs)=delete
	AmrMesh (AmrMesh &&rhs)=default
AmrMesh &	operator= (AmrMesh &&rhs)=default
virtual	~AmrMesh ()=default
int	Verbose () const noexcept
int	maxLevel () const noexcept
int	finestLevel () const noexcept
IntVect	refRatio (int lev) const noexcept
int	MaxRefRatio (int lev) const noexcept
const Vector< IntVect > &	refRatio () const noexcept
const Vector< Geometry > &	Geom () const noexcept
const Vector< DistributionMapping > &	DistributionMap () const noexcept
const Vector< BoxArray > &	boxArray () const noexcept
const Geometry &	Geom (int lev) const noexcept
const DistributionMapping &	DistributionMap (int lev) const noexcept
const BoxArray &	boxArray (int lev) const noexcept
Vector< Geometry >	Geom (int a_coarsest_lev, int a_finest_lev) const noexcept
Vector< BoxArray >	boxArray (int a_coarsest_lev, int a_finest_lev) const noexcept
Vector< DistributionMapping >	DistributionMap (int a_coarsest_lev, int a_finest_lev) const noexcept
Vector< Geometry > &	Geom () noexcept
Geometry &	Geom (int lev) noexcept
void	SetMaxGridSize (int new_mgs) noexcept
void	SetMaxGridSize (const IntVect &new_mgs) noexcept
void	SetMaxGridSize (const Vector< int > &new_mgs) noexcept
void	SetMaxGridSize (const Vector< IntVect > &new_mgs) noexcept
void	SetBlockingFactor (int new_bf) noexcept
void	SetBlockingFactor (const IntVect &new_bf) noexcept
void	SetBlockingFactor (const Vector< int > &new_bf) noexcept
void	SetBlockingFactor (const Vector< IntVect > &new_bf) noexcept
void	SetGridEff (Real eff) noexcept
void	SetNProper (int n) noexcept
void	SetFinestLevel (int new_finest_level) noexcept
void	SetDistributionMap (int lev, const DistributionMapping &dmap_in) noexcept
void	SetBoxArray (int lev, const BoxArray &ba_in) noexcept
void	SetGeometry (int lev, const Geometry &geom_in) noexcept
int	GetLevel (Box const &domain) noexcept
void	ClearDistributionMap (int lev) noexcept
void	ClearBoxArray (int lev) noexcept
int	nErrorBuf (int lev, int direction=0) const noexcept
const IntVect &	nErrorBufVect (int lev) const noexcept
Real	gridEff () const noexcept
int	nProper () const noexcept
const IntVect &	blockingFactor (int lev) const noexcept
const IntVect &	maxGridSize (int lev) const noexcept
bool	LevelDefined (int lev) noexcept
bool	useFixedCoarseGrids () const noexcept
int	useFixedUpToLevel () const noexcept
void	ChopGrids (int lev, BoxArray &ba, int target_size) const
BoxArray	MakeBaseGrids () const
void	MakeNewGrids (int lbase, Real time, int &new_finest, Vector< BoxArray > &new_grids)
void	MakeNewGrids (Real time=0.0)
virtual void	ManualTagsPlacement (int, TagBoxArray &, const Vector< IntVect > &)
virtual BoxArray	GetAreaNotToTag (int)
long	CountCells (int lev) noexcept
virtual DistributionMapping	MakeDistributionMap (int lev, BoxArray const &ba)

Static Public Member Functions
static WarpX &	GetInstance ()
static void	ResetInstance ()
static void	Finalize ()
	This method has to be called at the end of the simulation. It deletes the WarpX instance. More...
static std::string	Version ()
	Version of WarpX executable. More...
static std::string	PicsarVersion ()
	Version of PICSAR dependency. More...
static void	shiftMF (amrex::MultiFab &mf, const amrex::Geometry &geom, int num_shift, int dir, int lev, bool update_cost_flag, amrex::Real external_field=0.0, bool useparser=false, amrex::ParserExecutor< 3 > const &field_parser={})
static void	AllocInitMultiFab (std::unique_ptr< amrex::MultiFab > &mf, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm, int ncomp, const amrex::IntVect &ngrow, int level, const std::string &name, std::optional< const amrex::Real > initial_value={})
	Allocate and optionally initialize the MultiFab. This also adds the MultiFab to the map of MultiFabs (used to ease the access to MultiFabs from the Python interface. More...
static void	AllocInitMultiFab (std::unique_ptr< amrex::iMultiFab > &mf, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm, int ncomp, const amrex::IntVect &ngrow, int level, const std::string &name, std::optional< const int > initial_value={})
	Allocate and optionally initialize the iMultiFab. This also adds the iMultiFab to the map of MultiFabs (used to ease the access to MultiFabs from the Python interface. More...
static void	AliasInitMultiFab (std::unique_ptr< amrex::MultiFab > &mf, const amrex::MultiFab &mf_to_alias, int scomp, int ncomp, int level, const std::string &name, std::optional< const amrex::Real > initial_value)
	Create an alias of a MultiFab, adding the alias to the MultiFab map. More...
static void	AllocInitMultiFabFromModel (std::unique_ptr< amrex::MultiFab > &mf, amrex::MultiFab &mf_model, int level, const std::string &name, std::optional< const amrex::Real > initial_value={})
	Allocate the MultiFab so that is like the specified MultiFab (same ba and dm) and optionally initialize it. This also adds the MultiFab to the map of MultiFabs (used to ease the access to MultiFabs from the Python interface. More...
static amrex::LayoutData< amrex::Real > *	getCosts (int lev)
static bool	isAnyParticleBoundaryThermal ()
static std::array< amrex::Real, 3 >	CellSize (int lev)
static amrex::RealBox	getRealBox (const amrex::Box &bx, int lev)
static std::array< amrex::Real, 3 >	LowerCorner (const amrex::Box &bx, int lev, amrex::Real time_shift_delta)
	Return the lower corner of the box in real units. More...
static std::array< amrex::Real, 3 >	UpperCorner (const amrex::Box &bx, int lev, amrex::Real time_shift_delta)
	Return the upper corner of the box in real units. More...
static amrex::IntVect	RefRatio (int lev)
static const amrex::iMultiFab *	CurrentBufferMasks (int lev)
static const amrex::iMultiFab *	GatherBufferMasks (int lev)
static int	moving_window_active (int const step)
static void	ComputeDivB (amrex::MultiFab &divB, int dcomp, const std::array< const amrex::MultiFab *const, 3 > &B, const std::array< amrex::Real, 3 > &dx)
static void	ComputeDivB (amrex::MultiFab &divB, int dcomp, const std::array< const amrex::MultiFab *const, 3 > &B, const std::array< amrex::Real, 3 > &dx, amrex::IntVect ngrow)
static amrex::Vector< amrex::Real >	getFornbergStencilCoefficients (int n_order, short a_grid_type)
	Returns an array of coefficients (Fornberg coefficients), corresponding to the weight of each point in a finite-difference approximation of a derivative (up to order n_order). More...

Public Attributes
int	maxlevel_extEMfield_init
bool	current_correction
	If true, a correction is applied to the current in Fourier space,. More...
bool	update_with_rho = false
amrex::IntVect	m_rho_nodal_flag
BilinearFilter	bilinear_filter
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > >	nci_godfrey_filter_exeybz
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > >	nci_godfrey_filter_bxbyez
amrex::Real	time_of_last_gal_shift = 0
amrex::Vector< amrex::Real >	m_v_galilean = amrex::Vector<amrex::Real>(3, amrex::Real(0.))
amrex::Array< amrex::Real, 3 >	m_galilean_shift = {{0}}
amrex::Vector< amrex::Real >	m_v_comoving = amrex::Vector<amrex::Real>(3, amrex::Real(0.))
amrex::Vector< amrex::Real >	mirror_z
amrex::Vector< amrex::Real >	mirror_z_width
amrex::Vector< int >	mirror_z_npoints
std::unique_ptr< MultiReducedDiags >	reduced_diags
	object with all reduced diagnostics, similar to MultiParticleContainer for species. More...
bool	m_boundary_potential_specified = false
ElectrostaticSolver::PoissonBoundaryHandler	m_poisson_boundary_handler
MagnetostaticSolver::VectorPoissonBoundaryHandler	m_vector_poisson_boundary_handler
amrex::Gpu::DeviceVector< amrex::Real >	device_field_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real >	device_field_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real >	device_field_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real >	device_current_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real >	device_current_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real >	device_current_centering_stencil_coeffs_z

Static Public Attributes
static short	current_deposition_algo
	Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay, Villasenor) More...
static short	charge_deposition_algo
	Integer that corresponds to the charge deposition algorithm (only standard deposition) More...
static short	field_gathering_algo
	Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving) More...
static short	particle_pusher_algo
	Integer that corresponds to the particle push algorithm (Boris, Vay, Higuera-Cary) More...
static short	electromagnetic_solver_id
	Integer that corresponds to the type of Maxwell solver (Yee, CKC, PSATD, ECT) More...
static short	evolve_scheme
	Integer that corresponds to the evolve scheme (explicit, implicit_picard, semi_implicit_picard) More...
static int	max_picard_iterations = 10
	The maximum number of Picard iterations to do each time step. More...
static amrex::Real	picard_iteration_tolerance = 1.e-7
	The tolerance for the Picard iteration convergence. More...
static bool	require_picard_convergence = true
	Flags whether the Picard iterations are required to converge. More...
static short	load_balance_costs_update_algo
static int	em_solver_medium
	Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1) More...
static int	macroscopic_solver_algo
static amrex::Vector< FieldBoundaryType >	field_boundary_lo
static amrex::Vector< FieldBoundaryType >	field_boundary_hi
static amrex::Vector< ParticleBoundaryType >	particle_boundary_lo
static amrex::Vector< ParticleBoundaryType >	particle_boundary_hi
static short	psatd_solution_type
static short	J_in_time
static short	rho_in_time
static bool	do_current_centering = false
static bool	do_single_precision_comms = false
	perform field communications in single precision More...
static bool	do_shared_mem_charge_deposition = false
	used shared memory algorithm for charge deposition More...
static bool	do_shared_mem_current_deposition = false
	use shared memory algorithm for current deposition More...
static int	shared_mem_current_tpb = 128
	number of threads to use per block in shared deposition More...
static amrex::IntVect	shared_tilesize
	tileSize to use for shared current deposition operations More...
static amrex::IntVect	m_fill_guards_fields = amrex::IntVect(0)
	Whether to fill guard cells when computing inverse FFTs of fields. More...
static amrex::IntVect	m_fill_guards_current = amrex::IntVect(0)
	Whether to fill guard cells when computing inverse FFTs of currents. More...
static bool	do_dive_cleaning = false
static bool	do_divb_cleaning = false
	Solve additional Maxwell equation for G in order to control errors in magnetic Gauss' law. More...
static int	nox = 0
	Order of the particle shape factors (splines) along x. More...
static int	noy = 0
	Order of the particle shape factors (splines) along y. More...
static int	noz = 0
	Order of the particle shape factors (splines) along z. More...
static int	field_centering_nox = 2
	Order of finite centering of fields (from staggered grid to nodal grid), along x. More...
static int	field_centering_noy = 2
	Order of finite centering of fields (from staggered grid to nodal grid), along y. More...
static int	field_centering_noz = 2
	Order of finite centering of fields (from staggered grid to nodal grid), along z. More...
static int	current_centering_nox = 2
	Order of finite centering of currents (from nodal grid to staggered grid), along x. More...
static int	current_centering_noy = 2
	Order of finite centering of currents (from nodal grid to staggered grid), along y. More...
static int	current_centering_noz = 2
	Order of finite centering of currents (from nodal grid to staggered grid), along z. More...
static int	n_rz_azimuthal_modes = 1
	Number of modes for the RZ multi-mode version. More...
static int	ncomps = 1
static bool	use_fdtd_nci_corr = false
static bool	galerkin_interpolation = true
static bool	verboncoeur_axis_correction = true
static bool	use_filter = true
	If true, a bilinear filter is used to smooth charge and currents. More...
static bool	use_kspace_filter = true
	If true, the bilinear filtering of charge and currents is done in Fourier space. More...
static bool	use_filter_compensation = false
	If true, a compensation step is added to the bilinear filtering of charge and currents. More...
static bool	serialize_initial_conditions = false
	If true, the initial conditions from random number generators are serialized (useful for reproducible testing with OpenMP) More...
static amrex::Real	gamma_boost = 1._rt
	Lorentz factor of the boosted frame in which a boosted-frame simulation is run. More...
static amrex::Real	beta_boost = 0._rt
	Beta value corresponding to the Lorentz factor of the boosted frame of the simulation. More...
static amrex::Vector< int >	boost_direction = {0,0,0}
	Direction of the Lorentz transform that defines the boosted frame of the simulation. More...
static amrex::Real	zmax_plasma_to_compute_max_step = 0._rt
static bool	do_compute_max_step_from_zmax = false
static amrex::Real	zmin_domain_boost_step_0 = 0._rt
static bool	compute_max_step_from_btd = false
	If true, the code will compute max_step from the back transformed diagnostics. More...
static bool	do_dynamic_scheduling = true
static bool	refine_plasma = false
static utils::parser::IntervalsParser	sort_intervals
static amrex::IntVect	sort_bin_size
static bool	sort_particles_for_deposition = false
	If true, particles will be sorted in the order x -> y -> z -> ppc for faster deposition. More...
static amrex::IntVect	sort_idx_type
	Specifies the type of grid used for the above sorting, i.e. cell-centered, nodal, or mixed. More...
static bool	do_subcycling = false
static bool	do_multi_J = false
static int	do_multi_J_n_depositions
static bool	do_device_synchronize = false
static bool	safe_guard_cells = false
static int	n_field_gather_buffer = -1
static int	n_current_deposition_buffer = -1
static short	grid_type
static std::map< std::string, amrex::MultiFab * >	multifab_map
static std::map< std::string, amrex::iMultiFab * >	imultifab_map
static amrex::IntVect	filter_npass_each_dir
static int	num_mirrors = 0
static amrex::Real	quantum_xi_c2 = PhysConst::xi_c2
static int	electrostatic_solver_id
static int	poisson_solver_id
static amrex::Real	self_fields_required_precision = 1.e-11_rt
static amrex::Real	self_fields_absolute_tolerance = 0.0_rt
static int	self_fields_max_iters = 200
static int	self_fields_verbosity = 2
static int	do_moving_window = 0
static int	start_moving_window_step = 0
static int	end_moving_window_step = -1
static int	moving_window_dir = -1
static amrex::Real	moving_window_v = std::numeric_limits<amrex::Real>::max()
static bool	fft_do_time_averaging = false

Protected Member Functions
void	InitLevelData (int lev, amrex::Real time)
	This function initializes E, B, rho, and F, at all the levels of the multifab. rho and F are initialized with 0. The E and B fields are initialized using user-defined inputs. The initialization type is set using "B_ext_grid_init_style" and "E_ext_grid_init_style". The initialization style is set to "default" if not explicitly defined by the user, and the E and B fields are initialized with E_external_grid and B_external_grid, respectively, each with a default value of 0. If the initialization type for the E and B field is "constant", then, the E and B fields at all the levels are initialized with user-defined values for E_external_grid and B_external_grid. If the initialization type for B-field is set to "parse_ext_grid_function", then, the parser is used to read Bx_external_grid_function(x,y,z), By_external_grid_function(x,y,z), and Bz_external_grid_function(x,y,z). Similarly, if the E-field initialization type is set to "parse_ext_grid_function", then, the parser is used to read Ex_external_grid_function(x,y,z), Ey_external_grid_function(x,y,z), and Ex_external_grid_function(x,y,z). The parser for the E and B initialization assumes that the function has three independent variables, at max, namely, x, y, z. However, any number of constants can be used in the function used to define the E and B fields on the grid. More...
void	PostProcessBaseGrids (amrex::BoxArray &ba0) const final
void	MakeNewLevelFromScratch (int lev, amrex::Real time, const amrex::BoxArray &new_grids, const amrex::DistributionMapping &new_dmap) final
void	MakeNewLevelFromCoarse (int, amrex::Real, const amrex::BoxArray &, const amrex::DistributionMapping &) final
void	RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final
void	ClearLevel (int lev) final
	Delete level data. Called by AmrCore::regrid. More...
Protected Member Functions inherited from amrex::AmrCore
void	ErrorEst (int lev, TagBoxArray &tags, Real time, int ngrow) override=0
void	MakeNewLevelFromScratch (int lev, Real time, const BoxArray &ba, const DistributionMapping &dm) override=0
virtual void	MakeNewLevelFromCoarse (int lev, Real time, const BoxArray &ba, const DistributionMapping &dm)=0
virtual void	RemakeLevel (int lev, Real time, const BoxArray &ba, const DistributionMapping &dm)=0
Protected Member Functions inherited from amrex::AmrMesh
void	checkInput ()
void	SetIterateToFalse () noexcept
void	SetUseNewChop () noexcept

Private Member Functions
	WarpX ()
	WarpX constructor. This method should not be called directly, but rather through the static member function MakeWarpX(). MakeWarpX() is called by GetInstance () if an instance of the WarpX class does not currently exist. More...
void	HandleSignals ()
	Complete the asynchronous broadcast of signal flags, and initiate a checkpoint if requested. More...
void	FillBoundaryB (int lev, PatchType patch_type, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryE (int lev, PatchType patch_type, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryF (int lev, PatchType patch_type, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryG (int lev, PatchType patch_type, amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
void	FillBoundaryB_avg (int lev, PatchType patch_type, amrex::IntVect ng)
void	FillBoundaryE_avg (int lev, PatchType patch_type, amrex::IntVect ng)
void	AddExternalFields ()
void	OneStep_nosub (amrex::Real cur_time)
void	OneStep_sub1 (amrex::Real cur_time)
void	OneStep_ImplicitPicard (amrex::Real cur_time)
void	OneStep_multiJ (amrex::Real cur_time)
	Perform one PIC iteration, with the multiple J deposition per time step. More...
void	RestrictCurrentFromFineToCoarsePatch (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp, int lev)
	Fills the values of the current on the coarse patch by averaging the values of the current of the fine patch (on the same level). More...
void	AddCurrentFromFineLevelandSumBoundary (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_buffer, int lev)
void	StoreCurrent (int lev)
void	RestoreCurrent (int lev)
void	ApplyFilterJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &current, int lev, int idim)
void	ApplyFilterJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &current, int lev)
void	SumBoundaryJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &current, int lev, int idim, const amrex::Periodicity &period)
void	SumBoundaryJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &current, int lev, const amrex::Periodicity &period)
void	NodalSyncJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp, int lev, PatchType patch_type)
void	RestrictRhoFromFineToCoarsePatch (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, int lev)
void	ApplyFilterandSumBoundaryRho (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, int lev, PatchType patch_type, int icomp, int ncomp)
void	AddRhoFromFineLevelandSumBoundary (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_buffer, int lev, int icomp, int ncomp)
void	NodalSyncRho (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, int lev, PatchType patch_type, int icomp, int ncomp)
void	ReadParameters ()
void	BackwardCompatibility ()
void	InitFromScratch ()
void	AllocLevelData (int lev, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm)
amrex::DistributionMapping	GetRestartDMap (const std::string &chkfile, const amrex::BoxArray &ba, int lev) const
void	InitFromCheckpoint ()
void	PostRestart ()
void	InitPML ()
void	ComputePMLFactors ()
void	InitFilter ()
void	InitDiagnostics ()
void	InitNCICorrector ()
void	CheckGuardCells ()
	Check that the number of guard cells is smaller than the number of valid cells, for all available MultiFabs, and abort otherwise. More...
void	CheckKnownIssues ()
	Checks for known numerical issues involving different WarpX modules. More...
void	PerformanceHints ()
void	BuildBufferMasks ()
const amrex::iMultiFab *	getCurrentBufferMasks (int lev) const
const amrex::iMultiFab *	getGatherBufferMasks (int lev) const
void	ReorderFornbergCoefficients (amrex::Vector< amrex::Real > &ordered_coeffs, amrex::Vector< amrex::Real > &unordered_coeffs, int order)
	Re-orders the Fornberg coefficients so that they can be used more conveniently for finite-order centering operations. For example, for finite-order centering of order 6, the Fornberg coefficients (c_0,c_1,c_2) are re-ordered as (c_2,c_1,c_0,c_0,c_1,c_2). More...
void	AllocateCenteringCoefficients (amrex::Gpu::DeviceVector< amrex::Real > &device_centering_stencil_coeffs_x, amrex::Gpu::DeviceVector< amrex::Real > &device_centering_stencil_coeffs_y, amrex::Gpu::DeviceVector< amrex::Real > &device_centering_stencil_coeffs_z, int centering_nox, int centering_noy, int centering_noz, short a_grid_type)
	Allocates and initializes the stencil coefficients used for the finite-order centering of fields and currents, and stores them in the given device vectors. More...
void	AllocLevelMFs (int lev, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm, const amrex::IntVect &ngEB, amrex::IntVect &ngJ, const amrex::IntVect &ngRho, const amrex::IntVect &ngF, const amrex::IntVect &ngG, bool aux_is_nodal)
void	AllocLevelSpectralSolverRZ (amrex::Vector< std::unique_ptr< SpectralSolverRZ >> &spectral_solver, int lev, const amrex::BoxArray &realspace_ba, const amrex::DistributionMapping &dm, const std::array< amrex::Real, 3 > &dx)
amrex::MultiFab *	getFieldPointerUnchecked (FieldType field_type, int lev, int direction=0) const
	Get a pointer to the field data. Does not check if the pointer is not nullptr. More...
amrex::FabFactory< amrex::FArrayBox > const &	fieldFactory (int lev) const noexcept
bool	checkStopSimulation (amrex::Real cur_time)
void	checkEarlyUnusedParams ()
void	HandleParticlesAtBoundaries (int step, amrex::Real cur_time, int num_moved)
void	ScrapeParticles ()
void	ExplicitFillBoundaryEBUpdateAux ()
void	PushPSATD ()
void	PSATDForwardTransformEB (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &E_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &B_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &E_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &B_cp)
	Forward FFT of E,B on all mesh refinement levels. More...
void	PSATDBackwardTransformEB (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &E_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &B_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &E_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &B_cp)
	Backward FFT of E,B on all mesh refinement levels, with field damping in the guard cells (if needed) More...
void	PSATDBackwardTransformEBavg (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &E_avg_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &B_avg_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &E_avg_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &B_avg_cp)
	Backward FFT of averaged E,B on all mesh refinement levels. More...
void	PSATDForwardTransformJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp, bool apply_kspace_filter=true)
	Forward FFT of J on all mesh refinement levels, with k-space filtering (if needed) More...
void	PSATDBackwardTransformJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp)
	Backward FFT of J on all mesh refinement levels. More...
void	PSATDForwardTransformRho (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, int icomp, int dcomp, bool apply_kspace_filter=true)
	Forward FFT of rho on all mesh refinement levels, with k-space filtering (if needed) More...
void	PSATDMoveRhoNewToRhoOld ()
	Copy rho_new to rho_old in spectral space (when rho is linear in time) More...
void	PSATDMoveJNewToJOld ()
	Copy J_new to J_old in spectral space (when J is linear in time) More...
void	PSATDForwardTransformF ()
	Forward FFT of F on all mesh refinement levels. More...
void	PSATDBackwardTransformF ()
	Backward FFT of F on all mesh refinement levels. More...
void	PSATDForwardTransformG ()
	Forward FFT of G on all mesh refinement levels. More...
void	PSATDBackwardTransformG ()
	Backward FFT of G on all mesh refinement levels. More...
void	PSATDCurrentCorrection ()
	Correct current in Fourier space so that the continuity equation is satisfied. More...
void	PSATDVayDeposition ()
	Vay deposition in Fourier space (https://doi.org/10.1016/j.jcp.2013.03.010) More...
void	PSATDPushSpectralFields ()
	Update all necessary fields in spectral space. More...
void	PSATDScaleAverageFields (amrex::Real scale_factor)
	Scale averaged E,B fields to account for time integration. More...
void	PSATDEraseAverageFields ()
	Set averaged E,B fields to zero before new iteration. More...

Static Private Member Functions
static void	MakeWarpX ()
	This method creates a new instance of the WarpX class. More...

Private Attributes
std::string	m_authors
	Author of an input file / simulation setup. More...
amrex::Vector< int >	istep
amrex::Vector< int >	nsubsteps
amrex::Vector< amrex::Real >	t_new
amrex::Vector< amrex::Real >	t_old
amrex::Vector< amrex::Real >	dt
std::unique_ptr< MultiParticleContainer >	mypc
std::unique_ptr< MultiDiagnostics >	multi_diags
bool	do_fluid_species = false
std::unique_ptr< MultiFluidContainer >	myfl
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_aux
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	F_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	G_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	rho_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	phi_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_fp_vay
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_n
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_n
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_save
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_save
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	vector_potential_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	vector_potential_grad_buf_e_stag
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	vector_potential_grad_buf_b_stag
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	m_edge_lengths
	EB: Lengths of the mesh edges. More...
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	m_face_areas
	EB: Areas of the mesh faces. More...
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > >	m_flag_info_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > >	m_flag_ext_face
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	m_area_mod
amrex::Vector< std::array< std::unique_ptr< amrex::LayoutData< FaceInfoBox > >, 3 > >	m_borrowing
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	ECTRhofield
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Venl
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	m_distance_to_eb
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_store
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_fp_nodal
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	F_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	G_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	rho_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_cax
amrex::Vector< std::unique_ptr< amrex::iMultiFab > >	current_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > >	gather_buffer_masks
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_buf
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	charge_buf
int	do_pml = 0
int	do_silver_mueller = 0
int	pml_ncell = 10
int	pml_delta = 10
int	pml_has_particles = 0
int	do_pml_j_damping = 0
int	do_pml_in_domain = 0
bool	do_pml_dive_cleaning
bool	do_pml_divb_cleaning
amrex::Vector< amrex::IntVect >	do_pml_Lo
amrex::Vector< amrex::IntVect >	do_pml_Hi
amrex::Vector< std::unique_ptr< PML > >	pml
amrex::Vector< std::unique_ptr< PML_RZ > >	pml_rz
amrex::Real	v_particle_pml
std::unique_ptr< ExternalFieldParams >	m_p_ext_field_params
amrex::Real	moving_window_x = std::numeric_limits<amrex::Real>::max()
int	warpx_do_continuous_injection = 0
int	num_injected_species = -1
amrex::Vector< int >	injected_plasma_species
std::optional< amrex::Real >	m_const_dt
std::unique_ptr< MacroscopicProperties >	m_macroscopic_properties
std::unique_ptr< HybridPICModel >	m_hybrid_pic_model
utils::parser::IntervalsParser	load_balance_intervals
amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > >	costs
int	load_balance_with_sfc = 0
amrex::Real	load_balance_knapsack_factor = amrex::Real(1.24)
amrex::Real	load_balance_efficiency_ratio_threshold = amrex::Real(1.1)
amrex::Vector< amrex::Real >	load_balance_efficiency
amrex::Real	costs_heuristic_cells_wt = amrex::Real(0)
amrex::Real	costs_heuristic_particles_wt = amrex::Real(0)
utils::parser::IntervalsParser	override_sync_intervals
int	verbose = 1
bool	use_hybrid_QED = false
int	max_step = std::numeric_limits<int>::max()
amrex::Real	stop_time = std::numeric_limits<amrex::Real>::max()
int	regrid_int = -1
amrex::Real	cfl = amrex::Real(0.999)
std::string	restart_chkfile
bool	write_diagnostics_on_restart = false
amrex::VisMF::Header::Version	plotfile_headerversion = amrex::VisMF::Header::Version_v1
amrex::VisMF::Header::Version	slice_plotfile_headerversion = amrex::VisMF::Header::Version_v1
bool	use_single_read = true
bool	use_single_write = true
int	mffile_nstreams = 4
int	field_io_nfiles = 1024
int	particle_io_nfiles = 1024
amrex::RealVect	fine_tag_lo
amrex::RealVect	fine_tag_hi
std::unique_ptr< amrex::Parser >	ref_patch_parser
	User-defined parser to define refinement patches. More...
bool	is_synchronized = true
guardCellManager	guard_cells
int	slice_max_grid_size
int	slice_plot_int = -1
amrex::RealBox	slice_realbox
amrex::IntVect	slice_cr_ratio
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	F_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	G_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > >	rho_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	current_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Efield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > >	Bfield_slice
bool	fft_periodic_single_box = false
int	nox_fft = 16
int	noy_fft = 16
int	noz_fft = 16
amrex::IntVect	numprocs {0}
	Domain decomposition on Level 0. More...
std::unique_ptr< ParticleBoundaryBuffer >	m_particle_boundary_buffer
	particle buffer for scraped particles on the boundaries More...
amrex::Vector< std::unique_ptr< AcceleratorLattice > >	m_accelerator_lattice
amrex::Vector< std::unique_ptr< amrex::FabFactory< amrex::FArrayBox > > >	m_field_factory
bool	m_exit_loop_due_to_interrupt_signal = false
amrex::Vector< std::unique_ptr< SpectralSolverRZ > >	spectral_solver_fp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > >	spectral_solver_cp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > >	m_fdtd_solver_fp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > >	m_fdtd_solver_cp

Static Private Attributes
static WarpX *	m_instance = nullptr
static int	do_similar_dm_pml = 1
static constexpr bool	sync_nodal_points = true

Friends
class	PML

Additional Inherited Members
Protected Attributes inherited from amrex::AmrMesh
int	finest_level
Vector< Geometry >	geom
Vector< DistributionMapping >	dmap
Vector< BoxArray >	grids
unsigned int	num_setdm
unsigned int	num_setba
Protected Attributes inherited from amrex::AmrInfo
int	verbose
int	max_level
Vector< IntVect >	ref_ratio
Vector< IntVect >	blocking_factor
Vector< IntVect >	max_grid_size
Vector< IntVect >	n_error_buf
Real	grid_eff
int	n_proper
int	use_fixed_upto_level
bool	use_fixed_coarse_grids
bool	refine_grid_layout
IntVect	refine_grid_layout_dims
bool	check_input
bool	use_new_chop
bool	iterate_on_new_grids

Constructor & Destructor Documentation

~WarpX()

WarpX::~WarpX ( )

override

Destructor

WarpX() [1/3]

WarpX::WarpX ( WarpX const &  )

delete

Copy constructor

WarpX() [2/3]

WarpX::WarpX ( WarpX &&  )

default

Move constructor

WarpX() [3/3]

WarpX::WarpX ( )

private

WarpX constructor. This method should not be called directly, but rather through the static member function MakeWarpX(). MakeWarpX() is called by GetInstance () if an instance of the WarpX class does not currently exist.

Member Function Documentation

AddBoundaryField()

void WarpX::AddBoundaryField

(

)

AddCurrentFromFineLevelandSumBoundary()

void WarpX::AddCurrentFromFineLevelandSumBoundary ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_buffer, int  lev  )

private

AddExternalFields()

void WarpX::AddExternalFields ( )

private

AddMagnetostaticFieldLabFrame()

void WarpX::AddMagnetostaticFieldLabFrame

(

)

AddRhoFromFineLevelandSumBoundary()

void WarpX::AddRhoFromFineLevelandSumBoundary ( const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_cp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_buffer, int  lev, int  icomp, int  ncomp  )

private

AddSpaceChargeField()

void WarpX::AddSpaceChargeField

(

WarpXParticleContainer &

pc

)

AddSpaceChargeFieldLabFrame()

void WarpX::AddSpaceChargeFieldLabFrame

(

)

AliasInitMultiFab()

void WarpX::AliasInitMultiFab ( std::unique_ptr< amrex::MultiFab > &  mf, const amrex::MultiFab &  mf_to_alias, int  scomp, int  ncomp, int  level, const std::string &  name, std::optional< const amrex::Real >  initial_value  )

static

Create an alias of a MultiFab, adding the alias to the MultiFab map.

Parameters

[out]	mf	The MultiFab to create
[in]	mf_to_alias	The MultiFab to alias
[in]	scomp	The starting component to be aliased
[in]	ncomp	The number of components to alias
[in]	level	The refinement level
[in]	name	The name of the MultiFab to use in the map
[in]	initial_value	optional initial value for MultiFab

AllocateCenteringCoefficients()

void WarpX::AllocateCenteringCoefficients ( amrex::Gpu::DeviceVector< amrex::Real > &  device_centering_stencil_coeffs_x, amrex::Gpu::DeviceVector< amrex::Real > &  device_centering_stencil_coeffs_y, amrex::Gpu::DeviceVector< amrex::Real > &  device_centering_stencil_coeffs_z, int  centering_nox, int  centering_noy, int  centering_noz, short  a_grid_type  )

private

Allocates and initializes the stencil coefficients used for the finite-order centering of fields and currents, and stores them in the given device vectors.

Parameters

[in,out]	device_centering_stencil_coeffs_x	device vector where the stencil coefficients along x will be stored
[in,out]	device_centering_stencil_coeffs_y	device vector where the stencil coefficients along y will be stored
[in,out]	device_centering_stencil_coeffs_z	device vector where the stencil coefficients along z will be stored
[in]	centering_nox	order of the finite-order centering along x
[in]	centering_noy	order of the finite-order centering along y
[in]	centering_noz	order of the finite-order centering along z
[in]	a_grid_type	type of grid (collocated or not)

AllocInitMultiFab() [1/2]

void WarpX::AllocInitMultiFab ( std::unique_ptr< amrex::iMultiFab > &  mf, const amrex::BoxArray &  ba, const amrex::DistributionMapping &  dm, int  ncomp, const amrex::IntVect &  ngrow, int  level, const std::string &  name, std::optional< const int >  initial_value = {}  )

static

Allocate and optionally initialize the iMultiFab. This also adds the iMultiFab to the map of MultiFabs (used to ease the access to MultiFabs from the Python interface.

Parameters

[out]	mf	The iMultiFab unique pointer to be allocated
[in]	ba	The BoxArray describing the iMultiFab
[in]	dm	The DistributionMapping describing the iMultiFab
[in]	ncomp	The number of components in the iMultiFab
[in]	ngrow	The number of guard cells in the iMultiFab
[in]	level	The refinement level
[in]	name	The name of the iMultiFab to use in the map
[in]	initial_value	The optional initial value

AllocInitMultiFab() [2/2]

void WarpX::AllocInitMultiFab ( std::unique_ptr< amrex::MultiFab > &  mf, const amrex::BoxArray &  ba, const amrex::DistributionMapping &  dm, int  ncomp, const amrex::IntVect &  ngrow, int  level, const std::string &  name, std::optional< const amrex::Real >  initial_value = {}  )

static

Allocate and optionally initialize the MultiFab. This also adds the MultiFab to the map of MultiFabs (used to ease the access to MultiFabs from the Python interface.

Parameters

[out]	mf	The MultiFab unique pointer to be allocated
[in]	ba	The BoxArray describing the MultiFab
[in]	dm	The DistributionMapping describing the MultiFab
[in]	ncomp	The number of components in the MultiFab
[in]	ngrow	The number of guard cells in the MultiFab
[in]	level	The refinement level
[in]	name	The name of the MultiFab to use in the map
[in]	initial_value	The optional initial value

AllocInitMultiFabFromModel()

void WarpX::AllocInitMultiFabFromModel ( std::unique_ptr< amrex::MultiFab > &  mf, amrex::MultiFab &  mf_model, int  level, const std::string &  name, std::optional< const amrex::Real >  initial_value = {}  )

static

Allocate the MultiFab so that is like the specified MultiFab (same ba and dm) and optionally initialize it. This also adds the MultiFab to the map of MultiFabs (used to ease the access to MultiFabs from the Python interface.

Parameters

mf[out]	The MultiFab unique pointer to be allocated
mf_model[in]	The MultiFab to model
name[in]	The name of the MultiFab to use in the map
initial_value[in]	The optional initial value

AllocLevelData()

void WarpX::AllocLevelData ( int  lev, const amrex::BoxArray &  ba, const amrex::DistributionMapping &  dm  )

private

AllocLevelMFs()

void WarpX::AllocLevelMFs ( int  lev, const amrex::BoxArray &  ba, const amrex::DistributionMapping &  dm, const amrex::IntVect &  ngEB, amrex::IntVect &  ngJ, const amrex::IntVect &  ngRho, const amrex::IntVect &  ngF, const amrex::IntVect &  ngG, bool  aux_is_nodal  )

private

AllocLevelSpectralSolverRZ()

void WarpX::AllocLevelSpectralSolverRZ ( amrex::Vector< std::unique_ptr< SpectralSolverRZ >> &  spectral_solver, int  lev, const amrex::BoxArray &  realspace_ba, const amrex::DistributionMapping &  dm, const std::array< amrex::Real, 3 > &  dx  )

private

ApplyBCKCorrection()

void WarpX::ApplyBCKCorrection

(

int

idim

)

Whenever an unstable cell cannot be extended we increase its area to be the minimal for stability. This is the method Benkler-Chavannes-Kuster method and it is less accurate than the regular ECT but it still works better than staircasing. (see https://ieeexplore.ieee.org/document/1638381)

Parameters

idim	Integer indicating the dimension (x->0, y->1, z->2) for which the BCK correction is done

ApplyBfieldBoundary()

void WarpX::ApplyBfieldBoundary	(	int	lev,
		PatchType	patch_type,
		DtType	dt_type
	)

ApplyEfieldBoundary()

void WarpX::ApplyEfieldBoundary	(	int	lev,
		PatchType	patch_type
	)

ApplyElectronPressureBoundary()

void WarpX::ApplyElectronPressureBoundary	(	int	lev,
		PatchType	patch_type
	)

When the Ohm's law solver is used, the electron pressure values on PEC boundaries are set to enforce a zero derivative Neumann condition, otherwise the E_perp values have large spikes (that grows as 1/dx). This has to be done since the E-field is algebraically calculated instead of evolved which means the 1/dx growth is not avoided by multiplication with dt as happens in the B-field evolve.

ApplyFieldBoundaryOnAxis()

void WarpX::ApplyFieldBoundaryOnAxis	(	amrex::MultiFab *	Er,
		amrex::MultiFab *	Et,
		amrex::MultiFab *	Ez,
		int	lev
	)		const

ApplyFilterandSumBoundaryRho() [1/2]

void WarpX::ApplyFilterandSumBoundaryRho ( const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_cp, int  lev, PatchType  patch_type, int  icomp, int  ncomp  )

private

ApplyFilterandSumBoundaryRho() [2/2]

void WarpX::ApplyFilterandSumBoundaryRho	(	int	lev,
		int	glev,
		amrex::MultiFab &	rho,
		int	icomp,
		int	ncomp
	)

ApplyFilterJ() [1/2]

void WarpX::ApplyFilterJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  current, int  lev  )

private

ApplyFilterJ() [2/2]

void WarpX::ApplyFilterJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  current, int  lev, int  idim  )

private

ApplyInverseVolumeScalingToChargeDensity()

void WarpX::ApplyInverseVolumeScalingToChargeDensity	(	amrex::MultiFab *	Rho,
		int	lev
	)

ApplyInverseVolumeScalingToCurrentDensity()

void WarpX::ApplyInverseVolumeScalingToCurrentDensity	(	amrex::MultiFab *	Jx,
		amrex::MultiFab *	Jy,
		amrex::MultiFab *	Jz,
		int	lev
	)

ApplyJfieldBoundary()

void WarpX::ApplyJfieldBoundary	(	int	lev,
		amrex::MultiFab *	Jx,
		amrex::MultiFab *	Jy,
		amrex::MultiFab *	Jz,
		PatchType	patch_type
	)

If a PEC boundary conditions is used the current density deposited in the guard cells have to be reflected back into the simulation domain. This function performs that logic.

applyMirrors()

void WarpX::applyMirrors

(

amrex::Real

time

)

ApplyRhofieldBoundary()

void WarpX::ApplyRhofieldBoundary	(	int	lev,
		amrex::MultiFab *	Rho,
		PatchType	patch_type
	)

If a PEC boundary conditions is used the charge density deposited in the guard cells have to be reflected back into the simulation domain. This function performs that logic.

AverageAndPackFields()

void WarpX::AverageAndPackFields	(	amrex::Vector< std::string > &	varnames,
		amrex::Vector< amrex::MultiFab > &	mf_avg,
		amrex::IntVect	ngrow
	)		const

BackwardCompatibility()

void WarpX::BackwardCompatibility ( )

private

This function queries deprecated input parameters and abort the run if one of them is specified.

BuildBufferMasks()

void WarpX::BuildBufferMasks ( )

private

BuildBufferMasksInBox()

void WarpX::BuildBufferMasksInBox	(	amrex::Box	tbx,
		amrex::IArrayBox &	buffer_mask,
		const amrex::IArrayBox &	guard_mask,
		int	ng
	)

Build buffer mask within given FArrayBox.

Parameters

tbx	Current FArrayBox
buffer_mask	Buffer mask to be set
guard_mask	Guard mask used to set buffer_mask
ng	Number of guard cells

CellSize()

std::array< Real, 3 > WarpX::CellSize ( int  lev )

static

checkEarlyUnusedParams()

void WarpX::checkEarlyUnusedParams ( )

private

Print Unused Parameter Warnings after Step 1

Instead of waiting for a simulation to end, we already do an early "unused parameter check" after step 1 to inform users early of potential issues with their simulation setup.

CheckGuardCells()

void WarpX::CheckGuardCells ( )

private

Check that the number of guard cells is smaller than the number of valid cells, for all available MultiFabs, and abort otherwise.

CheckKnownIssues()

void WarpX::CheckKnownIssues ( )

private

Checks for known numerical issues involving different WarpX modules.

CheckLoadBalance()

void WarpX::CheckLoadBalance

(

int

step

)

Check and potentially compute load balancing

checkStopSimulation()

bool WarpX::checkStopSimulation ( amrex::Real  cur_time )

private

Stop the simulation at the end of the current step?

ClearLevel()

void WarpX::ClearLevel ( int  lev )

finalprotectedvirtual

Delete level data. Called by AmrCore::regrid.

Implements amrex::AmrCore.

computeB()

void WarpX::computeB	(	amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &	B,
		const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &	phi,
		std::array< amrex::Real, 3 >	beta = {{0,0,0}}
	)		const

ComputeCostsHeuristic()

void WarpX::ComputeCostsHeuristic

(

amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > > &

costs

)

adds particle and cell contributions in cells to compute heuristic cost in each box on each level, and records in costs

Parameters

[in]

costs

vector of (unique_ptr to) vectors; expected to be initialized to correct number of boxes and boxes per level

ComputeDistanceToEB()

void WarpX::ComputeDistanceToEB

(

)

Compute the level set function used for particle-boundary interaction.

ComputeDivB() [1/2]

void WarpX::ComputeDivB ( amrex::MultiFab &  divB, int  dcomp, const std::array< const amrex::MultiFab *const, 3 > &  B, const std::array< amrex::Real, 3 > &  dx  )

static

ComputeDivB() [2/2]

void WarpX::ComputeDivB ( amrex::MultiFab &  divB, int  dcomp, const std::array< const amrex::MultiFab *const, 3 > &  B, const std::array< amrex::Real, 3 > &  dx, amrex::IntVect  ngrow  )

static

ComputeDivE()

void WarpX::ComputeDivE	(	amrex::MultiFab &	divE,
		int	lev
	)

ComputeDt()

void WarpX::ComputeDt

(

)

Determine the timestep of the simulation.

computeE()

void WarpX::computeE	(	amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &	E,
		const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &	phi,
		std::array< amrex::Real, 3 >	beta = {{0,0,0}}
	)		const

ComputeEightWaysExtensions()

void WarpX::ComputeEightWaysExtensions

(

)

Do the eight-ways extension.

ComputeFaceExtensions()

void WarpX::ComputeFaceExtensions

(

)

Main function computing the cell extension. Where possible it computes one-way extensions and, when this is not possible, it does eight-ways extensions.

ComputeMagnetostaticField()

void WarpX::ComputeMagnetostaticField

(

)

ComputeMaxStep()

void WarpX::ComputeMaxStep

(

)

Compute the last time step of the simulation Calls computeMaxStepBoostAccelerator() if required.

computeMaxStepBoostAccelerator()

void WarpX::computeMaxStepBoostAccelerator

(

)

ComputeOneWayExtensions()

void WarpX::ComputeOneWayExtensions

(

)

Do the one-way extension.

computePhi()

void WarpX::computePhi	(	const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &	rho,
		amrex::Vector< std::unique_ptr< amrex::MultiFab > > &	phi,
		std::array< amrex::Real, 3 >	beta = {{0,0,0}},
		amrex::Real	required_precision = amrex::Real(1.e-11),
		amrex::Real	absolute_tolerance = amrex::Real(0.0),
		int	max_iters = 200,
		int	verbosity = 2
	)		const

computePhiTriDiagonal()

void WarpX::computePhiTriDiagonal	(	const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &	rho,
		amrex::Vector< std::unique_ptr< amrex::MultiFab > > &	phi
	)		const

ComputePMLFactors()

void WarpX::ComputePMLFactors ( )

private

ComputeSpaceChargeField()

void WarpX::ComputeSpaceChargeField

(

bool

reset_fields

)

computeVectorPotential()

void WarpX::computeVectorPotential	(	const amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &	curr,
		amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &	A,
		amrex::Real	required_precision = amrex::Real(1.e-11),
		amrex::Real	absolute_tolerance = amrex::Real(0.0),
		int	max_iters = 200,
		int	verbosity = 2
	)		const

CopyJPML()

void WarpX::CopyJPML

(

)

Copy the current J from the regular grid to the PML.

CountExtFaces()

amrex::Array1D< int, 0, 2 > WarpX::CountExtFaces

(

)

Auxiliary function to count the amount of faces which still need to be extended.

CurrentBufferMasks()

const iMultiFab * WarpX::CurrentBufferMasks ( int  lev )

static

DampFieldsInGuards() [1/2]

void WarpX::DampFieldsInGuards	(	int	lev,
		const std::array< std::unique_ptr< amrex::MultiFab >, 3 > &	Efield,
		const std::array< std::unique_ptr< amrex::MultiFab >, 3 > &	Bfield
	)

Private function for spectral solver Applies a damping factor in the guards cells that extend beyond the extent of the domain, reducing fluctuations that can appear in parallel simulations. This will be called when FieldBoundaryType is set to damped. Vector version.

DampFieldsInGuards() [2/2]

void WarpX::DampFieldsInGuards	(	int	lev,
		std::unique_ptr< amrex::MultiFab > &	mf
	)

Private function for spectral solver Applies a damping factor in the guards cells that extend beyond the extent of the domain, reducing fluctuations that can appear in parallel simulations. This will be called when FieldBoundaryType is set to damped. Scalar version.

DampJPML() [1/3]

void WarpX::DampJPML

(

)

DampJPML() [2/3]

void WarpX::DampJPML

(

int

lev

)

DampJPML() [3/3]

void WarpX::DampJPML	(	int	lev,
		PatchType	patch_type
	)

DampPML() [1/3]

void WarpX::DampPML

(

)

DampPML() [2/3]

void WarpX::DampPML

(

int

lev

)

DampPML() [3/3]

void WarpX::DampPML	(	int	lev,
		PatchType	patch_type
	)

DampPML_Cartesian()

void WarpX::DampPML_Cartesian	(	int	lev,
		PatchType	patch_type
	)

doFieldIonization() [1/2]

void WarpX::doFieldIonization

(

)

Run the ionization module on all species

doFieldIonization() [2/2]

void WarpX::doFieldIonization

(

int

lev

)

Run the ionization module on all species at level lev

Parameters

lev

level

DoFluidSpecies()

bool WarpX::DoFluidSpecies ( ) const

inline

DoPML()

bool WarpX::DoPML ( ) const

inline

doQEDEvents() [1/2]

void WarpX::doQEDEvents

(

)

Run the QED module on all species

doQEDEvents() [2/2]

void WarpX::doQEDEvents

(

int

lev

)

Run the QED module on all species at level lev

Parameters

lev

level

ErrorEst()

void WarpX::ErrorEst ( int  lev, amrex::TagBoxArray &  tags, amrex::Real  time, int    )

final

Tagging cells for refinement.

Evolve()

void WarpX::Evolve

(

int

numsteps = -1

)

reduced diags

EvolveB() [1/3]

void WarpX::EvolveB	(	amrex::Real	dt,
		DtType	dt_type
	)

EvolveB() [2/3]

void WarpX::EvolveB	(	int	lev,
		amrex::Real	dt,
		DtType	dt_type
	)

EvolveB() [3/3]

void WarpX::EvolveB	(	int	lev,
		PatchType	patch_type,
		amrex::Real	dt,
		DtType	dt_type
	)

EvolveE() [1/3]

void WarpX::EvolveE

(

amrex::Real

dt

)

EvolveE() [2/3]

void WarpX::EvolveE	(	int	lev,
		amrex::Real	dt
	)

EvolveE() [3/3]

void WarpX::EvolveE	(	int	lev,
		PatchType	patch_type,
		amrex::Real	dt
	)

EvolveF() [1/3]

void WarpX::EvolveF	(	amrex::Real	dt,
		DtType	dt_type
	)

EvolveF() [2/3]

void WarpX::EvolveF	(	int	lev,
		amrex::Real	dt,
		DtType	dt_type
	)

EvolveF() [3/3]

void WarpX::EvolveF	(	int	lev,
		PatchType	patch_type,
		amrex::Real	dt,
		DtType	dt_type
	)

EvolveG() [1/3]

void WarpX::EvolveG	(	amrex::Real	dt,
		DtType	dt_type
	)

EvolveG() [2/3]

void WarpX::EvolveG	(	int	lev,
		amrex::Real	dt,
		DtType	dt_type
	)

EvolveG() [3/3]

void WarpX::EvolveG	(	int	lev,
		PatchType	patch_type,
		amrex::Real	dt,
		DtType	dt_type
	)

EvolveImplicitPicardInit()

void WarpX::EvolveImplicitPicardInit

(

int

lev

)

ExplicitFillBoundaryEBUpdateAux()

void WarpX::ExplicitFillBoundaryEBUpdateAux ( )

private

Update the E and B fields in the explicit em PIC scheme.

At the beginning, we have B^{n} and E^{n}. Particles have p^{n} and x^{n}.

fieldFactory()

amrex::FabFactory<amrex::FArrayBox> const& WarpX::fieldFactory ( int  lev ) const

inlineprivatenoexcept

FillBoundaryAux() [1/2]

void WarpX::FillBoundaryAux

(

amrex::IntVect

ng

)

FillBoundaryAux() [2/2]

void WarpX::FillBoundaryAux	(	int	lev,
		amrex::IntVect	ng
	)

FillBoundaryB() [1/3]

void WarpX::FillBoundaryB	(	amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryB() [2/3]

void WarpX::FillBoundaryB	(	int	lev,
		amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryB() [3/3]

void WarpX::FillBoundaryB ( int  lev, PatchType  patch_type, amrex::IntVect  ng, std::optional< bool >  nodal_sync = std::nullopt  )

private

FillBoundaryB_avg() [1/3]

void WarpX::FillBoundaryB_avg

(

amrex::IntVect

ng

)

FillBoundaryB_avg() [2/3]

void WarpX::FillBoundaryB_avg	(	int	lev,
		amrex::IntVect	ng
	)

FillBoundaryB_avg() [3/3]

void WarpX::FillBoundaryB_avg ( int  lev, PatchType  patch_type, amrex::IntVect  ng  )

private

FillBoundaryE() [1/3]

void WarpX::FillBoundaryE	(	amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryE() [2/3]

void WarpX::FillBoundaryE	(	int	lev,
		amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryE() [3/3]

void WarpX::FillBoundaryE ( int  lev, PatchType  patch_type, amrex::IntVect  ng, std::optional< bool >  nodal_sync = std::nullopt  )

private

FillBoundaryE_avg() [1/3]

void WarpX::FillBoundaryE_avg

(

amrex::IntVect

ng

)

FillBoundaryE_avg() [2/3]

void WarpX::FillBoundaryE_avg	(	int	lev,
		amrex::IntVect	ng
	)

FillBoundaryE_avg() [3/3]

void WarpX::FillBoundaryE_avg ( int  lev, PatchType  patch_type, amrex::IntVect  ng  )

private

FillBoundaryF() [1/3]

void WarpX::FillBoundaryF	(	amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryF() [2/3]

void WarpX::FillBoundaryF	(	int	lev,
		amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryF() [3/3]

void WarpX::FillBoundaryF ( int  lev, PatchType  patch_type, amrex::IntVect  ng, std::optional< bool >  nodal_sync = std::nullopt  )

private

FillBoundaryG() [1/3]

void WarpX::FillBoundaryG	(	amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryG() [2/3]

void WarpX::FillBoundaryG	(	int	lev,
		amrex::IntVect	ng,
		std::optional< bool >	nodal_sync = std::nullopt
	)

FillBoundaryG() [3/3]

void WarpX::FillBoundaryG ( int  lev, PatchType  patch_type, amrex::IntVect  ng, std::optional< bool >  nodal_sync = std::nullopt  )

private

Finalize()

void WarpX::Finalize ( )

static

This method has to be called at the end of the simulation. It deletes the WarpX instance.

FinishImplicitFieldUpdate()

void WarpX::FinishImplicitFieldUpdate	(	amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &	Efield_fp,
		amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > &	Efield_n
	)

FinishImplicitParticleUpdate()

void WarpX::FinishImplicitParticleUpdate	(	WarpXParticleContainer &	pc,
		int	lev
	)

GatherBufferMasks()

const iMultiFab * WarpX::GatherBufferMasks ( int  lev )

static

get_accelerator_lattice()

const AcceleratorLattice& WarpX::get_accelerator_lattice ( int  lev )

inline

get_load_balance_intervals()

utils::parser::IntervalsParser WarpX::get_load_balance_intervals ( ) const

inline

returns the load balance interval

get_ng_depos_J()

amrex::IntVect WarpX::get_ng_depos_J ( ) const

inline

get_ng_depos_rho()

amrex::IntVect WarpX::get_ng_depos_rho ( ) const

inline

get_ng_fieldgather()

amrex::IntVect WarpX::get_ng_fieldgather ( ) const

inline

get_numprocs()

amrex::IntVect WarpX::get_numprocs ( ) const

inline

Coarsest-level Domain Decomposition

If specified, the domain will be chopped into the exact number of pieces in each dimension as specified by this parameter.

Returns

the number of MPI processes per dimension if specified, otherwise a 0-vector

get_pointer_fdtd_solver_fp()

FiniteDifferenceSolver* WarpX::get_pointer_fdtd_solver_fp ( int  lev )

inline

get_pointer_HybridPICModel()

HybridPICModel* WarpX::get_pointer_HybridPICModel ( ) const

inline

get_spectral_solver_fp()

SpectralSolverRZ& WarpX::get_spectral_solver_fp ( int  lev )

inline

GetAuthors()

std::string WarpX::GetAuthors ( ) const

inline

If an authors' string is specified in the inputfile, this method returns that string. Otherwise, it returns an empty string.

getCosts()

amrex::LayoutData< amrex::Real > * WarpX::getCosts ( int  lev )

static

getCurrentBufferMasks()

const amrex::iMultiFab* WarpX::getCurrentBufferMasks ( int  lev ) const

inlineprivate

getdo_moving_window()

int WarpX::getdo_moving_window ( ) const

inline

getdt() [1/2]

amrex::Vector<amrex::Real> WarpX::getdt ( ) const

inline

getdt() [2/2]

amrex::Real WarpX::getdt ( int  lev ) const

inline

getField()

const amrex::MultiFab & WarpX::getField	(	FieldType	field_type,
		int	lev,
		int	direction = 0
	)		const

Get a constant reference to the field data.

Parameters

field_type[in]	the field type
lev[in]	the mesh refinement level
direction[in]	the field component (0 by default)

Returns

a constant refernce to an amrex::MultiFab containing the field data

getFieldPointer()

amrex::MultiFab * WarpX::getFieldPointer	(	FieldType	field_type,
		int	lev,
		int	direction = 0
	)		const

Get a pointer to the field data.

Parameters

field_type[in]	the field type
lev[in]	the mesh refinement level
direction[in]	the field component (0 by default)

Returns

the pointer to an amrex::MultiFab containing the field data

getFieldPointerArray()

std::array< const amrex::MultiFab *const, 3 > WarpX::getFieldPointerArray	(	FieldType	field_type,
		int	lev
	)		const

For vector fields, get an array of three pointers to the field data.

Parameters

field_type[in]	the field type
lev[in]	the mesh refinement level

Returns

an array of three pointers amrex::MultiFab* containing the field data

getFieldPointerUnchecked()

amrex::MultiFab * WarpX::getFieldPointerUnchecked ( FieldType  field_type, int  lev, int  direction = 0  ) const

private

Get a pointer to the field data. Does not check if the pointer is not nullptr.

Parameters

field_type[in]	the field type
lev[in]	the mesh refinement level
direction[in]	the field component (0 by default)

Returns

the pointer to an amrex::MultiFab containing the field data

GetFluidContainer()

MultiFluidContainer& WarpX::GetFluidContainer ( )

inline

getFornbergStencilCoefficients()

amrex::Vector< amrex::Real > WarpX::getFornbergStencilCoefficients ( int  n_order, short  a_grid_type  )

static

Returns an array of coefficients (Fornberg coefficients), corresponding to the weight of each point in a finite-difference approximation of a derivative (up to order n_order).

Parameters

[in]	n_order	order of the finite-difference approximation
[in]	a_grid_type	type of grid (collocated or not)

getGatherBufferMasks()

const amrex::iMultiFab* WarpX::getGatherBufferMasks ( int  lev ) const

inlineprivate

GetHybridPICModel()

HybridPICModel& WarpX::GetHybridPICModel ( )

inline

GetInstance()

WarpX & WarpX::GetInstance ( )

static

getis_synchronized()

bool WarpX::getis_synchronized ( ) const

inline

getistep() [1/2]

amrex::Vector<int> WarpX::getistep ( ) const

inline

getistep() [2/2]

int WarpX::getistep ( int  lev ) const

inline

getLoadBalanceEfficiency()

amrex::Real WarpX::getLoadBalanceEfficiency

(

int

lev

)

GetMacroscopicProperties()

MacroscopicProperties& WarpX::GetMacroscopicProperties ( )

inline

getmoving_window_x()

amrex::Real WarpX::getmoving_window_x ( ) const

inline

GetMultiDiags()

MultiDiagnostics& WarpX::GetMultiDiags ( )

inline

getngEB()

amrex::IntVect WarpX::getngEB ( ) const

inline

getngF()

amrex::IntVect WarpX::getngF ( ) const

inline

getngUpdateAux()

amrex::IntVect WarpX::getngUpdateAux ( ) const

inline

getnsubsteps() [1/2]

amrex::Vector<int> WarpX::getnsubsteps ( ) const

inline

getnsubsteps() [2/2]

int WarpX::getnsubsteps ( int  lev ) const

inline

GetPartContainer()

MultiParticleContainer& WarpX::GetPartContainer ( )

inline

GetParticleBoundaryBuffer()

ParticleBoundaryBuffer& WarpX::GetParticleBoundaryBuffer ( )

inline

GetPML()

PML * WarpX::GetPML

(

int

lev

)

GetPML_RZ()

PML_RZ * WarpX::GetPML_RZ

(

int

lev

)

getPMLdirections()

std::vector< bool > WarpX::getPMLdirections

(

)

const

get low-high-low-high-... vector for each direction indicating if mother grid PMLs are enabled

getPMLRZ()

const PML_RZ* WarpX::getPMLRZ ( )

inline

getRealBox()

amrex::RealBox WarpX::getRealBox ( const amrex::Box &  bx, int  lev  )

static

GetRestartDMap()

amrex::DistributionMapping WarpX::GetRestartDMap ( const std::string &  chkfile, const amrex::BoxArray &  ba, int  lev  ) const

private

gett_new() [1/2]

amrex::Vector<amrex::Real> WarpX::gett_new ( ) const

inline

gett_new() [2/2]

amrex::Real WarpX::gett_new ( int  lev ) const

inline

gett_old() [1/2]

amrex::Vector<amrex::Real> WarpX::gett_old ( ) const

inline

gett_old() [2/2]

amrex::Real WarpX::gett_old ( int  lev ) const

inline

HandleParticlesAtBoundaries()

void WarpX::HandleParticlesAtBoundaries ( int  step, amrex::Real  cur_time, int  num_moved  )

private

Perform essential particle house keeping at boundaries

Inject, communicate, scrape and sort particles.

Parameters

step	current step
cur_time	current time
num_moved	number of cells the moving window moved

HandleSignals()

void WarpX::HandleSignals ( )

private

Complete the asynchronous broadcast of signal flags, and initiate a checkpoint if requested.

Hybrid_QED_Push() [1/3]

void WarpX::Hybrid_QED_Push

(

amrex::Vector< amrex::Real >

dt

)

apply QED correction on electric field

Parameters

dt	vector of time steps (for all levels)

Hybrid_QED_Push() [2/3]

void WarpX::Hybrid_QED_Push	(	int	lev,
		amrex::Real	dt
	)

apply QED correction on electric field for level lev

Parameters

lev	mesh refinement level
dt	time step

Hybrid_QED_Push() [3/3]

void WarpX::Hybrid_QED_Push	(	int	lev,
		PatchType	patch_type,
		amrex::Real	dt
	)

apply QED correction on electric field for level lev and patch type patch_type

Parameters

lev	mesh refinement level
patch_type	which MR patch: PatchType::fine or PatchType::coarse
dt	time step

HybridPICDepositInitialRhoAndJ()

void WarpX::HybridPICDepositInitialRhoAndJ

(

)

Hybrid-PIC initial deposition function. The hybrid-PIC algorithm uses the charge and current density from both the current and previous step when updating the fields. This function deposits the initial ion charge and current (before the first particle push), to be used in the HybridPICEvolveFields() function.

HybridPICEvolveFields()

void WarpX::HybridPICEvolveFields

(

)

Hybrid-PIC field evolve function. This function contains the logic involved in evolving the electric and magnetic fields in the hybrid PIC algorithm.

InitBorrowing()

void WarpX::InitBorrowing

(

)

Initialize the memory for the FaceInfoBoxes.

InitData()

void WarpX::InitData

(

)

InitDiagnostics()

void WarpX::InitDiagnostics ( )

private

InitEB()

void WarpX::InitEB

(

)

InitFilter()

void WarpX::InitFilter ( )

private

InitFromCheckpoint()

void WarpX::InitFromCheckpoint ( )

private

InitFromScratch()

void WarpX::InitFromScratch ( )

private

InitializeEBGridData()

void WarpX::InitializeEBGridData

(

int

lev

)

This function initializes and calculates grid quantities used along with EBs such as edge lengths, face areas, distance to EB, etc. It also appropriately communicates EB data to guard cells.

Parameters

[in]

lev

level of the Multifabs that is initialized

InitializeExternalFieldsOnGridUsingParser()

void WarpX::InitializeExternalFieldsOnGridUsingParser	(	amrex::MultiFab *	mfx,
		amrex::MultiFab *	mfy,
		amrex::MultiFab *	mfz,
		amrex::ParserExecutor< 3 > const &	xfield_parser,
		amrex::ParserExecutor< 3 > const &	yfield_parser,
		amrex::ParserExecutor< 3 > const &	zfield_parser,
		std::array< std::unique_ptr< amrex::MultiFab >, 3 > const &	edge_lengths,
		std::array< std::unique_ptr< amrex::MultiFab >, 3 > const &	face_areas,
		char	field,
		int	lev,
		PatchType	patch_type
	)

This function initializes the E and B fields on each level using the parser and the user-defined function for the external fields. The subroutine will parse the x_/y_z_external_grid_function and then, the field multifab is initialized based on the (x,y,z) position on the staggered yee-grid or cell-centered grid, in the interior cells and guard cells.

Parameters

[in]	mfx	x-component of the field to be initialized
[in]	mfy	y-component of the field to be initialized
[in]	mfz	z-component of the field to be initialized
[in]	xfield_parser	parser function to initialize x-field
[in]	yfield_parser	parser function to initialize y-field
[in]	zfield_parser	parser function to initialize z-field
[in]	edge_lengths	edge lengths information
[in]	face_areas	face areas information
[in]	field	flag indicating which field is being initialized ('E' for electric, 'B' for magnetic)
[in]	lev	level of the Multifabs that is initialized
[in]	patch_type	PatchType on which the field is initialized (fine or coarse)

InitLevelData()

void WarpX::InitLevelData ( int  lev, amrex::Real  time  )

protected

This function initializes E, B, rho, and F, at all the levels of the multifab. rho and F are initialized with 0. The E and B fields are initialized using user-defined inputs. The initialization type is set using "B_ext_grid_init_style" and "E_ext_grid_init_style". The initialization style is set to "default" if not explicitly defined by the user, and the E and B fields are initialized with E_external_grid and B_external_grid, respectively, each with a default value of 0. If the initialization type for the E and B field is "constant", then, the E and B fields at all the levels are initialized with user-defined values for E_external_grid and B_external_grid. If the initialization type for B-field is set to "parse_ext_grid_function", then, the parser is used to read Bx_external_grid_function(x,y,z), By_external_grid_function(x,y,z), and Bz_external_grid_function(x,y,z). Similarly, if the E-field initialization type is set to "parse_ext_grid_function", then, the parser is used to read Ex_external_grid_function(x,y,z), Ey_external_grid_function(x,y,z), and Ex_external_grid_function(x,y,z). The parser for the E and B initialization assumes that the function has three independent variables, at max, namely, x, y, z. However, any number of constants can be used in the function used to define the E and B fields on the grid.

InitNCICorrector()

void WarpX::InitNCICorrector ( )

private

InitPML()

void WarpX::InitPML ( )

private

isAnyBoundaryPML()

bool WarpX::isAnyBoundaryPML

(

)

isAnyParticleBoundaryThermal()

bool WarpX::isAnyParticleBoundaryThermal ( )

static

True if any of the particle boundary condition type is Thermal

isFieldInitialized()

bool WarpX::isFieldInitialized	(	FieldType	field_type,
		int	lev,
		int	direction = 0
	)		const

Check if a field is initialized.

Parameters

field_type[in]	the field type
lev[in]	the mesh refinement level
direction[in]	the field component (0 by default)

Returns

true if the field is initialized, false otherwise

LoadBalance()

void WarpX::LoadBalance

(

)

perform load balance; compute and communicate new amrex::DistributionMapping

LoadExternalFieldsFromFile()

void WarpX::LoadExternalFieldsFromFile

(

int

lev

)

Load field values from a user-specified openPMD file, for the fields Ex, Ey, Ez, Bx, By, Bz.

LowerCorner()

std::array< Real, 3 > WarpX::LowerCorner ( const amrex::Box &  bx, int  lev, amrex::Real  time_shift_delta  )

static

Return the lower corner of the box in real units.

Parameters

bx	The box
lev	The refinement level of the box
time_shift_delta	The time relative to the current time at which to calculate the position (when v_galilean is not zero)

Returns

An array of the position coordinates

MacroscopicEvolveE() [1/3]

void WarpX::MacroscopicEvolveE

(

amrex::Real

dt

)

MacroscopicEvolveE() [2/3]

void WarpX::MacroscopicEvolveE	(	int	lev,
		amrex::Real	dt
	)

MacroscopicEvolveE() [3/3]

void WarpX::MacroscopicEvolveE	(	int	lev,
		PatchType	patch_type,
		amrex::Real	dt
	)

MakeNewLevelFromCoarse()

void WarpX::MakeNewLevelFromCoarse ( int  , amrex::Real  , const amrex::BoxArray &  , const amrex::DistributionMapping &    )

finalprotected

Make a new level using provided BoxArray and DistributionMapping and fill with interpolated coarse level data. Called by AmrCore::regrid.

MakeNewLevelFromScratch()

void WarpX::MakeNewLevelFromScratch ( int  lev, amrex::Real  time, const amrex::BoxArray &  new_grids, const amrex::DistributionMapping &  new_dmap  )

finalprotected

Make a new level from scratch using provided BoxArray and DistributionMapping. Only used during initialization. Called by AmrCoreInitFromScratch.

MakeWarpX()

void WarpX::MakeWarpX ( )

staticprivate

This method creates a new instance of the WarpX class.

maxStep()

int WarpX::maxStep ( ) const

inline

MoveWindow()

int WarpX::MoveWindow	(	int	step,
		bool	move_j
	)

Move the moving window.

Parameters

step	Time step
move_j	whether the current (and the charge, if allocated) is shifted or not

moving_window_active()

static int WarpX::moving_window_active ( int const  step )

inlinestatic

Returns true if the moving window is active for the provided step

Parameters

step

time step

Returns

true if active, else false

NodalSyncJ()

void WarpX::NodalSyncJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_cp, int  lev, PatchType  patch_type  )

private

NodalSyncRho()

void WarpX::NodalSyncRho ( const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_cp, int  lev, PatchType  patch_type, int  icomp, int  ncomp  )

private

OneStep_ImplicitPicard()

void WarpX::OneStep_ImplicitPicard ( amrex::Real  cur_time )

private

OneStep_multiJ()

void WarpX::OneStep_multiJ ( amrex::Real  cur_time )

private

Perform one PIC iteration, with the multiple J deposition per time step.

OneStep_nosub()

void WarpX::OneStep_nosub ( amrex::Real  cur_time )

private

OneStep_sub1()

void WarpX::OneStep_sub1 ( amrex::Real  cur_time )

private

operator=() [1/2]

WarpX& WarpX::operator= ( WarpX &&  )

default

Move operator

operator=() [2/2]

WarpX& WarpX::operator= ( WarpX const &  )

delete

Copy operator

PerformanceHints()

void WarpX::PerformanceHints ( )

private

Check the requested resources and write performance hints

PicsarVersion()

std::string WarpX::PicsarVersion ( )

static

Version of PICSAR dependency.

PostProcessBaseGrids()

void WarpX::PostProcessBaseGrids ( amrex::BoxArray &  ba0 ) const

finalprotectedvirtual

Use this function to override the Level 0 grids made by AMReX. This function is called in amrex::AmrCore::InitFromScratch.

create object for reduced diagnostics

Reimplemented from amrex::AmrMesh.

PostRestart()

void WarpX::PostRestart ( )

private

prepareFields()

void WarpX::prepareFields	(	int	step,
		amrex::Vector< std::string > &	varnames,
		amrex::Vector< amrex::MultiFab > &	mf_avg,
		amrex::Vector< const amrex::MultiFab * > &	output_mf,
		amrex::Vector< amrex::Geometry > &	output_geom
	)		const

PrintDtDxDyDz()

void WarpX::PrintDtDxDyDz

(

)

Print dt and dx,dy,dz

PrintMainPICparameters()

void WarpX::PrintMainPICparameters

(

)

Print main PIC parameters to stdout

PSATDBackwardTransformEB()

void WarpX::PSATDBackwardTransformEB ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  E_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  B_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  E_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  B_cp  )

private

Backward FFT of E,B on all mesh refinement levels, with field damping in the guard cells (if needed)

Parameters

E_fp	Vector of three-dimensional arrays (for each level) storing the fine patch electric field to be transformed
B_fp	Vector of three-dimensional arrays (for each level) storing the fine patch magnetic field to be transformed
E_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch electric field to be transformed
B_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch magnetic field to be transformed

PSATDBackwardTransformEBavg()

void WarpX::PSATDBackwardTransformEBavg ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  E_avg_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  B_avg_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  E_avg_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  B_avg_cp  )

private

Backward FFT of averaged E,B on all mesh refinement levels.

Parameters

E_avg_fp	Vector of three-dimensional arrays (for each level) storing the fine patch averaged electric field to be transformed
B_avg_fp	Vector of three-dimensional arrays (for each level) storing the fine patch averaged magnetic field to be transformed
E_avg_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch averaged electric field to be transformed
B_avg_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch averaged magnetic field to be transformed

PSATDBackwardTransformF()

void WarpX::PSATDBackwardTransformF ( )

private

Backward FFT of F on all mesh refinement levels.

PSATDBackwardTransformG()

void WarpX::PSATDBackwardTransformG ( )

private

Backward FFT of G on all mesh refinement levels.

PSATDBackwardTransformJ()

void WarpX::PSATDBackwardTransformJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_cp  )

private

Backward FFT of J on all mesh refinement levels.

Parameters

J_fp	Vector of three-dimensional arrays (for each level) storing the fine patch current to be transformed
J_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch current to be transformed

PSATDCurrentCorrection()

void WarpX::PSATDCurrentCorrection ( )

private

Correct current in Fourier space so that the continuity equation is satisfied.

PSATDEraseAverageFields()

void WarpX::PSATDEraseAverageFields ( )

private

Set averaged E,B fields to zero before new iteration.

PSATDForwardTransformEB()

void WarpX::PSATDForwardTransformEB ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  E_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  B_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  E_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  B_cp  )

private

Forward FFT of E,B on all mesh refinement levels.

Parameters

E_fp	Vector of three-dimensional arrays (for each level) storing the fine patch electric field to be transformed
B_fp	Vector of three-dimensional arrays (for each level) storing the fine patch magnetic field to be transformed
E_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch electric field to be transformed
B_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch magnetic field to be transformed

PSATDForwardTransformF()

void WarpX::PSATDForwardTransformF ( )

private

Forward FFT of F on all mesh refinement levels.

PSATDForwardTransformG()

void WarpX::PSATDForwardTransformG ( )

private

Forward FFT of G on all mesh refinement levels.

PSATDForwardTransformJ()

void WarpX::PSATDForwardTransformJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_cp, bool  apply_kspace_filter = true  )

private

Forward FFT of J on all mesh refinement levels, with k-space filtering (if needed)

Parameters

	J_fp	Vector of three-dimensional arrays (for each level) storing the fine patch current to be transformed
	J_cp	Vector of three-dimensional arrays (for each level) storing the coarse patch current to be transformed
[in]	apply_kspace_filter	Control whether to apply filtering (only used in RZ geometry to avoid double filtering)

PSATDForwardTransformRho()

void WarpX::PSATDForwardTransformRho ( const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_cp, int  icomp, int  dcomp, bool  apply_kspace_filter = true  )

private

Forward FFT of rho on all mesh refinement levels, with k-space filtering (if needed)

Parameters

	charge_fp	Vector (for each level) storing the fine patch charge to be transformed
	charge_cp	Vector (for each level) storing the coarse patch charge to be transformed
[in]	icomp	index of fourth component (0 for rho_old, 1 for rho_new)
[in]	dcomp	index of spectral component (0 for rho_old, 1 for rho_new)
[in]	apply_kspace_filter	Control whether to apply filtering (only used in RZ geometry to avoid double filtering)

PSATDMoveJNewToJOld()

void WarpX::PSATDMoveJNewToJOld ( )

private

Copy J_new to J_old in spectral space (when J is linear in time)

PSATDMoveRhoNewToRhoOld()

void WarpX::PSATDMoveRhoNewToRhoOld ( )

private

Copy rho_new to rho_old in spectral space (when rho is linear in time)

PSATDPushSpectralFields()

void WarpX::PSATDPushSpectralFields ( )

private

Update all necessary fields in spectral space.

PSATDScaleAverageFields()

void WarpX::PSATDScaleAverageFields ( amrex::Real  scale_factor )

private

Scale averaged E,B fields to account for time integration.

Parameters

[in]

scale_factor

scalar to multiply each field component by

PSATDSubtractCurrentPartialSumsAvg()

void WarpX::PSATDSubtractCurrentPartialSumsAvg

(

)

Subtract the average of the cumulative sums of the preliminary current D from the current J (computed from D according to the Vay deposition scheme)

PSATDVayDeposition()

void WarpX::PSATDVayDeposition ( )

private

Vay deposition in Fourier space (https://doi.org/10.1016/j.jcp.2013.03.010)

PushParticlesandDeposit() [1/2]

void WarpX::PushParticlesandDeposit	(	amrex::Real	cur_time,
		bool	skip_current = false,
		PushType	push_type = PushType::Explicit
	)

PushParticlesandDeposit() [2/2]

void WarpX::PushParticlesandDeposit	(	int	lev,
		amrex::Real	cur_time,
		DtType	a_dt_type = DtType::Full,
		bool	skip_current = false,
		PushType	push_type = PushType::Explicit
	)

PushPSATD()

void WarpX::PushPSATD ( )

private

ReadExternalFieldFromFile()

void WarpX::ReadExternalFieldFromFile	(	const std::string &	read_fields_from_path,
		amrex::MultiFab *	mf,
		const std::string &	F_name,
		const std::string &	F_component
	)

Load field values from a user-specified openPMD file for a specific field (specified by F_name)

ReadParameters()

void WarpX::ReadParameters ( )

private

RefRatio()

IntVect WarpX::RefRatio ( int  lev )

static

RemakeLevel()

void WarpX::RemakeLevel ( int  lev, amrex::Real  time, const amrex::BoxArray &  ba, const amrex::DistributionMapping &  dm  )

finalprotected

Remake an existing level using provided BoxArray and DistributionMapping and fill with existing fine and coarse data. Called by AmrCore::regrid.

ReorderFornbergCoefficients()

void WarpX::ReorderFornbergCoefficients ( amrex::Vector< amrex::Real > &  ordered_coeffs, amrex::Vector< amrex::Real > &  unordered_coeffs, int  order  )

private

Re-orders the Fornberg coefficients so that they can be used more conveniently for finite-order centering operations. For example, for finite-order centering of order 6, the Fornberg coefficients (c_0,c_1,c_2) are re-ordered as (c_2,c_1,c_0,c_0,c_1,c_2).

Parameters

[in,out]	ordered_coeffs	host vector where the re-ordered Fornberg coefficients will be stored
[in]	unordered_coeffs	host vector storing the original sequence of Fornberg coefficients
[in]	order	order of the finite-order centering along a given direction

RescaleCosts()

void WarpX::RescaleCosts

(

int

step

)

Perform running average of the LB costs

Only needed for timers cost update, heuristic load balance considers the instantaneous costs. This gives more importance to most recent costs.

ResetCosts()

void WarpX::ResetCosts

(

)

resets costs to zero

ResetInstance()

void WarpX::ResetInstance ( )

static

ResetProbDomain()

void WarpX::ResetProbDomain

(

const amrex::RealBox &

rb

)

RestoreCurrent()

void WarpX::RestoreCurrent ( int  lev )

private

RestrictCurrentFromFineToCoarsePatch()

void WarpX::RestrictCurrentFromFineToCoarsePatch ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  J_cp, int  lev  )

private

Fills the values of the current on the coarse patch by averaging the values of the current of the fine patch (on the same level).

RestrictRhoFromFineToCoarsePatch()

void WarpX::RestrictRhoFromFineToCoarsePatch ( const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &  charge_cp, int  lev  )

private

SaveParticlesAtImplicitStepStart()

void WarpX::SaveParticlesAtImplicitStepStart	(	WarpXParticleContainer &	pc,
		int	lev
	)

ScrapeParticles()

void WarpX::ScrapeParticles ( )

private

setistep()

void WarpX::setistep ( int  lev, int  ii  )

inline

setLoadBalanceEfficiency()

void WarpX::setLoadBalanceEfficiency	(	int	lev,
		amrex::Real	efficiency
	)

setPhiBC()

void WarpX::setPhiBC

(

amrex::Vector< std::unique_ptr< amrex::MultiFab > > &

phi

)

const

sett_new()

void WarpX::sett_new ( int  lev, amrex::Real  time  )

inline

setVectorPotentialBC()

void WarpX::setVectorPotentialBC

(

amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &

A

)

const

ShiftGalileanBoundary()

void WarpX::ShiftGalileanBoundary

(

)

This function shifts the boundary of the grid by 'm_v_galilean*dt'. In doding so, only positions attributes are changed while fields remain unchanged.

shiftMF()

void WarpX::shiftMF ( amrex::MultiFab &  mf, const amrex::Geometry &  geom, int  num_shift, int  dir, int  lev, bool  update_cost_flag, amrex::Real  external_field = 0.0, bool  useparser = false, amrex::ParserExecutor< 3 > const &  field_parser = {}  )

static

ShrinkBorrowing()

void WarpX::ShrinkBorrowing

(

)

Shrink the vectors in the FaceInfoBoxes.

stopTime()

amrex::Real WarpX::stopTime ( ) const

inline

StoreCurrent()

void WarpX::StoreCurrent ( int  lev )

private

SumBoundaryJ() [1/2]

void WarpX::SumBoundaryJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  current, int  lev, const amrex::Periodicity &  period  )

private

SumBoundaryJ() [2/2]

void WarpX::SumBoundaryJ ( const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &  current, int  lev, int  idim, const amrex::Periodicity &  period  )

private

SyncCurrent()

void WarpX::SyncCurrent	(	const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &	J_fp,
		const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &	J_cp,
		const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &	J_buffer
	)

Apply filter and sum guard cells across MR levels. If current centering is used, center the current from a nodal grid to a staggered grid. For each MR level beyond level 0, interpolate the fine-patch current onto the coarse-patch current at the same level. Then, for each MR level, including level 0, apply filter and sum guard cells across levels.

Parameters

[in,out]	J_fp	reference to fine-patch current MultiFab (all MR levels)
[in,out]	J_cp	reference to coarse-patch current MultiFab (all MR levels)
[in,out]	J_buffer	reference to buffer current MultiFab (all MR levels)

SyncCurrentAndRho()

void WarpX::SyncCurrentAndRho

(

)

Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels and apply boundary conditions. Contains separate calls to WarpX::SyncCurrent and WarpX::SyncRho.

SyncRho() [1/2]

void WarpX::SyncRho

(

)

SyncRho() [2/2]

void WarpX::SyncRho	(	const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	charge_fp,
		const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	charge_cp,
		const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &	charge_buffer
	)

UpdateAuxilaryData()

void WarpX::UpdateAuxilaryData

(

)

UpdateAuxilaryDataSameType()

void WarpX::UpdateAuxilaryDataSameType

(

)

UpdateAuxilaryDataStagToNodal()

void WarpX::UpdateAuxilaryDataStagToNodal

(

)

UpdateCurrentNodalToStag()

void WarpX::UpdateCurrentNodalToStag	(	amrex::MultiFab &	dst,
		amrex::MultiFab const &	src
	)

This function is called if warpx.do_current_centering = 1 and it centers the currents from a nodal grid to a staggered grid (Yee) using finite-order interpolation based on the Fornberg coefficients.

Parameters

[in,out]	dst	destination MultiFab where the results of the finite-order centering are stored
[in]	src	source MultiFab that contains the values of the nodal current to be centered

UpdateInjectionPosition()

void WarpX::UpdateInjectionPosition

(

amrex::Real

dt

)

Update injection position for continuous injection of particles and lasers (loops over species and lasers).

updateMaxStep()

void WarpX::updateMaxStep ( const int  new_max_step )

inline

updateStopTime()

void WarpX::updateStopTime ( const amrex::Real  new_stop_time )

inline

UpperCorner()

std::array< Real, 3 > WarpX::UpperCorner ( const amrex::Box &  bx, int  lev, amrex::Real  time_shift_delta  )

static

Return the upper corner of the box in real units.

Parameters

bx	The box
lev	The refinement level of the box
time_shift_delta	The time relative to the current time at which to calculate the position (when v_galilean is not zero)

Returns

An array of the position coordinates

Verbose()

int WarpX::Verbose ( ) const

inline

Version()

std::string WarpX::Version ( )

static

Version of WarpX executable.

WriteUsedInputsFile()

void WarpX::WriteUsedInputsFile

(

)

const

Write a file that record all inputs: inputs file + command line options

Friends And Related Function Documentation

PML

friend class PML

friend

Member Data Documentation

beta_boost

Real WarpX::beta_boost = 0._rt

static

Beta value corresponding to the Lorentz factor of the boosted frame of the simulation.

Bfield_aux

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_aux

private

Bfield_avg_cp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_avg_cp

private

Bfield_avg_fp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_avg_fp

private

Bfield_cax

amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_cax

private

Bfield_cp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_cp

private

Bfield_fp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_fp

private

Bfield_fp_external

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_fp_external

private

Bfield_n

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_n

private

Bfield_save

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_save

private

Bfield_slice

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Bfield_slice

private

bilinear_filter

BilinearFilter WarpX::bilinear_filter

boost_direction

Vector< int > WarpX::boost_direction = {0,0,0}

static

Direction of the Lorentz transform that defines the boosted frame of the simulation.

cfl

amrex::Real WarpX::cfl = amrex::Real(0.999)

private

charge_buf

amrex::Vector<std::unique_ptr<amrex::MultiFab> > WarpX::charge_buf

private

charge_deposition_algo

short WarpX::charge_deposition_algo

static

Integer that corresponds to the charge deposition algorithm (only standard deposition)

compute_max_step_from_btd

bool WarpX::compute_max_step_from_btd = false

static

If true, the code will compute max_step from the back transformed diagnostics.

costs

amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > > WarpX::costs

private

Collection of LayoutData to keep track of weights used in load balancing routines. Contains timer-based or heuristic-based costs depending on input option

costs_heuristic_cells_wt

amrex::Real WarpX::costs_heuristic_cells_wt = amrex::Real(0)

private

Weight factor for cells in Heuristic costs update. Default values on GPU are determined from single-GPU tests on Summit. The problem setup for these tests is an empty (i.e. no particles) domain of size 256 by 256 by 256 cells, from which the average time per iteration per cell is computed.

costs_heuristic_particles_wt

amrex::Real WarpX::costs_heuristic_particles_wt = amrex::Real(0)

private

Weight factor for particles in Heuristic costs update. Default values on GPU are determined from single-GPU tests on Summit. The problem setup for these tests is a high-ppc (27 particles per cell) uniform plasma on a domain of size 128 by 128 by 128, from which the approximate time per iteration per particle is computed.

current_buf

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::current_buf

private

current_buffer_masks

amrex::Vector<std::unique_ptr<amrex::iMultiFab> > WarpX::current_buffer_masks

private

current_centering_nox

int WarpX::current_centering_nox = 2

static

Order of finite centering of currents (from nodal grid to staggered grid), along x.

current_centering_noy

int WarpX::current_centering_noy = 2

static

Order of finite centering of currents (from nodal grid to staggered grid), along y.

current_centering_noz

int WarpX::current_centering_noz = 2

static

Order of finite centering of currents (from nodal grid to staggered grid), along z.

current_correction

bool WarpX::current_correction

If true, a correction is applied to the current in Fourier space,.

current_cp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::current_cp

private

current_deposition_algo

short WarpX::current_deposition_algo

static

Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay, Villasenor)

current_fp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::current_fp

private

current_fp_nodal

amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3> > WarpX::current_fp_nodal

private

current_fp_vay

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::current_fp_vay

private

current_slice

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::current_slice

private

current_store

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::current_store

private

device_current_centering_stencil_coeffs_x

amrex::Gpu::DeviceVector<amrex::Real> WarpX::device_current_centering_stencil_coeffs_x

device_current_centering_stencil_coeffs_y

amrex::Gpu::DeviceVector<amrex::Real> WarpX::device_current_centering_stencil_coeffs_y

device_current_centering_stencil_coeffs_z

amrex::Gpu::DeviceVector<amrex::Real> WarpX::device_current_centering_stencil_coeffs_z

device_field_centering_stencil_coeffs_x

amrex::Gpu::DeviceVector<amrex::Real> WarpX::device_field_centering_stencil_coeffs_x

device_field_centering_stencil_coeffs_y

amrex::Gpu::DeviceVector<amrex::Real> WarpX::device_field_centering_stencil_coeffs_y

device_field_centering_stencil_coeffs_z

amrex::Gpu::DeviceVector<amrex::Real> WarpX::device_field_centering_stencil_coeffs_z

do_compute_max_step_from_zmax

bool WarpX::do_compute_max_step_from_zmax = false

static

Set to true if zmax_plasma_to_compute_max_step is specified, in which case the maximum number of iterations is computed automatically so that the lower end of the simulation domain along z reaches zmax_plasma_to_compute_max_step in the boosted frame

do_current_centering

bool WarpX::do_current_centering = false

static

If true, the current is deposited on a nodal grid and then centered onto a staggered grid using finite centering of order given by current_centering_nox, current_centering_noy, and current_centering_noz

do_device_synchronize

bool WarpX::do_device_synchronize = false

static

do_divb_cleaning

bool WarpX::do_divb_cleaning = false

static

Solve additional Maxwell equation for G in order to control errors in magnetic Gauss' law.

do_dive_cleaning

bool WarpX::do_dive_cleaning = false

static

Solve additional Maxwell equation for F in order to control errors in Gauss' law (useful when using current deposition algorithms that are not charge-conserving)

do_dynamic_scheduling

bool WarpX::do_dynamic_scheduling = true

static

do_fluid_species

bool WarpX::do_fluid_species = false

private

do_moving_window

int WarpX::do_moving_window = 0

static

do_multi_J

bool WarpX::do_multi_J = false

static

do_multi_J_n_depositions

int WarpX::do_multi_J_n_depositions

static

do_pml

int WarpX::do_pml = 0

private

do_pml_divb_cleaning

bool WarpX::do_pml_divb_cleaning

private

do_pml_dive_cleaning

bool WarpX::do_pml_dive_cleaning

private

do_pml_Hi

amrex::Vector<amrex::IntVect> WarpX::do_pml_Hi

private

do_pml_in_domain

int WarpX::do_pml_in_domain = 0

private

do_pml_j_damping

int WarpX::do_pml_j_damping = 0

private

do_pml_Lo

amrex::Vector<amrex::IntVect> WarpX::do_pml_Lo

private

do_shared_mem_charge_deposition

bool WarpX::do_shared_mem_charge_deposition = false

static

used shared memory algorithm for charge deposition

do_shared_mem_current_deposition

bool WarpX::do_shared_mem_current_deposition = false

static

use shared memory algorithm for current deposition

do_silver_mueller

int WarpX::do_silver_mueller = 0

private

do_similar_dm_pml

int WarpX::do_similar_dm_pml = 1

staticprivate

do_single_precision_comms

bool WarpX::do_single_precision_comms = false

static

perform field communications in single precision

do_subcycling

bool WarpX::do_subcycling = false

static

dt

amrex::Vector<amrex::Real> WarpX::dt

private

ECTRhofield

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::ECTRhofield

private

ECTRhofield is needed only by the ect solver and it contains the electromotive force density for every mesh face. The name ECTRhofield has been used to comply with the notation of the paper https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4463918 (page 9, equation 4 and below). Although it's called rho it has nothing to do with the charge density! This is only used for the ECT solver.

Efield_aux

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_aux

private

Efield_avg_cp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_avg_cp

private

Efield_avg_fp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_avg_fp

private

Efield_cax

amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_cax

private

Efield_cp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_cp

private

Efield_fp

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_fp

private

Efield_fp_external

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_fp_external

private

Efield_n

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_n

private

Efield_save

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_save

private

Efield_slice

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Efield_slice

private

electromagnetic_solver_id

short WarpX::electromagnetic_solver_id

static

Integer that corresponds to the type of Maxwell solver (Yee, CKC, PSATD, ECT)

electrostatic_solver_id

int WarpX::electrostatic_solver_id

static

em_solver_medium

int WarpX::em_solver_medium

static

Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1)

end_moving_window_step

int WarpX::end_moving_window_step = -1

static

evolve_scheme

short WarpX::evolve_scheme

static

Integer that corresponds to the evolve scheme (explicit, implicit_picard, semi_implicit_picard)

F_cp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::F_cp

private

F_fp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::F_fp

private

F_slice

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::F_slice

private

fft_do_time_averaging

bool WarpX::fft_do_time_averaging = false

static

fft_periodic_single_box

bool WarpX::fft_periodic_single_box = false

private

field_boundary_hi

amrex::Vector< FieldBoundaryType > WarpX::field_boundary_hi

static

Integers that correspond to boundary condition applied to fields at the upper domain boundaries (0 to 6 correspond to PML, Periodic, PEC, PMC, Damped, Absorbing Silver-Mueller, None)

field_boundary_lo

amrex::Vector< FieldBoundaryType > WarpX::field_boundary_lo

static

Integers that correspond to boundary condition applied to fields at the lower domain boundaries (0 to 6 correspond to PML, Periodic, PEC, PMC, Damped, Absorbing Silver-Mueller, None)

field_centering_nox

int WarpX::field_centering_nox = 2

static

Order of finite centering of fields (from staggered grid to nodal grid), along x.

field_centering_noy

int WarpX::field_centering_noy = 2

static

Order of finite centering of fields (from staggered grid to nodal grid), along y.

field_centering_noz

int WarpX::field_centering_noz = 2

static

Order of finite centering of fields (from staggered grid to nodal grid), along z.

field_gathering_algo

short WarpX::field_gathering_algo

static

Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving)

field_io_nfiles

int WarpX::field_io_nfiles = 1024

private

filter_npass_each_dir

IntVect WarpX::filter_npass_each_dir

static

fine_tag_hi

amrex::RealVect WarpX::fine_tag_hi

private

fine_tag_lo

amrex::RealVect WarpX::fine_tag_lo

private

G_cp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::G_cp

private

G_fp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::G_fp

private

G_slice

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::G_slice

private

galerkin_interpolation

bool WarpX::galerkin_interpolation = true

static

If true (Galerkin method): The fields are interpolated directly from the staggered grid to the particle positions (with reduced interpolation order in the parallel direction). This scheme is energy conserving in the limit of infinitely small time steps. Otherwise, "momentum conserving" (in the same limit): The fields are first interpolated from the staggered grid points to the corners of each cell, and then from the cell corners to the particle position (with the same order of interpolation in all directions). This scheme is momentum conserving in the limit of infinitely small time steps.

gamma_boost

Real WarpX::gamma_boost = 1._rt

static

Lorentz factor of the boosted frame in which a boosted-frame simulation is run.

gather_buffer_masks

amrex::Vector<std::unique_ptr<amrex::iMultiFab> > WarpX::gather_buffer_masks

private

grid_type

short WarpX::grid_type

static

Integer that corresponds to the type of grid used in the simulation (collocated, staggered, hybrid)

guard_cells

guardCellManager WarpX::guard_cells

private

imultifab_map

std::map< std::string, amrex::iMultiFab * > WarpX::imultifab_map

static

injected_plasma_species

amrex::Vector<int> WarpX::injected_plasma_species

private

is_synchronized

bool WarpX::is_synchronized = true

private

istep

amrex::Vector<int> WarpX::istep

private

J_in_time

short WarpX::J_in_time

static

Integers that correspond to the time dependency of J (constant, linear) and rho (linear, quadratic) for the PSATD algorithm

load_balance_costs_update_algo

short WarpX::load_balance_costs_update_algo

static

Records a number corresponding to the load balance cost update strategy being used (0 or 1 corresponding to timers or heuristic).

load_balance_efficiency

amrex::Vector<amrex::Real> WarpX::load_balance_efficiency

private

Current load balance efficiency for each level.

load_balance_efficiency_ratio_threshold

amrex::Real WarpX::load_balance_efficiency_ratio_threshold = amrex::Real(1.1)

private

Threshold value that controls whether to adopt the proposed distribution mapping during load balancing. The new distribution mapping is adopted if the ratio of proposed distribution mapping efficiency to current distribution mapping efficiency is larger than the threshold; 'efficiency' here means the average cost per MPI rank.

load_balance_intervals

utils::parser::IntervalsParser WarpX::load_balance_intervals

private

Load balancing intervals that reads the "load_balance_intervals" string int the input file for getting steps at which load balancing is performed

load_balance_knapsack_factor

amrex::Real WarpX::load_balance_knapsack_factor = amrex::Real(1.24)

private

Controls the maximum number of boxes that can be assigned to a rank during load balance via the 'knapsack' strategy; e.g., if there are 4 boxes per rank, load_balance_knapsack_factor=2 limits the maximum number of boxes that can be assigned to a rank to 8.

load_balance_with_sfc

int WarpX::load_balance_with_sfc = 0

private

Load balance with 'space filling curve' strategy.

m_accelerator_lattice

amrex::Vector< std::unique_ptr<AcceleratorLattice> > WarpX::m_accelerator_lattice

private

m_area_mod

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::m_area_mod

private

EB: m_area_mod contains the modified areas of the mesh faces, i.e. if a face is enlarged it contains the area of the enlarged face This is only used for the ECT solver.

m_authors

std::string WarpX::m_authors

private

Author of an input file / simulation setup.

m_borrowing

amrex::Vector<std::array< std::unique_ptr<amrex::LayoutData<FaceInfoBox> >, 3 > > WarpX::m_borrowing

private

EB: m_borrowing contains the info about the enlarged cells, i.e. for every enlarged cell it contains the info of which neighbors are being intruded (and the amount of borrowed area). This is only used for the ECT solver.

m_boundary_potential_specified

bool WarpX::m_boundary_potential_specified = false

m_const_dt

std::optional<amrex::Real> WarpX::m_const_dt

private

m_distance_to_eb

amrex::Vector<std::unique_ptr<amrex::MultiFab> > WarpX::m_distance_to_eb

private

m_edge_lengths

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::m_edge_lengths

private

EB: Lengths of the mesh edges.

m_exit_loop_due_to_interrupt_signal

bool WarpX::m_exit_loop_due_to_interrupt_signal = false

private

Stop the simulation at the end of the current step due to a received Unix signal?

m_face_areas

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::m_face_areas

private

EB: Areas of the mesh faces.

m_fdtd_solver_cp

amrex::Vector<std::unique_ptr<FiniteDifferenceSolver> > WarpX::m_fdtd_solver_cp

private

m_fdtd_solver_fp

amrex::Vector<std::unique_ptr<FiniteDifferenceSolver> > WarpX::m_fdtd_solver_fp

private

m_field_factory

amrex::Vector<std::unique_ptr<amrex::FabFactory<amrex::FArrayBox> > > WarpX::m_field_factory

private

m_fill_guards_current

amrex::IntVect WarpX::m_fill_guards_current = amrex::IntVect(0)

static

Whether to fill guard cells when computing inverse FFTs of currents.

m_fill_guards_fields

amrex::IntVect WarpX::m_fill_guards_fields = amrex::IntVect(0)

static

Whether to fill guard cells when computing inverse FFTs of fields.

m_flag_ext_face

amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > WarpX::m_flag_ext_face

private

EB: for every mesh face face flag_ext_face contains a:

• 1 if the face needs to be extended
• 0 otherwise It is initialized in WarpX::MarkCells and then modified in WarpX::ComputeOneWayExtensions and in WarpX::ComputeEightWaysExtensions This is only used for the ECT solver.

m_flag_info_face

amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > WarpX::m_flag_info_face

private

EB: for every mesh face flag_info_face contains a:

• 0 if the face needs to be extended
• 1 if the face is large enough to lend area to other faces
• 2 if the face is actually intruded by other face It is initialized in WarpX::MarkCells This is only used for the ECT solver.

m_galilean_shift

amrex::Array<amrex::Real,3> WarpX::m_galilean_shift = {{0}}

m_hybrid_pic_model

std::unique_ptr<HybridPICModel> WarpX::m_hybrid_pic_model

private

m_instance

WarpX * WarpX::m_instance = nullptr

staticprivate

m_macroscopic_properties

std::unique_ptr<MacroscopicProperties> WarpX::m_macroscopic_properties

private

m_p_ext_field_params

std::unique_ptr<ExternalFieldParams> WarpX::m_p_ext_field_params

private

m_particle_boundary_buffer

std::unique_ptr<ParticleBoundaryBuffer> WarpX::m_particle_boundary_buffer

private

particle buffer for scraped particles on the boundaries

m_poisson_boundary_handler

ElectrostaticSolver::PoissonBoundaryHandler WarpX::m_poisson_boundary_handler

m_rho_nodal_flag

amrex::IntVect WarpX::m_rho_nodal_flag

m_v_comoving

amrex::Vector<amrex::Real> WarpX::m_v_comoving = amrex::Vector<amrex::Real>(3, amrex::Real(0.))

m_v_galilean

amrex::Vector<amrex::Real> WarpX::m_v_galilean = amrex::Vector<amrex::Real>(3, amrex::Real(0.))

m_vector_poisson_boundary_handler

MagnetostaticSolver::VectorPoissonBoundaryHandler WarpX::m_vector_poisson_boundary_handler

macroscopic_solver_algo

int WarpX::macroscopic_solver_algo

static

Integer that correspond to macroscopic Maxwell solver algorithm (BackwardEuler - 0, Lax-Wendroff - 1)

max_picard_iterations

int WarpX::max_picard_iterations = 10

static

The maximum number of Picard iterations to do each time step.

max_step

int WarpX::max_step = std::numeric_limits<int>::max()

private

maxlevel_extEMfield_init

int WarpX::maxlevel_extEMfield_init

Maximum level up to which the externally defined electric and magnetic fields are initialized. The default value is set to the max levels in the simulation. if lev > maxlevel_extEMfield_init, the fields on those levels will have a default value of 0

mffile_nstreams

int WarpX::mffile_nstreams = 4

private

mirror_z

amrex::Vector<amrex::Real> WarpX::mirror_z

mirror_z_npoints

amrex::Vector<int> WarpX::mirror_z_npoints

mirror_z_width

amrex::Vector<amrex::Real> WarpX::mirror_z_width

moving_window_dir

int WarpX::moving_window_dir = -1

static

moving_window_v

Real WarpX::moving_window_v = std::numeric_limits<amrex::Real>::max()

static

moving_window_x

amrex::Real WarpX::moving_window_x = std::numeric_limits<amrex::Real>::max()

private

multi_diags

std::unique_ptr<MultiDiagnostics> WarpX::multi_diags

private

multifab_map

std::map< std::string, amrex::MultiFab * > WarpX::multifab_map

static

myfl

std::unique_ptr<MultiFluidContainer> WarpX::myfl

private

mypc

std::unique_ptr<MultiParticleContainer> WarpX::mypc

private

n_current_deposition_buffer

int WarpX::n_current_deposition_buffer = -1

static

With mesh refinement, particles located inside a refinement patch, but within n_current_deposition_buffer cells of the edge of the patch, will deposit their charge and current onto the lower refinement level instead of the refinement patch itself

n_field_gather_buffer

int WarpX::n_field_gather_buffer = -1

static

With mesh refinement, particles located inside a refinement patch, but within n_field_gather_buffer cells of the edge of the patch, will gather the fields from the lower refinement level instead of the refinement patch itself

n_rz_azimuthal_modes

int WarpX::n_rz_azimuthal_modes = 1

static

Number of modes for the RZ multi-mode version.

nci_godfrey_filter_bxbyez

amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > WarpX::nci_godfrey_filter_bxbyez

nci_godfrey_filter_exeybz

amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > WarpX::nci_godfrey_filter_exeybz

ncomps

int WarpX::ncomps = 1

static

Number of MultiFab components (with the RZ multi-mode version, each mode has a real and imaginary component, except mode 0 which is purely real: component 0 is mode 0, odd components are the real parts, even components are the imaginary parts)

nox

int WarpX::nox = 0

static

Order of the particle shape factors (splines) along x.

nox_fft

int WarpX::nox_fft = 16

private

noy

int WarpX::noy = 0

static

Order of the particle shape factors (splines) along y.

noy_fft

int WarpX::noy_fft = 16

private

noz

int WarpX::noz = 0

static

Order of the particle shape factors (splines) along z.

noz_fft

int WarpX::noz_fft = 16

private

nsubsteps

amrex::Vector<int> WarpX::nsubsteps

private

num_injected_species

int WarpX::num_injected_species = -1

private

num_mirrors

int WarpX::num_mirrors = 0

static

numprocs

amrex::IntVect WarpX::numprocs {0}

private

Domain decomposition on Level 0.

override_sync_intervals

utils::parser::IntervalsParser WarpX::override_sync_intervals

private

particle_boundary_hi

amrex::Vector< ParticleBoundaryType > WarpX::particle_boundary_hi

static

Integers that correspond to boundary condition applied to particles at the upper domain boundaries (0 to 4 correspond to Absorbing, Open, Reflecting, Periodic, Thermal)

particle_boundary_lo

amrex::Vector< ParticleBoundaryType > WarpX::particle_boundary_lo

static

Integers that correspond to boundary condition applied to particles at the lower domain boundaries (0 to 4 correspond to Absorbing, Open, Reflecting, Periodic, Thermal)

particle_io_nfiles

int WarpX::particle_io_nfiles = 1024

private

particle_pusher_algo

short WarpX::particle_pusher_algo

static

Integer that corresponds to the particle push algorithm (Boris, Vay, Higuera-Cary)

phi_fp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::phi_fp

private

picard_iteration_tolerance

Real WarpX::picard_iteration_tolerance = 1.e-7

static

The tolerance for the Picard iteration convergence.

plotfile_headerversion

amrex::VisMF::Header::Version WarpX::plotfile_headerversion = amrex::VisMF::Header::Version_v1

private

pml

amrex::Vector<std::unique_ptr<PML> > WarpX::pml

private

pml_delta

int WarpX::pml_delta = 10

private

pml_has_particles

int WarpX::pml_has_particles = 0

private

pml_ncell

int WarpX::pml_ncell = 10

private

pml_rz

amrex::Vector<std::unique_ptr<PML_RZ> > WarpX::pml_rz

private

poisson_solver_id

int WarpX::poisson_solver_id

static

psatd_solution_type

short WarpX::psatd_solution_type

static

Integer that corresponds to the order of the PSATD solution (whether the PSATD equations are derived from first-order or second-order solution)

quantum_xi_c2

Real WarpX::quantum_xi_c2 = PhysConst::xi_c2

static

reduced_diags

std::unique_ptr<MultiReducedDiags> WarpX::reduced_diags

object with all reduced diagnostics, similar to MultiParticleContainer for species.

ref_patch_parser

std::unique_ptr<amrex::Parser> WarpX::ref_patch_parser

private

User-defined parser to define refinement patches.

refine_plasma

bool WarpX::refine_plasma = false

static

regrid_int

int WarpX::regrid_int = -1

private

require_picard_convergence

bool WarpX::require_picard_convergence = true

static

Flags whether the Picard iterations are required to converge.

restart_chkfile

std::string WarpX::restart_chkfile

private

rho_cp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::rho_cp

private

rho_fp

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::rho_fp

private

rho_in_time

short WarpX::rho_in_time

static

rho_slice

amrex::Vector< std::unique_ptr<amrex::MultiFab> > WarpX::rho_slice

private

safe_guard_cells

bool WarpX::safe_guard_cells = false

static

self_fields_absolute_tolerance

Real WarpX::self_fields_absolute_tolerance = 0.0_rt

static

self_fields_max_iters

int WarpX::self_fields_max_iters = 200

static

self_fields_required_precision

Real WarpX::self_fields_required_precision = 1.e-11_rt

static

self_fields_verbosity

int WarpX::self_fields_verbosity = 2

static

serialize_initial_conditions

bool WarpX::serialize_initial_conditions = false

static

If true, the initial conditions from random number generators are serialized (useful for reproducible testing with OpenMP)

shared_mem_current_tpb

int WarpX::shared_mem_current_tpb = 128

static

number of threads to use per block in shared deposition

shared_tilesize

amrex::IntVect WarpX::shared_tilesize

static

tileSize to use for shared current deposition operations

slice_cr_ratio

amrex::IntVect WarpX::slice_cr_ratio

private

slice_max_grid_size

int WarpX::slice_max_grid_size

private

slice_plot_int

int WarpX::slice_plot_int = -1

private

slice_plotfile_headerversion

amrex::VisMF::Header::Version WarpX::slice_plotfile_headerversion = amrex::VisMF::Header::Version_v1

private

slice_realbox

amrex::RealBox WarpX::slice_realbox

private

sort_bin_size

amrex::IntVect WarpX::sort_bin_size

static

sort_idx_type

amrex::IntVect WarpX::sort_idx_type

static

Specifies the type of grid used for the above sorting, i.e. cell-centered, nodal, or mixed.

sort_intervals

utils::parser::IntervalsParser WarpX::sort_intervals

static

sort_particles_for_deposition

bool WarpX::sort_particles_for_deposition = false

static

If true, particles will be sorted in the order x -> y -> z -> ppc for faster deposition.

spectral_solver_cp

amrex::Vector<std::unique_ptr<SpectralSolverRZ> > WarpX::spectral_solver_cp

private

spectral_solver_fp

amrex::Vector<std::unique_ptr<SpectralSolverRZ> > WarpX::spectral_solver_fp

private

start_moving_window_step

int WarpX::start_moving_window_step = 0

static

stop_time

amrex::Real WarpX::stop_time = std::numeric_limits<amrex::Real>::max()

private

sync_nodal_points

constexpr bool WarpX::sync_nodal_points = true

staticconstexprprivate

t_new

amrex::Vector<amrex::Real> WarpX::t_new

private

t_old

amrex::Vector<amrex::Real> WarpX::t_old

private

time_of_last_gal_shift

amrex::Real WarpX::time_of_last_gal_shift = 0

update_with_rho

bool WarpX::update_with_rho = false

If true, the PSATD update equation for E contains both J and rho (default is false for standard PSATD and true for Galilean PSATD)

use_fdtd_nci_corr

bool WarpX::use_fdtd_nci_corr = false

static

If true, a Numerical Cherenkov Instability (NCI) corrector is applied (for simulations using the FDTD Maxwell solver)

use_filter

bool WarpX::use_filter = true

static

If true, a bilinear filter is used to smooth charge and currents.

use_filter_compensation

bool WarpX::use_filter_compensation = false

static

If true, a compensation step is added to the bilinear filtering of charge and currents.

use_hybrid_QED

bool WarpX::use_hybrid_QED = false

private

use_kspace_filter

bool WarpX::use_kspace_filter = true

static

If true, the bilinear filtering of charge and currents is done in Fourier space.

use_single_read

bool WarpX::use_single_read = true

private

use_single_write

bool WarpX::use_single_write = true

private

v_particle_pml

amrex::Real WarpX::v_particle_pml

private

vector_potential_fp_nodal

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::vector_potential_fp_nodal

private

vector_potential_grad_buf_b_stag

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::vector_potential_grad_buf_b_stag

private

vector_potential_grad_buf_e_stag

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::vector_potential_grad_buf_e_stag

private

Venl

amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > WarpX::Venl

private

Venl contains the electromotive force for every mesh face, i.e. every entry is the corresponding entry in ECTRhofield multiplied by the total area (possibly with enlargement) This is only used for the ECT solver.

verboncoeur_axis_correction

bool WarpX::verboncoeur_axis_correction = true

static

Flag whether the Verboncoeur correction is applied to the current and charge density on the axis when using RZ.

verbose

int WarpX::verbose = 1

private

warpx_do_continuous_injection

int WarpX::warpx_do_continuous_injection = 0

private

write_diagnostics_on_restart

bool WarpX::write_diagnostics_on_restart = false

private

When true, write the diagnostics after restart at the time of the restart.

zmax_plasma_to_compute_max_step

Real WarpX::zmax_plasma_to_compute_max_step = 0._rt

static

If specified, the maximum number of iterations is computed automatically so that the lower end of the simulation domain along z reaches zmax_plasma_to_compute_max_step in the boosted frame

zmin_domain_boost_step_0

Real WarpX::zmin_domain_boost_step_0 = 0._rt

static

store initial value of zmin_domain_boost because WarpX::computeMaxStepBoostAccelerator needs the initial value of zmin_domain_boost, even if restarting from a checkpoint file

---

The documentation for this class was generated from the following files:

• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/WarpX.H
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/BoundaryConditions/WarpXEvolvePML.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/BoundaryConditions/WarpXFieldBoundaries.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Diagnostics/WarpXIO.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/EmbeddedBoundary/WarpXFaceExtensions.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/EmbeddedBoundary/WarpXInitEB.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Evolve/WarpXComputeDt.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Evolve/WarpXEvolve.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Evolve/WarpXOneStepImplicitPicard.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/FieldSolver/ElectrostaticSolver.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/FieldSolver/MagnetostaticSolver/MagnetostaticSolver.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/FieldSolver/WarpX_QED_Field_Pushers.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/FieldSolver/WarpXPushFieldsEM.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/FieldSolver/WarpXPushFieldsHybridPIC.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Initialization/WarpXInitData.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Parallelization/WarpXComm.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Parallelization/WarpXRegrid.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Utils/WarpXMovingWindow.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Utils/WarpXTagging.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/Utils/WarpXVersion.cpp
• /home/docs/checkouts/readthedocs.org/user_builds/warpx/checkouts/latest/Source/WarpX.cpp