#include <WarpX.H>
Inheritance diagram for WarpX:
Public Member Functions | |
| WarpX () | |
| ~WarpX () | |
| int | Verbose () const |
| void | InitData () |
| void | Evolve (int numsteps=-1) |
| MultiParticleContainer & | GetPartContainer () |
| MacroscopicProperties & | GetMacroscopicProperties () |
| London & | getLondon () |
| MultiDiagnostics & | GetMultiDiags () |
| ParticleBoundaryBuffer & | GetParticleBoundaryBuffer () |
| std::array< const amrex::MultiFab *const, 3 > | get_array_Bfield_aux (const int lev) const |
| std::array< const amrex::MultiFab *const, 3 > | get_array_Efield_aux (const int lev) const |
| amrex::MultiFab * | get_pointer_Efield_aux (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_Bfield_aux (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_Efield_fp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_Bfield_fp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_Bfield_sc_fp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_current_fp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_current_fp_nodal (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_rho_fp (int lev) const |
| amrex::MultiFab * | get_pointer_F_fp (int lev) const |
| amrex::MultiFab * | get_pointer_G_fp (int lev) const |
| amrex::MultiFab * | get_pointer_phi_fp (int lev) const |
| amrex::MultiFab * | get_pointer_vector_potential_fp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_Efield_cp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_Bfield_cp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_current_cp (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_rho_cp (int lev) const |
| amrex::MultiFab * | get_pointer_F_cp (int lev) const |
| amrex::MultiFab * | get_pointer_G_cp (int lev) const |
| amrex::MultiFab * | get_pointer_edge_lengths (int lev, int direction) const |
| amrex::MultiFab * | get_pointer_face_areas (int lev, int direction) const |
| const amrex::MultiFab & | getEfield (int lev, int direction) |
| const amrex::MultiFab & | getBfield (int lev, int direction) |
| const amrex::MultiFab & | getcurrent_cp (int lev, int direction) |
| const amrex::MultiFab & | getEfield_cp (int lev, int direction) |
| const amrex::MultiFab & | getBfield_cp (int lev, int direction) |
| const amrex::MultiFab & | getrho_cp (int lev) |
| const amrex::MultiFab & | getF_cp (int lev) |
| const amrex::MultiFab & | getG_cp (int lev) |
| const amrex::MultiFab & | getcurrent_fp (int lev, int direction) |
| const amrex::MultiFab & | getEfield_fp (int lev, int direction) |
| const amrex::MultiFab & | getBfield_fp (int lev, int direction) |
| const amrex::MultiFab & | getBfield_sc_fp (int lev, int direction) |
| const amrex::MultiFab & | getrho_fp (int lev) |
| const amrex::MultiFab & | getphi_fp (int lev) |
| const amrex::MultiFab & | getF_fp (int lev) |
| const amrex::MultiFab & | getG_fp (int lev) |
| const amrex::MultiFab & | getEfield_avg_fp (int lev, int direction) |
| const amrex::MultiFab & | getBfield_avg_fp (int lev, int direction) |
| const amrex::MultiFab & | getEfield_avg_cp (int lev, int direction) |
| const amrex::MultiFab & | getBfield_avg_cp (int lev, int direction) |
| bool | DoPML () const |
| const PML_RZ * | getPMLRZ () |
| std::vector< bool > | getPMLdirections () const |
| void | setLoadBalanceEfficiency (const int lev, const amrex::Real efficiency) |
| amrex::Real | getLoadBalanceEfficiency (const 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 (const 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 | UpdatePlasmaInjectionPosition (amrex::Real dt) |
| 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 | EvolveBLondon (amrex::Real dt, DtType dt_type) |
| void | EvolveBLondon (int lev, amrex::Real dt, DtType dt_type) |
| void | EvolveBLondon (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 | 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 | LoadBalance () |
perform load balance; compute and communicate new amrex::DistributionMapping More... | |
| void | ResetCosts () |
| resets costs to zero More... | |
| utils::parser::IntervalsParser | get_load_balance_intervals () const |
| returns the load balance interval More... | |
| void | DampFieldsInGuards (const 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 (const 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 (const 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 (const 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 (const int lev, PatchType patch_type) |
| void | ApplyBfieldBoundary (const int lev, PatchType patch_type, DtType dt_type) |
| void | DampPML () |
| void | DampPML (const int lev) |
| void | DampPML (const int lev, PatchType patch_type) |
| void | DampPML_Cartesian (const 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 () |
| void | NodalSyncPML () |
| Synchronize the nodal points of the PML MultiFabs. More... | |
| void | NodalSyncPML (int lev) |
| Synchronize the nodal points of the PML MultiFabs for given MR level. More... | |
| void | NodalSyncPML (int lev, PatchType patch_type) |
| Synchronize the nodal points of the PML MultiFabs for given MR level and patch. More... | |
| PML * | GetPML (int lev) |
| PML_RZ * | GetPML_RZ (int lev) |
| void | doFieldIonization () |
| void | doFieldIonization (int lev) |
| void | doQEDEvents () |
| void | doQEDEvents (int lev) |
| void | PushParticlesandDepose (int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false) |
| void | PushParticlesandDepose (amrex::Real cur_time, bool skip_current=false) |
| 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 | FillBoundaryJ (amrex::IntVect ng) |
| void | FillBoundaryJ (const int lev, amrex::IntVect ng) |
| void | SyncCurrentAndRho () |
| Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels. 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) |
| 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) |
| 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 |
| amrex::Real | getcurrent_injection_position () 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, const amrex::IntVect ngrow) const |
| void | prepareFields (int const 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, const int lev) |
| const amrex::IntVect | getngEB () const |
| const amrex::IntVect | getngF () const |
| const amrex::IntVect | getngUpdateAux () const |
| const amrex::IntVect | get_ng_depos_J () const |
| const amrex::IntVect | get_ng_depos_rho () const |
| const amrex::IntVect | get_ng_fieldgather () const |
| const amrex::IntVect | get_numprocs () const |
| void | ComputeSpaceChargeField (bool const 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 > const beta={{0, 0, 0}}, amrex::Real const required_precision=amrex::Real(1.e-11), amrex::Real absolute_tolerance=amrex::Real(0.0), const int max_iters=200, const 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 > const 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 > const 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 const required_precision=amrex::Real(1.e-11), amrex::Real absolute_tolerance=amrex::Real(0.0), const int max_iters=200, const 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, const char field, const 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 | ReadExternalFieldFromFile (std::string read_fields_from_path, amrex::MultiFab *mf, std::string F_name, std::string F_component) |
| 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 | ApplyExternalFieldExcitationOnGrid (int const externalfieldtype, DtType a_dt_type=DtType::Full) |
Adds the contribution of user-defined external field-excitation to Efield, Bfield, and also Hfield if USE_LLG=TRUE. Two types of excitation are supported, namely, hard source and soft source. An excitation is called hard source if the field value is set exactly equal to the excitation (similar to a Dirichlet boundary) (field = excitation). An excitation is called soft source if the field value is updated by adding to it the contribution from the externally applied excitation (field += excitation). To ensure that the excitation is appropriately accounted for, a flag parser for each component of the field must be specified. The flag can have three values : If flag_type == 0, field is not updated with external excitation If flag_type == 1, field is set equal to the external excitation (aka hard source) If flag_type == 2, field is updated to add the contribution from external excitation (aka soft source) More... | |
| void | ApplyExternalFieldExcitationOnGrid (amrex::MultiFab *mfx, amrex::MultiFab *mfy, amrex::MultiFab *mfz, amrex::ParserExecutor< 4 > const &xfield_parser, amrex::ParserExecutor< 4 > const &yfield_parser, amrex::ParserExecutor< 4 > const &zfield_parser, amrex::ParserExecutor< 3 > const &xflag_parser, amrex::ParserExecutor< 3 > const &yflag_parser, amrex::ParserExecutor< 3 > const &zflag_parser, const int lev, DtType a_dt_type) |
| void | ReadExcitationParser () |
| virtual 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 (const amrex::Box tbx, amrex::IArrayBox &buffer_mask, const amrex::IArrayBox &guard_mask, const int ng) |
| Build buffer mask within given FArrayBox. More... | |
| void | InitEB () |
| void | ComputeDistanceToEB () |
| Compute the length of the mesh edges. Here the length is a value in [0, 1]. An edge of length 0 is fully covered. 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 (const 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) |
 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 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, const int lev, bool update_cost_flag, amrex::Real external_field=0.0, bool useparser=false, amrex::ParserExecutor< 3 > const &field_parser={}) |
| static void | GotoNextLine (std::istream &is) |
| static void | AllocInitMultiFab (std::unique_ptr< amrex::MultiFab > &mf, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm, const int ncomp, const amrex::IntVect &ngrow, 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, const int ncomp, const amrex::IntVect &ngrow, 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, const int scomp, const int ncomp, 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 | AddToMultiFabMap (const std::string &name, const std::unique_ptr< amrex::MultiFab > &mf) |
| Add the MultiFab to the map of MultiFabs. More... | |
| static void | AddToMultiFabMap (const std::string &name, const std::unique_ptr< amrex::iMultiFab > &mf) |
| Add the iMultiFab to the map of MultiFabs. More... | |
| static amrex::LayoutData< amrex::Real > * | getCosts (int lev) |
| 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, const int lev, const 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, const int lev, const 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 const dcomp, const std::array< const amrex::MultiFab *const, 3 > &B, const std::array< amrex::Real, 3 > &dx) |
| static void | ComputeDivB (amrex::MultiFab &divB, int const dcomp, const std::array< const amrex::MultiFab *const, 3 > &B, const std::array< amrex::Real, 3 > &dx, amrex::IntVect const ngrow) |
| static amrex::Vector< amrex::Real > | getFornbergStencilCoefficients (const int n_order, const 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... | |
Static Public Attributes | |
| static std::string | authors = "" |
| Author of an input file / simulation setup. More... | |
| static amrex::Vector< amrex::Real > | E_external_grid |
| Initial electric field on the grid. More... | |
| static amrex::Vector< amrex::Real > | B_external_grid |
| Initial magnetic field on the grid. More... | |
| static std::string | B_ext_grid_s = "default" |
| Initialization type for external magnetic field on the grid. More... | |
| static std::string | E_ext_grid_s = "default" |
| Initialization type for external electric field on the grid. More... | |
| static std::string | B_excitation_grid_s = "default" |
| static std::string | E_excitation_grid_s = "default" |
| static int | ApplyExcitationInPML = 0 |
| static bool | add_external_E_field = false |
| Whether to apply the effect of an externally-defined electric field. More... | |
| static bool | add_external_B_field = false |
| Whether to apply the effect of an externally-defined magnetic field. More... | |
| static std::string | str_Bx_ext_grid_function |
| String storing parser function to initialize x-component of the magnetic field on the grid. More... | |
| static std::string | str_By_ext_grid_function |
| String storing parser function to initialize y-component of the magnetic field on the grid. More... | |
| static std::string | str_Bz_ext_grid_function |
| String storing parser function to initialize z-component of the magnetic field on the grid. More... | |
| static std::string | str_Ex_ext_grid_function |
| String storing parser function to initialize x-component of the electric field on the grid. More... | |
| static std::string | str_Ey_ext_grid_function |
| String storing parser function to initialize y-component of the electric field on the grid. More... | |
| static std::string | str_Ez_ext_grid_function |
| String storing parser function to initialize z-component of the electric field on the grid. More... | |
| static std::string | str_Bx_excitation_grid_function |
| static std::string | str_By_excitation_grid_function |
| static std::string | str_Bz_excitation_grid_function |
| static std::string | str_Ex_excitation_grid_function |
| static std::string | str_Ey_excitation_grid_function |
| static std::string | str_Ez_excitation_grid_function |
| static std::string | str_Ex_excitation_flag_function |
| static std::string | str_Ey_excitation_flag_function |
| static std::string | str_Ez_excitation_flag_function |
| static std::string | str_Bx_excitation_flag_function |
| static std::string | str_By_excitation_flag_function |
| static std::string | str_Bz_excitation_flag_function |
| static short | current_deposition_algo |
| Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay) 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 | 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< int > | field_boundary_lo |
| static amrex::Vector< int > | field_boundary_hi |
| static amrex::Vector< ParticleBoundaryType > | particle_boundary_lo |
| static amrex::Vector< ParticleBoundaryType > | particle_boundary_hi |
| static int | yee_coupled_solver_algo |
| 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 = 0 |
| 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 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_B_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_E_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... | |
| virtual void | PostProcessBaseGrids (amrex::BoxArray &ba0) const final |
| virtual void | MakeNewLevelFromScratch (int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final |
| virtual void | MakeNewLevelFromCoarse (int, amrex::Real, const amrex::BoxArray &, const amrex::DistributionMapping &) final |
| virtual void | RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final |
| virtual 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 | |
| void | HandleSignals () |
| Complete the asynchronous broadcast of signal flags, and initiate a checkpoint if requested. More... | |
| void | EvolveEM (int numsteps) |
| void | FillBoundaryB (const int lev, const PatchType patch_type, const amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt) |
| void | FillBoundaryE (const int lev, const PatchType patch_type, const 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 | FillBoundaryJ (const int lev, const PatchType patch_type, const amrex::IntVect ng) |
| void | AddExternalFields () |
| void | OneStep_nosub (amrex::Real t) |
| void | OneStep_sub1 (amrex::Real t) |
| void | OneStep_multiJ (const amrex::Real t) |
| 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, const 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 int lev) |
| void | StoreCurrent (const int lev) |
| void | RestoreCurrent (const int lev) |
| void | ApplyFilterJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> ¤t, const int lev, const int idim) |
| void | ApplyFilterJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> ¤t, const int lev) |
| void | SumBoundaryJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> ¤t, const int lev, const int idim, const amrex::Periodicity &period) |
| void | SumBoundaryJ (const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> ¤t, const 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, const 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, const int lev) |
| void | ApplyFilterandSumBoundaryRho (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, const int lev, PatchType patch_type, const int icomp, const 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 int lev, const int icomp, const int ncomp) |
| void | NodalSyncRho (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_fp, const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &charge_cp, const int lev, PatchType patch_type, const int icomp, const int ncomp) |
| void | ReadParameters () |
| void | BackwardCompatibility () |
| void | InitFromScratch () |
| void | AllocLevelData (int lev, const amrex::BoxArray &new_grids, const amrex::DistributionMapping &new_dmap) |
| 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 | CheckGuardCells (amrex::MultiFab const &mf) |
| Check that the number of guard cells is smaller than the number of valid cells, for a given MultiFab, 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, const 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 | |
| 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, const int centering_nox, const int centering_noy, const int centering_noz, const 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, const bool aux_is_nodal) |
| void | AllocLevelSpectralSolverRZ (amrex::Vector< std::unique_ptr< SpectralSolverRZ >> &spectral_solver, const int lev, const amrex::BoxArray &realspace_ba, const amrex::DistributionMapping &dm, const std::array< amrex::Real, 3 > &dx) |
| amrex::FabFactory< amrex::FArrayBox > const & | fieldFactory (int lev) const noexcept |
| void | ScrapeParticles () |
| 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, const 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, const int icomp, const int dcomp, const 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 (const 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 | CheckSignals () |
| Check and clear signal flags and asynchronously broadcast them from process 0. More... | |
Static Private Attributes | |
| static WarpX * | m_instance = nullptr |
| static int | do_similar_dm_pml = 1 |
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 | ( | ) |
create object for reduced diagnostics
◆ ~WarpX()
| WarpX::~WarpX | ( | ) |
Member Function Documentation
◆ AddBoundaryField()
| void WarpX::AddBoundaryField | ( | ) |
◆ AddCurrentFromFineLevelandSumBoundary()
|
private |
◆ AddExternalFields()
|
private |
◆ AddMagnetostaticFieldLabFrame()
| void WarpX::AddMagnetostaticFieldLabFrame | ( | ) |
◆ AddRhoFromFineLevelandSumBoundary()
|
private |
◆ AddSpaceChargeField()
| void WarpX::AddSpaceChargeField | ( | WarpXParticleContainer & | pc | ) |
◆ AddSpaceChargeFieldLabFrame()
| void WarpX::AddSpaceChargeFieldLabFrame | ( | ) |
◆ AddToMultiFabMap() [1/2]
|
inlinestatic |
Add the iMultiFab to the map of MultiFabs.
- Parameters
-
name The name of the iMultiFab use to reference the iMultiFab mf The iMultiFab to be added to the map (via a pointer to it)
◆ AddToMultiFabMap() [2/2]
|
inlinestatic |
Add the MultiFab to the map of MultiFabs.
- Parameters
-
name The name of the MultiFab use to reference the MultiFab mf The MultiFab to be added to the map (via a pointer to it)
◆ AliasInitMultiFab()
|
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] name The name of the MultiFab to use in the map [in] initial_value optional initial value for MultiFab
◆ AllocateCenteringCoefficients()
|
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]
|
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] name The name of the iMultiFab to use in the map [in] initial_value The optional initial value
◆ AllocInitMultiFab() [2/2]
|
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] name The name of the MultiFab to use in the map [in] initial_value The optional initial value
◆ AllocLevelData()
|
private |
◆ AllocLevelMFs()
|
private |
◆ AllocLevelSpectralSolverRZ()
|
private |
◆ ApplyBCKCorrection()
| void WarpX::ApplyBCKCorrection | ( | const 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()
◆ ApplyEfieldBoundary()
◆ ApplyExternalFieldExcitationOnGrid() [1/2]
| void WarpX::ApplyExternalFieldExcitationOnGrid | ( | amrex::MultiFab * | mfx, |
| amrex::MultiFab * | mfy, | ||
| amrex::MultiFab * | mfz, | ||
| amrex::ParserExecutor< 4 > const & | xfield_parser, | ||
| amrex::ParserExecutor< 4 > const & | yfield_parser, | ||
| amrex::ParserExecutor< 4 > const & | zfield_parser, | ||
| amrex::ParserExecutor< 3 > const & | xflag_parser, | ||
| amrex::ParserExecutor< 3 > const & | yflag_parser, | ||
| amrex::ParserExecutor< 3 > const & | zflag_parser, | ||
| const int | lev, | ||
| DtType | a_dt_type | ||
| ) |
◆ ApplyExternalFieldExcitationOnGrid() [2/2]
| void WarpX::ApplyExternalFieldExcitationOnGrid | ( | int const | externalfieldtype, |
| DtType | a_dt_type = DtType::Full |
||
| ) |
Adds the contribution of user-defined external field-excitation to Efield, Bfield, and also Hfield if USE_LLG=TRUE. Two types of excitation are supported, namely, hard source and soft source. An excitation is called hard source if the field value is set exactly equal to the excitation (similar to a Dirichlet boundary) (field = excitation). An excitation is called soft source if the field value is updated by adding to it the contribution from the externally applied excitation (field += excitation). To ensure that the excitation is appropriately accounted for, a flag parser for each component of the field must be specified. The flag can have three values : If flag_type == 0, field is not updated with external excitation If flag_type == 1, field is set equal to the external excitation (aka hard source) If flag_type == 2, field is updated to add the contribution from external excitation (aka soft source)
externalfieldtype determines which field component the external excitation is applied on externalfieldtype == ExternalFieldType::AllExternal : external field excitation applied to all three field components, E, B and H externalfieldtype == ExternalFieldType::EfieldExternal : external field excitation applied to E field only externalfieldtype == ExternalFieldType::BfieldExternal : external field excitation applied to B field only externalfieldtype == ExternalFieldType::HfieldExternal : external field excitation applied to H field only; this option is only valid when USE_LLG == TRUE
- Parameters
-
[in] mfx,mfy,mfz : The field component Multifabs to be updated with the external excitation. [in] xfield_parser : external excitation for xcomponent of the field [in] yfield_parser : external excitation for ycomponent of the field [in] zfield_parser : external excitation for zcomponent of the field [in] xflag_parser : Type xfield excitation (hard source=0/soft source=1) [in] yflag_parser : Type yfield excitation (hard source=0/soft source=1) [in] zflag_parser : Type zfield excitation (hard source=0/soft source=1) [in] lev : level on which the excitation is applied.
◆ ApplyFilterandSumBoundaryRho() [1/2]
|
private |
◆ ApplyFilterandSumBoundaryRho() [2/2]
| void WarpX::ApplyFilterandSumBoundaryRho | ( | int | lev, |
| int | glev, | ||
| amrex::MultiFab & | rho, | ||
| int | icomp, | ||
| int | ncomp | ||
| ) |
◆ ApplyFilterJ() [1/2]
|
private |
◆ ApplyFilterJ() [2/2]
|
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 | ( | const 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 | ( | const 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, | ||
| const amrex::IntVect | ngrow | ||
| ) | const |
◆ BackwardCompatibility()
|
private |
This function queries deprecated input parameters and abort the run if one of them is specified.
◆ BuildBufferMasks()
|
private |
◆ BuildBufferMasksInBox()
| void WarpX::BuildBufferMasksInBox | ( | const amrex::Box | tbx, |
| amrex::IArrayBox & | buffer_mask, | ||
| const amrex::IArrayBox & | guard_mask, | ||
| const 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()
|
static |
◆ CheckGuardCells() [1/2]
|
private |
Check that the number of guard cells is smaller than the number of valid cells, for all available MultiFabs, and abort otherwise.
◆ CheckGuardCells() [2/2]
|
private |
Check that the number of guard cells is smaller than the number of valid cells, for a given MultiFab, and abort otherwise.
◆ CheckKnownIssues()
|
private |
Checks for known numerical issues involving different WarpX modules.
◆ CheckSignals()
|
staticprivate |
Check and clear signal flags and asynchronously broadcast them from process 0.
◆ ClearLevel()
|
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 > const | 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_ptrto) vectors; expected to be initialized to correct number of boxes and boxes per level
◆ ComputeDistanceToEB()
| void WarpX::ComputeDistanceToEB | ( | ) |
Compute the length of the mesh edges. Here the length is a value in [0, 1]. An edge of length 0 is fully covered.
◆ ComputeDivB() [1/2]
|
static |
◆ ComputeDivB() [2/2]
|
static |
◆ ComputeDivE()
| void WarpX::ComputeDivE | ( | amrex::MultiFab & | divE, |
| const 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 > const | 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 > const | beta = {{0,0,0}}, |
||
| amrex::Real const | required_precision = amrex::Real(1.e-11), |
||
| amrex::Real | absolute_tolerance = amrex::Real(0.0), |
||
| const int | max_iters = 200, |
||
| const 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()
|
private |
◆ ComputeSpaceChargeField()
| void WarpX::ComputeSpaceChargeField | ( | bool const | 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 const | required_precision = amrex::Real(1.e-11), |
||
| amrex::Real | absolute_tolerance = amrex::Real(0.0), |
||
| const int | max_iters = 200, |
||
| const 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()
◆ DampFieldsInGuards() [1/2]
| void WarpX::DampFieldsInGuards | ( | const 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 | ( | const 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]
◆ DampPML() [1/3]
| void WarpX::DampPML | ( | ) |
◆ DampPML() [2/3]
| void WarpX::DampPML | ( | const int | lev | ) |
◆ DampPML() [3/3]
◆ DampPML_Cartesian()
◆ 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
◆ DoPML()
|
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()
|
finalvirtual |
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]
◆ EvolveB() [3/3]
◆ EvolveBLondon() [1/3]
| void WarpX::EvolveBLondon | ( | amrex::Real | dt, |
| DtType | dt_type | ||
| ) |
◆ EvolveBLondon() [2/3]
◆ EvolveBLondon() [3/3]
◆ EvolveE() [1/3]
| void WarpX::EvolveE | ( | amrex::Real | dt | ) |
◆ EvolveE() [2/3]
| void WarpX::EvolveE | ( | int | lev, |
| amrex::Real | dt | ||
| ) |
◆ EvolveE() [3/3]
◆ EvolveEM()
|
private |
Advance the simulation by numsteps steps, electromagnetic case.
◆ EvolveF() [1/3]
| void WarpX::EvolveF | ( | amrex::Real | dt, |
| DtType | dt_type | ||
| ) |
◆ EvolveF() [2/3]
◆ EvolveF() [3/3]
◆ EvolveG() [1/3]
| void WarpX::EvolveG | ( | amrex::Real | dt, |
| DtType | dt_type | ||
| ) |
◆ EvolveG() [2/3]
◆ EvolveG() [3/3]
◆ fieldFactory()
|
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]
|
private |
◆ FillBoundaryB() [3/3]
| void WarpX::FillBoundaryB | ( | int | lev, |
| amrex::IntVect | ng, | ||
| std::optional< bool > | nodal_sync = std::nullopt |
||
| ) |
◆ 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]
|
private |
◆ FillBoundaryE() [1/3]
| void WarpX::FillBoundaryE | ( | amrex::IntVect | ng, |
| std::optional< bool > | nodal_sync = std::nullopt |
||
| ) |
◆ FillBoundaryE() [2/3]
|
private |
◆ FillBoundaryE() [3/3]
| void WarpX::FillBoundaryE | ( | int | lev, |
| amrex::IntVect | ng, | ||
| std::optional< bool > | nodal_sync = std::nullopt |
||
| ) |
◆ 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]
|
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]
|
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]
|
private |
◆ FillBoundaryJ() [1/3]
| void WarpX::FillBoundaryJ | ( | amrex::IntVect | ng | ) |
◆ FillBoundaryJ() [2/3]
| void WarpX::FillBoundaryJ | ( | const int | lev, |
| amrex::IntVect | ng | ||
| ) |
◆ FillBoundaryJ() [3/3]
|
private |
◆ GatherBufferMasks()
◆ get_accelerator_lattice()
|
inline |
◆ get_array_Bfield_aux()
|
inline |
◆ get_array_Efield_aux()
|
inline |
◆ get_load_balance_intervals()
|
inline |
returns the load balance interval
◆ get_ng_depos_J()
|
inline |
◆ get_ng_depos_rho()
|
inline |
◆ get_ng_fieldgather()
|
inline |
◆ get_numprocs()
|
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_Bfield_aux()
|
inline |
◆ get_pointer_Bfield_cp()
|
inline |
◆ get_pointer_Bfield_fp()
|
inline |
◆ get_pointer_Bfield_sc_fp()
|
inline |
◆ get_pointer_current_cp()
|
inline |
◆ get_pointer_current_fp()
|
inline |
◆ get_pointer_current_fp_nodal()
|
inline |
◆ get_pointer_edge_lengths()
|
inline |
◆ get_pointer_Efield_aux()
|
inline |
◆ get_pointer_Efield_cp()
|
inline |
◆ get_pointer_Efield_fp()
|
inline |
◆ get_pointer_F_cp()
|
inline |
◆ get_pointer_F_fp()
|
inline |
◆ get_pointer_face_areas()
|
inline |
◆ get_pointer_G_cp()
|
inline |
◆ get_pointer_G_fp()
|
inline |
◆ get_pointer_phi_fp()
|
inline |
◆ get_pointer_rho_cp()
|
inline |
◆ get_pointer_rho_fp()
|
inline |
◆ get_pointer_vector_potential_fp()
|
inline |
◆ get_spectral_solver_fp()
|
inline |
◆ getBfield()
|
inline |
◆ getBfield_avg_cp()
|
inline |
◆ getBfield_avg_fp()
|
inline |
◆ getBfield_cp()
|
inline |
◆ getBfield_fp()
|
inline |
◆ getBfield_sc_fp()
|
inline |
◆ getCosts()
|
static |
◆ getcurrent_cp()
|
inline |
◆ getcurrent_fp()
|
inline |
◆ getcurrent_injection_position()
|
inline |
◆ getCurrentBufferMasks()
|
inlineprivate |
◆ getdo_moving_window()
|
inline |
◆ getdt() [1/2]
|
inline |
◆ getdt() [2/2]
|
inline |
◆ getEfield()
|
inline |
◆ getEfield_avg_cp()
|
inline |
◆ getEfield_avg_fp()
|
inline |
◆ getEfield_cp()
|
inline |
◆ getEfield_fp()
|
inline |
◆ getF_cp()
|
inline |
◆ getF_fp()
|
inline |
◆ getFornbergStencilCoefficients()
|
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)
◆ getG_cp()
|
inline |
◆ getG_fp()
|
inline |
◆ getGatherBufferMasks()
|
inlineprivate |
◆ GetInstance()
|
static |
◆ getis_synchronized()
|
inline |
◆ getistep() [1/2]
|
inline |
◆ getistep() [2/2]
◆ getLoadBalanceEfficiency()
|
inline |
◆ getLondon()
|
inline |
◆ GetMacroscopicProperties()
|
inline |
◆ getmoving_window_x()
|
inline |
◆ GetMultiDiags()
|
inline |
◆ getngEB()
|
inline |
◆ getngF()
|
inline |
◆ getngUpdateAux()
|
inline |
◆ getnsubsteps() [1/2]
|
inline |
◆ getnsubsteps() [2/2]
◆ GetPartContainer()
|
inline |
◆ GetParticleBoundaryBuffer()
|
inline |
◆ getphi_fp()
|
inline |
◆ GetPML()
◆ GetPML_RZ()
◆ getPMLdirections()
| std::vector< bool > WarpX::getPMLdirections | ( | ) | const |
get low-high-low-high-... vector for each direction indicating if mother grid PMLs are enabled
◆ getPMLRZ()
|
inline |
◆ getRealBox()
|
static |
◆ GetRestartDMap()
|
private |
◆ getrho_cp()
|
inline |
◆ getrho_fp()
|
inline |
◆ gett_new() [1/2]
|
inline |
◆ gett_new() [2/2]
|
inline |
◆ gett_old() [1/2]
|
inline |
◆ gett_old() [2/2]
|
inline |
◆ GotoNextLine()
|
static |
◆ 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]
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
◆ InitBorrowing()
| void WarpX::InitBorrowing | ( | ) |
Initialize the memory for the FaceInfoBoxes.
◆ InitData()
| void WarpX::InitData | ( | ) |
◆ InitDiagnostics()
|
private |
◆ InitEB()
| void WarpX::InitEB | ( | ) |
◆ InitFilter()
|
private |
◆ InitFromCheckpoint()
|
private |
◆ 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, | ||
| const char | field, | ||
| const 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()
|
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_B_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_E_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()
|
private |
◆ InitPML()
|
private |
◆ isAnyBoundaryPML()
| bool WarpX::isAnyBoundaryPML | ( | ) |
◆ LoadBalance()
| void WarpX::LoadBalance | ( | ) |
perform load balance; compute and communicate new amrex::DistributionMapping
◆ LowerCorner()
|
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]
◆ MakeNewLevelFromCoarse()
|
finalprotectedvirtual |
Make a new level using provided BoxArray and DistributionMapping and fill with interpolated coarse level data. Called by AmrCore::regrid.
◆ MakeNewLevelFromScratch()
|
finalprotectedvirtual |
Make a new level from scratch using provided BoxArray and DistributionMapping. Only used during initialization. Called by AmrCoreInitFromScratch.
◆ maxStep()
|
inline |
◆ MoveWindow()
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()
Returns true if the moving window is active for the provided step
- Parameters
-
step time step
- Returns
- true if active, else false
◆ NodalSyncJ()
|
private |
◆ NodalSyncPML() [1/3]
| void WarpX::NodalSyncPML | ( | ) |
Synchronize the nodal points of the PML MultiFabs.
◆ NodalSyncPML() [2/3]
| void WarpX::NodalSyncPML | ( | int | lev | ) |
Synchronize the nodal points of the PML MultiFabs for given MR level.
◆ NodalSyncPML() [3/3]
Synchronize the nodal points of the PML MultiFabs for given MR level and patch.
◆ NodalSyncRho()
|
private |
◆ OneStep_multiJ()
|
private |
Perform one PIC iteration, with the multiple J deposition per time step.
◆ OneStep_nosub()
|
private |
◆ OneStep_sub1()
|
private |
◆ PerformanceHints()
|
private |
Check the requested resources and write performance hints
◆ PicsarVersion()
|
static |
Version of PICSAR dependency.
◆ PostProcessBaseGrids()
|
finalprotectedvirtual |
Use this function to override the Level 0 grids made by AMReX. This function is called in amrex::AmrCore::InitFromScratch.
Reimplemented from amrex::AmrMesh.
◆ PostRestart()
|
private |
◆ prepareFields()
| void WarpX::prepareFields | ( | int const | 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()
|
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()
|
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()
|
private |
Backward FFT of F on all mesh refinement levels.
◆ PSATDBackwardTransformG()
|
private |
Backward FFT of G on all mesh refinement levels.
◆ PSATDBackwardTransformJ()
|
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()
|
private |
Correct current in Fourier space so that the continuity equation is satisfied.
◆ PSATDEraseAverageFields()
|
private |
Set averaged E,B fields to zero before new iteration.
◆ PSATDForwardTransformEB()
|
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()
|
private |
Forward FFT of F on all mesh refinement levels.
◆ PSATDForwardTransformG()
|
private |
Forward FFT of G on all mesh refinement levels.
◆ PSATDForwardTransformJ()
|
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()
|
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()
|
private |
Copy J_new to J_old in spectral space (when J is linear in time)
◆ PSATDMoveRhoNewToRhoOld()
|
private |
Copy rho_new to rho_old in spectral space (when rho is linear in time)
◆ PSATDPushSpectralFields()
|
private |
Update all necessary fields in spectral space.
◆ PSATDScaleAverageFields()
|
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()
|
private |
Vay deposition in Fourier space (https://doi.org/10.1016/j.jcp.2013.03.010)
◆ PushParticlesandDepose() [1/2]
| void WarpX::PushParticlesandDepose | ( | amrex::Real | cur_time, |
| bool | skip_current = false |
||
| ) |
◆ PushParticlesandDepose() [2/2]
| void WarpX::PushParticlesandDepose | ( | int | lev, |
| amrex::Real | cur_time, | ||
| DtType | a_dt_type = DtType::Full, |
||
| bool | skip_current = false |
||
| ) |
◆ PushPSATD()
|
private |
◆ ReadExcitationParser()
| void WarpX::ReadExcitationParser | ( | ) |
Parse field excitation functions and flags
◆ ReadExternalFieldFromFile()
| void WarpX::ReadExternalFieldFromFile | ( | std::string | read_fields_from_path, |
| amrex::MultiFab * | mf, | ||
| std::string | F_name, | ||
| std::string | F_component | ||
| ) |
◆ ReadParameters()
|
private |
◆ RefRatio()
◆ RemakeLevel()
|
finalprotectedvirtual |
Remake an existing level using provided BoxArray and DistributionMapping and fill with existing fine and coarse data. Called by AmrCore::regrid.
◆ ReorderFornbergCoefficients()
|
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
◆ ResetCosts()
| void WarpX::ResetCosts | ( | ) |
resets costs to zero
◆ ResetInstance()
|
static |
◆ ResetProbDomain()
| void WarpX::ResetProbDomain | ( | const amrex::RealBox & | rb | ) |
◆ RestoreCurrent()
|
private |
◆ RestrictCurrentFromFineToCoarsePatch()
|
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()
|
private |
◆ ScrapeParticles()
|
private |
◆ setistep()
◆ setLoadBalanceEfficiency()
|
inline |
◆ setPhiBC()
| void WarpX::setPhiBC | ( | amrex::Vector< std::unique_ptr< amrex::MultiFab > > & | phi | ) | const |
◆ sett_new()
|
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()
|
static |
◆ ShrinkBorrowing()
| void WarpX::ShrinkBorrowing | ( | ) |
Shrink the vectors in the FaceInfoBoxes.
◆ stopTime()
|
inline |
◆ StoreCurrent()
|
private |
◆ SumBoundaryJ() [1/2]
|
private |
◆ SumBoundaryJ() [2/2]
|
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 | ||
| ) |
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)
◆ SyncCurrentAndRho()
| void WarpX::SyncCurrentAndRho | ( | ) |
Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels. 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 | ||
| ) |
◆ 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 MultiFabwhere the results of the finite-order centering are stored[in] src source MultiFabthat contains the values of the nodal current to be centered
◆ updateMaxStep()
|
inline |
◆ UpdatePlasmaInjectionPosition()
| void WarpX::UpdatePlasmaInjectionPosition | ( | amrex::Real | dt | ) |
◆ updateStopTime()
|
inline |
◆ UpperCorner()
|
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()
|
inline |
◆ 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 |
Member Data Documentation
◆ add_external_B_field
|
static |
Whether to apply the effect of an externally-defined magnetic field.
◆ add_external_E_field
|
static |
Whether to apply the effect of an externally-defined electric field.
◆ ApplyExcitationInPML
|
static |
◆ authors
|
static |
Author of an input file / simulation setup.
◆ B_excitation_grid_s
|
static |
◆ B_ext_grid_s
|
static |
Initialization type for external magnetic field on the grid.
◆ B_external_grid
|
static |
Initial magnetic field on the grid.
◆ beta_boost
|
static |
Beta value corresponding to the Lorentz factor of the boosted frame of the simulation.
◆ Bfield_aux
|
private |
◆ Bfield_avg_aux
|
private |
◆ Bfield_avg_cp
|
private |
◆ Bfield_avg_fp
|
private |
◆ Bfield_cax
|
private |
◆ Bfield_cp
|
private |
◆ Bfield_fp
|
private |
◆ Bfield_fp_external
|
private |
◆ Bfield_sc_fp
|
private |
◆ Bfield_slice
|
private |
◆ bilinear_filter
| BilinearFilter WarpX::bilinear_filter |
◆ boost_direction
|
static |
Direction of the Lorentz transform that defines the boosted frame of the simulation.
◆ Bxfield_flag_parser
| std::unique_ptr<amrex::Parser> WarpX::Bxfield_flag_parser |
◆ Bxfield_parser
| std::unique_ptr<amrex::Parser> WarpX::Bxfield_parser |
User-defined parser to initialize x-component of the magnetic field on the grid.
◆ Bxfield_xt_grid_parser
| std::unique_ptr<amrex::Parser> WarpX::Bxfield_xt_grid_parser |
◆ Byfield_flag_parser
| std::unique_ptr<amrex::Parser> WarpX::Byfield_flag_parser |
◆ Byfield_parser
| std::unique_ptr<amrex::Parser> WarpX::Byfield_parser |
User-defined parser to initialize y-component of the magnetic field on the grid.
◆ Byfield_xt_grid_parser
| std::unique_ptr<amrex::Parser> WarpX::Byfield_xt_grid_parser |
◆ Bzfield_flag_parser
| std::unique_ptr<amrex::Parser> WarpX::Bzfield_flag_parser |
◆ Bzfield_parser
| std::unique_ptr<amrex::Parser> WarpX::Bzfield_parser |
User-defined parser to initialize z-component of the magnetic field on the grid.
◆ Bzfield_xt_grid_parser
| std::unique_ptr<amrex::Parser> WarpX::Bzfield_xt_grid_parser |
◆ cfl
|
private |
◆ charge_buf
|
private |
◆ charge_deposition_algo
|
static |
Integer that corresponds to the charge deposition algorithm (only standard deposition)
◆ compute_max_step_from_btd
|
static |
If true, the code will compute max_step from the back transformed diagnostics.
◆ 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
|
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
|
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
|
private |
◆ current_buffer_masks
|
private |
◆ current_centering_nox
|
static |
Order of finite centering of currents (from nodal grid to staggered grid), along x.
◆ current_centering_noy
|
static |
Order of finite centering of currents (from nodal grid to staggered grid), along y.
◆ current_centering_noz
|
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
|
private |
◆ current_deposition_algo
|
static |
Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay)
◆ current_fp
|
private |
◆ current_fp_nodal
|
private |
◆ current_fp_vay
|
private |
◆ current_injection_position
|
private |
◆ current_slice
|
private |
◆ 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
|
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
|
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
|
static |
◆ do_divb_cleaning
|
static |
Solve additional Maxwell equation for G in order to control errors in magnetic Gauss' law.
◆ do_dive_cleaning
|
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
|
static |
◆ do_moving_window
|
static |
◆ do_multi_J
|
static |
◆ do_multi_J_n_depositions
|
static |
◆ do_pml
|
private |
◆ do_pml_divb_cleaning
|
private |
◆ do_pml_dive_cleaning
|
private |
◆ do_pml_Hi
|
private |
◆ do_pml_in_domain
|
private |
◆ do_pml_j_damping
|
private |
◆ do_pml_Lo
|
private |
◆ do_shared_mem_charge_deposition
|
static |
used shared memory algorithm for charge deposition
◆ do_shared_mem_current_deposition
|
static |
use shared memory algorithm for current deposition
◆ do_silver_mueller
|
private |
◆ do_similar_dm_pml
|
staticprivate |
◆ do_single_precision_comms
|
static |
perform field communications in single precision
◆ do_subcycling
|
static |
◆ dt
|
private |
◆ E_excitation_grid_s
|
static |
◆ E_ext_grid_s
|
static |
Initialization type for external electric field on the grid.
◆ E_external_grid
|
static |
Initial electric field on the grid.
◆ 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
|
private |
◆ Efield_avg_aux
|
private |
◆ Efield_avg_cp
|
private |
◆ Efield_avg_fp
|
private |
◆ Efield_cax
|
private |
◆ Efield_cp
|
private |
◆ Efield_fp
|
private |
◆ Efield_fp_external
|
private |
◆ Efield_slice
|
private |
◆ electromagnetic_solver_id
|
static |
Integer that corresponds to the type of Maxwell solver (Yee, CKC, PSATD, ECT)
◆ electrostatic_solver_id
|
static |
◆ em_solver_medium
|
static |
Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1)
◆ end_moving_window_step
|
static |
◆ Exfield_flag_parser
| std::unique_ptr<amrex::Parser> WarpX::Exfield_flag_parser |
◆ Exfield_parser
| std::unique_ptr<amrex::Parser> WarpX::Exfield_parser |
User-defined parser to initialize x-component of the electric field on the grid.
◆ Exfield_xt_grid_parser
| std::unique_ptr<amrex::Parser> WarpX::Exfield_xt_grid_parser |
◆ Eyfield_flag_parser
| std::unique_ptr<amrex::Parser> WarpX::Eyfield_flag_parser |
◆ Eyfield_parser
| std::unique_ptr<amrex::Parser> WarpX::Eyfield_parser |
User-defined parser to initialize y-component of the electric field on the grid.
◆ Eyfield_xt_grid_parser
| std::unique_ptr<amrex::Parser> WarpX::Eyfield_xt_grid_parser |
◆ Ezfield_flag_parser
| std::unique_ptr<amrex::Parser> WarpX::Ezfield_flag_parser |
◆ Ezfield_parser
| std::unique_ptr<amrex::Parser> WarpX::Ezfield_parser |
User-defined parser to initialize z-component of the electric field on the grid.
◆ Ezfield_xt_grid_parser
| std::unique_ptr<amrex::Parser> WarpX::Ezfield_xt_grid_parser |
◆ F_cp
|
private |
◆ F_fp
|
private |
◆ F_slice
|
private |
◆ fft_do_time_averaging
|
static |
◆ fft_periodic_single_box
|
private |
◆ field_boundary_hi
|
static |
◆ field_boundary_lo
|
static |
◆ field_centering_nox
|
static |
Order of finite centering of fields (from staggered grid to nodal grid), along x.
◆ field_centering_noy
|
static |
Order of finite centering of fields (from staggered grid to nodal grid), along y.
◆ field_centering_noz
|
static |
Order of finite centering of fields (from staggered grid to nodal grid), along z.
◆ field_gathering_algo
|
static |
Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving)
◆ field_io_nfiles
|
private |
◆ filter_npass_each_dir
|
static |
◆ fine_tag_hi
|
private |
◆ fine_tag_lo
|
private |
◆ G_cp
|
private |
◆ G_fp
|
private |
◆ G_slice
|
private |
◆ galerkin_interpolation
|
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
|
static |
Lorentz factor of the boosted frame in which a boosted-frame simulation is run.
◆ gather_buffer_masks
|
private |
◆ grid_type
|
static |
Integer that corresponds to the type of grid used in the simulation (collocated, staggered, hybrid)
◆ guard_cells
|
private |
◆ imultifab_map
|
static |
◆ injected_plasma_species
|
private |
◆ is_synchronized
|
private |
◆ istep
|
private |
◆ 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
|
static |
Records a number corresponding to the load balance cost update strategy being used (0, 1, 2 corresponding to timers, heuristic, or gpuclock).
◆ load_balance_efficiency
|
private |
Current load balance efficiency for each level.
◆ load_balance_efficiency_ratio_threshold
|
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
|
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
|
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
|
private |
Load balance with 'space filling curve' strategy.
◆ m_accelerator_lattice
|
private |
◆ 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_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_const_dt
|
private |
◆ m_distance_to_eb
|
private |
◆ m_edge_lengths
|
private |
EB: Lengths of the mesh edges.
◆ m_face_areas
|
private |
EB: Areas of the mesh faces.
◆ m_fdtd_solver_cp
|
private |
◆ m_fdtd_solver_fp
|
private |
◆ m_field_factory
|
private |
◆ m_fill_guards_current
|
static |
Whether to fill guard cells when computing inverse FFTs of currents.
◆ m_fill_guards_fields
|
static |
Whether to fill guard cells when computing inverse FFTs of fields.
◆ 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
|
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_instance
|
staticprivate |
◆ m_london
|
private |
◆ m_macroscopic_properties
|
private |
◆ 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
|
static |
Integer that correspond to macroscopic Maxwell solver algorithm (BackwardEuler - 0, Lax-Wendroff - 1)
◆ max_step
◆ mffile_nstreams
|
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
|
static |
◆ moving_window_v
|
static |
◆ moving_window_x
|
private |
◆ multi_diags
|
private |
◆ multifab_map
|
static |
◆ mypc
|
private |
◆ n_current_deposition_buffer
|
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
|
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
|
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
|
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
|
static |
Order of the particle shape factors (splines) along x.
◆ nox_fft
|
private |
◆ noy
|
static |
Order of the particle shape factors (splines) along y.
◆ noy_fft
|
private |
◆ noz
|
static |
Order of the particle shape factors (splines) along z.
◆ noz_fft
|
private |
◆ nsubsteps
|
private |
◆ num_injected_species
|
private |
◆ num_mirrors
|
static |
◆ numprocs
|
private |
Domain decomposition on Level 0.
◆ override_sync_intervals
|
private |
◆ particle_boundary_hi
|
static |
Integers that correspond to boundary condition applied to particles at the upper domain boundaries (0 to 3 correspond to Absorbing, Open, Reflecting, Periodic)
◆ particle_boundary_lo
|
static |
Integers that correspond to boundary condition applied to particles at the lower domain boundaries (0 to 3 correspond to Absorbing, Open, Reflecting, Periodic)
◆ particle_io_nfiles
|
private |
◆ particle_pusher_algo
|
static |
Integer that corresponds to the particle push algorithm (Boris, Vay, Higuera-Cary)
◆ phi_fp
|
private |
◆ plotfile_headerversion
|
private |
◆ pml
|
private |
◆ pml_delta
|
private |
◆ pml_has_particles
|
private |
◆ pml_ncell
|
private |
◆ pml_rz
|
private |
◆ 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
|
static |
◆ reduced_diags
| std::unique_ptr<MultiReducedDiags> WarpX::reduced_diags |
object with all reduced diagnotics, similar to MultiParticleContainer for species.
◆ refine_plasma
|
static |
◆ regrid_int
|
private |
◆ restart_chkfile
|
private |
◆ rho_cp
|
private |
◆ rho_fp
|
private |
◆ rho_in_time
|
static |
◆ rho_slice
|
private |
◆ safe_guard_cells
|
static |
◆ self_fields_absolute_tolerance
|
static |
◆ self_fields_max_iters
|
static |
◆ self_fields_required_precision
|
static |
◆ self_fields_verbosity
|
static |
◆ serialize_initial_conditions
|
static |
If true, the initial conditions from random number generators are serialized (useful for reproducible testing with OpenMP)
◆ shared_mem_current_tpb
|
static |
number of threads to use per block in shared deposition
◆ shared_tilesize
|
static |
tileSize to use for shared current deposition operations
◆ slice_cr_ratio
|
private |
◆ slice_max_grid_size
|
private |
◆ slice_plot_int
|
private |
◆ slice_plotfile_headerversion
|
private |
◆ slice_realbox
|
private |
◆ sort_bin_size
|
static |
◆ sort_idx_type
|
static |
Specifies the type of grid used for the above sorting, i.e. cell-centered, nodal, or mixed.
◆ sort_intervals
|
static |
◆ sort_particles_for_deposition
|
static |
If true, particles will be sorted in the order x -> y -> z -> ppc for faster deposition.
◆ spectral_solver_cp
|
private |
◆ spectral_solver_fp
|
private |
◆ start_moving_window_step
|
static |
◆ stop_time
|
private |
◆ str_Bx_excitation_flag_function
|
static |
◆ str_Bx_excitation_grid_function
|
static |
◆ str_Bx_ext_grid_function
|
static |
String storing parser function to initialize x-component of the magnetic field on the grid.
◆ str_By_excitation_flag_function
|
static |
◆ str_By_excitation_grid_function
|
static |
◆ str_By_ext_grid_function
|
static |
String storing parser function to initialize y-component of the magnetic field on the grid.
◆ str_Bz_excitation_flag_function
|
static |
◆ str_Bz_excitation_grid_function
|
static |
◆ str_Bz_ext_grid_function
|
static |
String storing parser function to initialize z-component of the magnetic field on the grid.
◆ str_Ex_excitation_flag_function
|
static |
◆ str_Ex_excitation_grid_function
|
static |
◆ str_Ex_ext_grid_function
|
static |
String storing parser function to initialize x-component of the electric field on the grid.
◆ str_Ey_excitation_flag_function
|
static |
◆ str_Ey_excitation_grid_function
|
static |
◆ str_Ey_ext_grid_function
|
static |
String storing parser function to initialize y-component of the electric field on the grid.
◆ str_Ez_excitation_flag_function
|
static |
◆ str_Ez_excitation_grid_function
|
static |
◆ str_Ez_ext_grid_function
|
static |
String storing parser function to initialize z-component of the electric field on the grid.
◆ sync_nodal_points
|
private |
◆ t_new
|
private |
◆ 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
|
static |
If true, a Numerical Cherenkov Instability (NCI) corrector is applied (for simulations using the FDTD Maxwell solver)
◆ use_filter
|
static |
If true, a bilinear filter is used to smooth charge and currents.
◆ use_filter_compensation
|
static |
If true, a compensation step is added to the bilinear filtering of charge and currents.
◆ use_hybrid_QED
|
private |
◆ use_kspace_filter
|
static |
If true, the bilinear filtering of charge and currents is done in Fourier space.
◆ use_single_read
|
private |
◆ use_single_write
|
private |
◆ v_particle_pml
|
private |
◆ vector_potential_fp_nodal
|
private |
◆ vector_potential_grad_buf_b_stag
|
private |
◆ vector_potential_grad_buf_e_stag
|
private |
◆ 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
|
static |
Flag whether the Verboncoeur correction is applied to the current and charge density on the axis when using RZ.
◆ verbose
|
private |
◆ warpx_do_continuous_injection
|
private |
◆ yee_coupled_solver_algo
|
static |
◆ zmax_plasma_to_compute_max_step
|
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
|
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/artemis-em/checkouts/latest/Source/WarpX.H
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/BoundaryConditions/WarpXEvolvePML.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/BoundaryConditions/WarpXFieldBoundaries.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Diagnostics/WarpXIO.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/EmbeddedBoundary/WarpXFaceExtensions.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/EmbeddedBoundary/WarpXInitEB.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Evolve/WarpXComputeDt.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Evolve/WarpXEvolve.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/FieldSolver/ElectrostaticSolver.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/FieldSolver/MagnetostaticSolver/MagnetostaticSolver.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/FieldSolver/WarpX_QED_Field_Pushers.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/FieldSolver/WarpXExternalEMFields.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/FieldSolver/WarpXPushFieldsEM.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Initialization/WarpXInitData.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Parallelization/WarpXComm.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Parallelization/WarpXRegrid.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Utils/WarpXMovingWindow.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Utils/WarpXTagging.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/Utils/WarpXVersion.cpp
- /home/docs/checkouts/readthedocs.org/user_builds/artemis-em/checkouts/latest/Source/WarpX.cpp
