_static/doxyhtml/_warp_x_8_h_source.html

 /* Copyright 2016-2020 Andrew Myers, Ann Almgren, Aurore Blelly

  *                     Axel Huebl, Burlen Loring, David Grote

  *                     Glenn Richardson, Junmin Gu, Luca Fedeli

  *                     Mathieu Lobet, Maxence Thevenet, Michael Rowan

  *                     Remi Lehe, Revathi Jambunathan, Weiqun Zhang

  *                     Yinjian Zhao

  *

  * This file is part of WarpX.

  *

  * License: BSD-3-Clause-LBNL

  */

 #ifndef WARPX_H_

 #define WARPX_H_


 #include "BoundaryConditions/PML_fwd.H"

 #include "Diagnostics/MultiDiagnostics_fwd.H"

 #include "Diagnostics/ReducedDiags/MultiReducedDiags_fwd.H"

 #include "EmbeddedBoundary/WarpXFaceInfoBox_fwd.H"

 #include "FieldSolver/FiniteDifferenceSolver/FiniteDifferenceSolver_fwd.H"

 #include "FieldSolver/FiniteDifferenceSolver/MacroscopicProperties/MacroscopicProperties_fwd.H"

 #include "FieldSolver/FiniteDifferenceSolver/HybridPICModel/HybridPICModel_fwd.H"

 #include "Filter/NCIGodfreyFilter_fwd.H"

 #include "Particles/ParticleBoundaryBuffer_fwd.H"

 #include "Particles/MultiParticleContainer_fwd.H"

 #include "Particles/WarpXParticleContainer_fwd.H"

 #ifdef WARPX_USE_PSATD

 #   ifdef WARPX_DIM_RZ

 #       include "FieldSolver/SpectralSolver/SpectralSolverRZ_fwd.H"

 #       include "BoundaryConditions/PML_RZ_fwd.H"

 #   else

 #       include "FieldSolver/SpectralSolver/SpectralSolver_fwd.H"

 #   endif

 #endif

 #include "Evolve/WarpXDtType.H"

 #include "FieldSolver/ElectrostaticSolver.H"

 #include "FieldSolver/MagnetostaticSolver/MagnetostaticSolver.H"

 #include "Filter/BilinearFilter.H"

 #include "Parallelization/GuardCellManager.H"

 #include "AcceleratorLattice/AcceleratorLattice.H"

 #include "Utils/Parser/IntervalsParser.H"

 #include "Utils/WarpXAlgorithmSelection.H"


 #include <AMReX.H>

 #include <AMReX_AmrCore.H>

 #include <AMReX_Array.H>

 #include <AMReX_Config.H>

 #ifdef AMREX_USE_EB

 #   include <AMReX_EBFabFactory.H>

 #endif

 #include <AMReX_GpuContainers.H>

 #include <AMReX_IntVect.H>

 #include <AMReX_LayoutData.H>

 #include <AMReX_Parser.H>

 #include <AMReX_REAL.H>

 #include <AMReX_RealBox.H>

 #include <AMReX_RealVect.H>

 #include <AMReX_Vector.H>

 #include <AMReX_VisMF.H>


 #include <AMReX_BaseFwd.H>

 #include <AMReX_AmrCoreFwd.H>


 #include <array>

 #include <iostream>

 #include <limits>

 #include <memory>

 #include <optional>

 #include <string>

 #include <vector>

 #include <map>


 enum struct PatchType : int

 {

     fine,

     coarse

 };


 class WarpX

     : public amrex::AmrCore

 {

 public:


     friend class PML;


     static WarpX& GetInstance ();

     static void ResetInstance ();


     WarpX ();

     ~WarpX ();


     static std::string Version ();

     static std::string PicsarVersion ();


     int Verbose () const { return verbose; }


     void InitData ();


     void Evolve (int numsteps = -1);


     MultiParticleContainer& GetPartContainer () { return *mypc; }

     MacroscopicProperties& GetMacroscopicProperties () { return *m_macroscopic_properties; }

     HybridPICModel& GetHybridPICModel () { return *m_hybrid_pic_model; }

     MultiDiagnostics& GetMultiDiags () {return *multi_diags;}


     ParticleBoundaryBuffer& GetParticleBoundaryBuffer () { return *m_particle_boundary_buffer; }


     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 std::string authors;


     static amrex::Vector<amrex::Real> E_external_grid;

     static amrex::Vector<amrex::Real> B_external_grid;


     static std::string B_ext_grid_s;

     static std::string E_ext_grid_s;


     static bool add_external_E_field;

     static bool add_external_B_field;


     static std::string str_Bx_ext_grid_function;

     static std::string str_By_ext_grid_function;

     static std::string str_Bz_ext_grid_function;

     static std::string str_Ex_ext_grid_function;

     static std::string str_Ey_ext_grid_function;

     static std::string str_Ez_ext_grid_function;


     std::unique_ptr<amrex::Parser> Bxfield_parser;

     std::unique_ptr<amrex::Parser> Byfield_parser;

     std::unique_ptr<amrex::Parser> Bzfield_parser;

     std::unique_ptr<amrex::Parser> Exfield_parser;

     std::unique_ptr<amrex::Parser> Eyfield_parser;

     std::unique_ptr<amrex::Parser> Ezfield_parser;


     // Algorithms

     static short current_deposition_algo;

     static short charge_deposition_algo;

     static short field_gathering_algo;

     static short particle_pusher_algo;

     static short electromagnetic_solver_id;

     static short load_balance_costs_update_algo;

     static int em_solver_medium;

     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 short psatd_solution_type;


     static short J_in_time;

     static short rho_in_time;


     static bool do_current_centering;


     //  to satisfy the continuity equation and charge conservation

     bool current_correction;


     bool update_with_rho = false;


     static bool do_single_precision_comms;


     static bool do_shared_mem_charge_deposition;


     static bool do_shared_mem_current_deposition;


     static int shared_mem_current_tpb;


     static amrex::IntVect shared_tilesize;


     static amrex::IntVect m_fill_guards_fields;


     static amrex::IntVect m_fill_guards_current;


     static bool do_dive_cleaning;

     static bool do_divb_cleaning;


     static int nox;

     static int noy;

     static int noz;


     static int field_centering_nox;

     static int field_centering_noy;

     static int field_centering_noz;


     static int current_centering_nox;

     static int current_centering_noy;

     static int current_centering_noz;


     static int n_rz_azimuthal_modes;

     static int ncomps;


     static bool use_fdtd_nci_corr;

     static bool galerkin_interpolation;


     static bool verboncoeur_axis_correction;


     static bool use_filter;

     static bool use_kspace_filter;

     static bool use_filter_compensation;


     static bool serialize_initial_conditions;


     static amrex::Real gamma_boost;

     static amrex::Real beta_boost;

     static amrex::Vector<int> boost_direction;

     static amrex::Real zmax_plasma_to_compute_max_step;

     static bool do_compute_max_step_from_zmax;

     static amrex::Real zmin_domain_boost_step_0;


     static bool compute_max_step_from_btd;


     static bool do_dynamic_scheduling;

     static bool refine_plasma;


     static utils::parser::IntervalsParser sort_intervals;

     static amrex::IntVect sort_bin_size;


     static bool sort_particles_for_deposition;

     static amrex::IntVect sort_idx_type;


     static bool do_subcycling;

     static bool do_multi_J;

     static int do_multi_J_n_depositions;


     static bool do_device_synchronize;

     static bool safe_guard_cells;


     static int n_field_gather_buffer;

     static int n_current_deposition_buffer;


     static short grid_type;


     // Global rho nodal flag to know about rho index type when rho MultiFab is not allocated

     amrex::IntVect m_rho_nodal_flag;


     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 int level,

         const std::string& name,

         std::optional<const amrex::Real> initial_value = {});


     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 int level,

         const std::string& name,

         std::optional<const int> initial_value = {});


     static void AliasInitMultiFab (

         std::unique_ptr<amrex::MultiFab>& mf,

         const amrex::MultiFab& mf_to_alias,

         const int scomp,

         const int ncomp,

         const int level,

         const std::string& name,

         std::optional<const amrex::Real> initial_value);


     // Maps of all of the MultiFabs and iMultiFabs used (this can include MFs from other classes)

     // This is a convenience for the Python interface, allowing all MultiFabs

     // to be easily referenced from Python.

     static std::map<std::string, amrex::MultiFab *> multifab_map;

     static std::map<std::string, amrex::iMultiFab *> imultifab_map;


     static void AddToMultiFabMap(const std::string& name, const std::unique_ptr<amrex::MultiFab>& mf) {

         multifab_map[name] = mf.get();

     }


     static void AddToMultiFabMap(const std::string& name, const std::unique_ptr<amrex::iMultiFab>& mf) {

         imultifab_map[name] = mf.get();

     }


     std::array<const amrex::MultiFab* const, 3>

     get_array_Bfield_aux  (const int lev) const {

         return {

             Bfield_aux[lev][0].get(),

             Bfield_aux[lev][1].get(),

             Bfield_aux[lev][2].get()

         };

     }

     std::array<const amrex::MultiFab* const, 3>

     get_array_Efield_aux  (const int lev) const {

         return {

             Efield_aux[lev][0].get(),

             Efield_aux[lev][1].get(),

             Efield_aux[lev][2].get()

         };

     }


     amrex::MultiFab * get_pointer_Efield_aux  (int lev, int direction) const { return Efield_aux[lev][direction].get(); }

     amrex::MultiFab * get_pointer_Bfield_aux  (int lev, int direction) const { return Bfield_aux[lev][direction].get(); }


     amrex::MultiFab * get_pointer_Efield_fp  (int lev, int direction) const { return Efield_fp[lev][direction].get(); }

     amrex::MultiFab * get_pointer_Bfield_fp  (int lev, int direction) const { return Bfield_fp[lev][direction].get(); }

     amrex::MultiFab * get_pointer_current_fp  (int lev, int direction) const { return current_fp[lev][direction].get(); }

     amrex::MultiFab * get_pointer_current_fp_nodal  (int lev, int direction) const { return current_fp_nodal[lev][direction].get(); }

     amrex::MultiFab * get_pointer_rho_fp  (int lev) const { return rho_fp[lev].get(); }

     amrex::MultiFab * get_pointer_F_fp  (int lev) const { return F_fp[lev].get(); }

     amrex::MultiFab * get_pointer_G_fp  (int lev) const { return G_fp[lev].get(); }

     amrex::MultiFab * get_pointer_phi_fp  (int lev) const { return phi_fp[lev].get(); }

     amrex::MultiFab * get_pointer_vector_potential_fp  (int lev, int direction) const { return vector_potential_fp_nodal[lev][direction].get(); }


     amrex::MultiFab * get_pointer_Efield_cp  (int lev, int direction) const { return Efield_cp[lev][direction].get(); }

     amrex::MultiFab * get_pointer_Bfield_cp  (int lev, int direction) const { return Bfield_cp[lev][direction].get(); }

     amrex::MultiFab * get_pointer_current_cp  (int lev, int direction) const { return current_cp[lev][direction].get(); }

     amrex::MultiFab * get_pointer_rho_cp  (int lev) const { return rho_cp[lev].get(); }

     amrex::MultiFab * get_pointer_F_cp  (int lev) const { return F_cp[lev].get(); }

     amrex::MultiFab * get_pointer_G_cp  (int lev) const { return G_cp[lev].get(); }


     amrex::MultiFab * get_pointer_edge_lengths  (int lev, int direction) const { return m_edge_lengths[lev][direction].get(); }

     amrex::MultiFab * get_pointer_face_areas  (int lev, int direction) const { return m_face_areas[lev][direction].get(); }


     const amrex::MultiFab& getEfield  (int lev, int direction) {return *Efield_aux[lev][direction];}

     const amrex::MultiFab& getBfield  (int lev, int direction) {return *Bfield_aux[lev][direction];}


     const amrex::MultiFab& getcurrent_cp (int lev, int direction) {return *current_cp[lev][direction];}

     const amrex::MultiFab& getEfield_cp  (int lev, int direction) {return  *Efield_cp[lev][direction];}

     const amrex::MultiFab& getBfield_cp  (int lev, int direction) {return  *Bfield_cp[lev][direction];}

     const amrex::MultiFab& getrho_cp (int lev) {return  *rho_cp[lev];}

     const amrex::MultiFab& getF_cp (int lev) {return *F_cp[lev];}

     const amrex::MultiFab& getG_cp (int lev) {return *G_cp[lev];}


     const amrex::MultiFab& getcurrent_fp (int lev, int direction) {return *current_fp[lev][direction];}

     const amrex::MultiFab& getEfield_fp  (int lev, int direction) {return *Efield_fp[lev][direction];}

     const amrex::MultiFab& getBfield_fp  (int lev, int direction) {return *Bfield_fp[lev][direction];}

     const amrex::MultiFab& getrho_fp (int lev) {return *rho_fp[lev];}

     const amrex::MultiFab& getphi_fp (int lev) {return *phi_fp[lev];}

     const amrex::MultiFab& getF_fp (int lev) {return *F_fp[lev];}

     const amrex::MultiFab& getG_fp (int lev) {return *G_fp[lev];}


     const amrex::MultiFab& getEfield_avg_fp (int lev, int direction) {return *Efield_avg_fp[lev][direction];}

     const amrex::MultiFab& getBfield_avg_fp (int lev, int direction) {return *Bfield_avg_fp[lev][direction];}

     const amrex::MultiFab& getEfield_avg_cp (int lev, int direction) {return *Efield_avg_cp[lev][direction];}

     const amrex::MultiFab& getBfield_avg_cp (int lev, int direction) {return *Bfield_avg_cp[lev][direction];}


     bool DoPML () const {return do_pml;}


 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)

     const PML_RZ* getPMLRZ() {return pml_rz[0].get();}

 #endif


     std::vector<bool> getPMLdirections() const;


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


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

     {

         if (m_instance)

         {

             m_instance->load_balance_efficiency[lev] = efficiency;

         } else

         {

             return;

         }

     }


     amrex::Real getLoadBalanceEfficiency (const int lev)

     {

         if (m_instance)

         {

             return m_instance->load_balance_efficiency[lev];

         } else

         {

             return -1;

         }

     }


     static amrex::IntVect filter_npass_each_dir;

     BilinearFilter bilinear_filter;

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

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


     amrex::Real time_of_last_gal_shift = 0;

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

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


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


     static int num_mirrors;

     amrex::Vector<amrex::Real> mirror_z;

     amrex::Vector<amrex::Real> mirror_z_width;

     amrex::Vector<int> mirror_z_npoints;


     std::unique_ptr<MultiReducedDiags> reduced_diags;


     void applyMirrors(amrex::Real time);


     void ComputeDt ();


     void PrintMainPICparameters ();


     void WriteUsedInputsFile () const;


     void PrintDtDxDyDz ();


     void ComputeMaxStep ();

     // Compute max_step automatically for simulations in a boosted frame.

     void computeMaxStepBoostAccelerator();


     int  MoveWindow (const int step, bool move_j);


     void ShiftGalileanBoundary ();

     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 MacroscopicEvolveE (         amrex::Real dt);

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

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


     void HybridPICEvolveFields ();


     void HybridPICDepositInitialRhoAndJ ();


     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);


     static amrex::Real quantum_xi_c2;


     void LoadBalance ();

     void ResetCosts ();


     utils::parser::IntervalsParser get_load_balance_intervals () const

     {

         return load_balance_intervals;

     }


     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);


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


 #ifdef WARPX_DIM_RZ

     void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab* Jx,

                                                    amrex::MultiFab* Jy,

                                                    amrex::MultiFab* Jz,

                                                    int lev);


     void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab* Rho,

                                                   int lev);

 #endif


     void ApplyRhofieldBoundary (const int lev, amrex::MultiFab* Rho,

                                 PatchType patch_type);


     void ApplyJfieldBoundary (const int lev, amrex::MultiFab* Jx,

                               amrex::MultiFab* Jy, amrex::MultiFab* Jz,

                               PatchType patch_type);


     void ApplyEfieldBoundary (const int lev, PatchType patch_type);

     void ApplyBfieldBoundary (const int lev, PatchType patch_type, DtType dt_type);


     void ApplyElectronPressureBoundary (const int lev, PatchType patch_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 ();

     bool isAnyBoundaryPML();


     void NodalSyncPML ();


     void NodalSyncPML (int lev);


     void NodalSyncPML (int lev, PatchType patch_type);


     PML* GetPML (int lev);

 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)

     PML_RZ* GetPML_RZ (int lev);

 #endif


     void doFieldIonization ();

     void doFieldIonization (int lev);


 #ifdef WARPX_QED

     void doQEDEvents ();

     void doQEDEvents (int lev);

 #endif


     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);


     // This function does aux(lev) = fp(lev) + I(aux(lev-1)-cp(lev)).

     // Caller must make sure fp and cp have ghost cells filled.

     void UpdateAuxilaryData ();

     void UpdateAuxilaryDataStagToNodal ();

     void UpdateAuxilaryDataSameType ();


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


     // Fill boundary cells including coarse/fine boundaries

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

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

     void FillBoundaryB_avg   (amrex::IntVect ng);

     void FillBoundaryE_avg   (amrex::IntVect ng);


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

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

     void FillBoundaryAux (amrex::IntVect ng);

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

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

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

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


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

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

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


     void SyncCurrentAndRho ();


     void SyncCurrent (

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_buffer);


     void SyncRho ();


     void SyncRho (

         const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,

         const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,

         const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_buffer);


     amrex::Vector<int> getnsubsteps () const {return nsubsteps;}

     int getnsubsteps (int lev) const {return nsubsteps[lev];}

     amrex::Vector<int> getistep () const {return istep;}

     int getistep (int lev) const {return istep[lev];}

     void setistep (int lev, int ii) {istep[lev] = ii;}

     amrex::Vector<amrex::Real> gett_old () const {return t_old;}

     amrex::Real gett_old (int lev) const {return t_old[lev];}

     amrex::Vector<amrex::Real> gett_new () const {return t_new;}

     amrex::Real gett_new (int lev) const {return t_new[lev];}

     void sett_new (int lev, amrex::Real time) {t_new[lev] = time;}

     amrex::Vector<amrex::Real> getdt () const {return dt;}

     amrex::Real getdt (int lev) const {return dt[lev];}

     int getdo_moving_window() const {return do_moving_window;}

     amrex::Real getmoving_window_x() const {return moving_window_x;}

     bool getis_synchronized() const {return is_synchronized;}


     int maxStep () const {return max_step;}

     void updateMaxStep (const int new_max_step) {max_step = new_max_step;}

     amrex::Real stopTime () const {return stop_time;}

     void updateStopTime (const amrex::Real new_stop_time) {stop_time = 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;


     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);

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


     static amrex::IntVect RefRatio (int lev);


     static const amrex::iMultiFab* CurrentBufferMasks (int lev);

     static const amrex::iMultiFab* GatherBufferMasks (int lev);


     static int electrostatic_solver_id;


     // Parameters for lab frame electrostatic

     static amrex::Real self_fields_required_precision;

     static amrex::Real self_fields_absolute_tolerance;

     static int self_fields_max_iters;

     static int self_fields_verbosity;


     static int do_moving_window; // boolean

     static int start_moving_window_step; // the first step to move window

     static int end_moving_window_step; // the last step to move window

     static int moving_window_active (int const step) {

         bool const step_before_end = (step < end_moving_window_step) || (end_moving_window_step < 0);

         bool const step_after_start = (step >= start_moving_window_step);

         return do_moving_window && step_before_end && step_after_start;

     }

     static int moving_window_dir;

     static amrex::Real moving_window_v;

     static bool fft_do_time_averaging;


     // these should be private, but can't due to Cuda limitations

     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);


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


     const amrex::IntVect getngEB() const { return guard_cells.ng_alloc_EB; }

     const amrex::IntVect getngF() const { return guard_cells.ng_alloc_F; }

     const amrex::IntVect getngUpdateAux() const { return guard_cells.ng_UpdateAux; }

     const amrex::IntVect get_ng_depos_J() const {return guard_cells.ng_depos_J;}

     const amrex::IntVect get_ng_depos_rho() const {return guard_cells.ng_depos_rho;}

     const amrex::IntVect get_ng_fieldgather () const {return guard_cells.ng_FieldGather;}


     const amrex::IntVect get_numprocs() const {return numprocs;}


     ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler;

     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;


     // Magnetostatic Solver Interface

     MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler;

     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);


     void ReadExternalFieldFromFile (

          std::string read_fields_from_path, amrex::MultiFab* mf,

          std::string F_name, std::string F_component);


     void InitializeEBGridData(int lev);


     void ComputeCostsHeuristic (amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > >& costs);


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


     static amrex::Vector<amrex::Real> getFornbergStencilCoefficients(const int n_order, const short a_grid_type);


     // Device vectors of stencil coefficients used for finite-order centering of fields

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

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

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


     // Device vectors of stencil coefficients used for finite-order centering of currents

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

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

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


     // This needs to be public for CUDA.

     virtual void ErrorEst (int lev, amrex::TagBoxArray& tags, amrex::Real time, int /*ngrow*/) final;


     // Return the accelerator lattice instance defined at the given refinement level

     const AcceleratorLattice& get_accelerator_lattice (int lev) {return *(m_accelerator_lattice[lev]);}


 protected:


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


     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 /*lev*/, amrex::Real /*time*/, const amrex::BoxArray& /*ba*/,

                                          const amrex::DistributionMapping& /*dm*/) final;


     virtual void RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray& ba,

                               const amrex::DistributionMapping& dm) final;


     virtual void ClearLevel (int lev) final;


 private:


     // Singleton is used when the code is run from python

     static WarpX* m_instance;


     static void CheckSignals ();

     void HandleSignals ();


     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 AddExternalFields ();


     void OneStep_nosub (amrex::Real t);

     void OneStep_sub1 (amrex::Real t);


     void OneStep_multiJ (const amrex::Real t);


     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);

     void AddCurrentFromFineLevelandSumBoundary (

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_buffer,

         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>>& current,

         const int lev,

         const int idim);

     void ApplyFilterJ (

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,

         const int lev);

     void SumBoundaryJ (

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,

         const int lev,

         const int idim,

         const amrex::Periodicity& period);

     void SumBoundaryJ (

         const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,

         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 amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_buffer,

         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();


     void CheckGuardCells(amrex::MultiFab const& mf);


     void CheckKnownIssues();


     void PerformanceHints ();


     void BuildBufferMasks ();

 public: // for cuda

     void BuildBufferMasksInBox ( const amrex::Box tbx, amrex::IArrayBox &buffer_mask,

                                  const amrex::IArrayBox &guard_mask, const int ng );

 private:

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

         return current_buffer_masks[lev].get();

     }

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

         return gather_buffer_masks[lev].get();

     }


     void ReorderFornbergCoefficients (amrex::Vector<amrex::Real>& ordered_coeffs,

                                       amrex::Vector<amrex::Real>& unordered_coeffs,

                                       const int order);

     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);


     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);


 #ifdef WARPX_USE_PSATD

 #   ifdef WARPX_DIM_RZ

     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);

 #   else

     void AllocLevelSpectralSolver (amrex::Vector<std::unique_ptr<SpectralSolver>>& spectral_solver,

                                    const int lev,

                                    const amrex::BoxArray& realspace_ba,

                                    const amrex::DistributionMapping& dm,

                                    const std::array<amrex::Real,3>& dx,

                                    const bool pml_flag=false);

 #   endif

 #endif


     amrex::Vector<int> istep;      // which step?

     amrex::Vector<int> nsubsteps;  // how many substeps on each level?


     amrex::Vector<amrex::Real> t_new;

     amrex::Vector<amrex::Real> t_old;

     amrex::Vector<amrex::Real> dt;


     // Particle container

     std::unique_ptr<MultiParticleContainer> mypc;

     std::unique_ptr<MultiDiagnostics> multi_diags;


     //

     // Fields: First array for level, second for direction

     //


     // Full solution

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

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


     // Fine patch

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

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

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

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

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

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

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

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

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

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


     // Memory buffers for computing magnetostatic fields

     // Vector Potential A and previous step.  Time buffer needed for computing dA/dt to first order

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

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

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


     // Same as Bfield_fp/Efield_fp for reading external field data

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

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


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

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


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

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

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

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


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

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


     //EB level set

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


     // store fine patch

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


     // Nodal MultiFab for nodal current deposition if warpx.do_current_centering = 1

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


     // Coarse patch

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

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

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

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

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

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

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

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


     // Copy of the coarse aux

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

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

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

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


     // If charge/current deposition buffers are used

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

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


     // PML

     int do_pml = 0;

     int do_silver_mueller = 0;

     int pml_ncell = 10;

     int pml_delta = 10;

     int pml_has_particles = 0;

     int do_pml_j_damping = 0;

     int do_pml_in_domain = 0;

     static int do_similar_dm_pml;

     bool do_pml_dive_cleaning; // default set in WarpX.cpp

     bool do_pml_divb_cleaning; // default set in WarpX.cpp

     amrex::Vector<amrex::IntVect> do_pml_Lo;

     amrex::Vector<amrex::IntVect> do_pml_Hi;

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

 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)

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

 #endif

     amrex::Real v_particle_pml;


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


     // Plasma injection parameters

     int warpx_do_continuous_injection = 0;

     int num_injected_species = -1;

     amrex::Vector<int> injected_plasma_species;


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


     // Macroscopic properties

     std::unique_ptr<MacroscopicProperties> m_macroscopic_properties;


     // Hybrid PIC algorithm parameters

     std::unique_ptr<HybridPICModel> m_hybrid_pic_model;


     // Load balancing

     utils::parser::IntervalsParser load_balance_intervals;

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

     int load_balance_with_sfc = 0;

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

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

     amrex::Vector<amrex::Real> load_balance_efficiency;

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

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


     // Determines timesteps for override sync

     utils::parser::IntervalsParser override_sync_intervals;


     // Other runtime parameters

     int verbose = 1;


     bool use_hybrid_QED = 0;


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

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


     int regrid_int = -1;


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


     std::string restart_chkfile;


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

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


     bool use_single_read = true;

     bool use_single_write = true;

     int mffile_nstreams = 4;

     int field_io_nfiles = 1024;

     int particle_io_nfiles = 1024;


     amrex::RealVect fine_tag_lo;

     amrex::RealVect fine_tag_hi;


     bool is_synchronized = true;


     // Synchronization of nodal points

     const bool sync_nodal_points = true;


     guardCellManager guard_cells;


     //Slice Parameters

     int slice_max_grid_size;

     int slice_plot_int = -1;

     amrex::RealBox slice_realbox;

     amrex::IntVect slice_cr_ratio;

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

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

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

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

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

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


     bool fft_periodic_single_box = false;

     int nox_fft = 16;

     int noy_fft = 16;

     int noz_fft = 16;


     amrex::IntVect numprocs{0};


     std::unique_ptr<ParticleBoundaryBuffer> m_particle_boundary_buffer;


     // Accelerator lattice elements

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


     //

     // Embedded Boundary

     //


     // Factory for field data

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


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

         return *m_field_factory[lev];

     }

 #ifdef AMREX_USE_EB

 public:

     amrex::EBFArrayBoxFactory const& fieldEBFactory (int lev) const noexcept {

         return static_cast<amrex::EBFArrayBoxFactory const&>(*m_field_factory[lev]);

     }

 #endif


 public:

     void InitEB ();

 public:

 #ifdef AMREX_USE_EB

     static void ComputeEdgeLengths (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,

                                     const amrex::EBFArrayBoxFactory& eb_fact);

     static void ComputeFaceAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,

                                   const amrex::EBFArrayBoxFactory& eb_fact);


     static void ScaleEdges (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,

                             const std::array<amrex::Real,3>& cell_size);

     static void ScaleAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,

                             const std::array<amrex::Real,3>& cell_size);

     void MarkCells();

 #endif

     void ComputeDistanceToEB ();

     amrex::Array1D<int, 0, 2> CountExtFaces();

     void ComputeFaceExtensions();

     void InitBorrowing();

     void ShrinkBorrowing();

     void ComputeOneWayExtensions();

     void ComputeEightWaysExtensions();

     void ApplyBCKCorrection(const int idim);


     void PSATDSubtractCurrentPartialSumsAvg ();


 private:

     void ScrapeParticles ();


     void PushPSATD ();


 #ifdef WARPX_USE_PSATD


     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);


     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);


     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);


     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);


     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);


     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);


     void PSATDMoveRhoNewToRhoOld ();


     void PSATDMoveJNewToJOld ();


     void PSATDForwardTransformF ();


     void PSATDBackwardTransformF ();


     void PSATDForwardTransformG ();


     void PSATDBackwardTransformG ();


     void PSATDCurrentCorrection ();


     void PSATDVayDeposition ();


     void PSATDPushSpectralFields ();


     void PSATDScaleAverageFields (const amrex::Real scale_factor);


     void PSATDEraseAverageFields ();


 #   ifdef WARPX_DIM_RZ

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

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

 #   else

         amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_fp;

         amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_cp;

 #   endif


 public:


 #   ifdef WARPX_DIM_RZ

         SpectralSolverRZ&

 #   else

         SpectralSolver&

 #   endif

             get_spectral_solver_fp (int lev) {return *spectral_solver_fp[lev];}

 #endif


 public:

     FiniteDifferenceSolver * get_pointer_fdtd_solver_fp (int lev) { return m_fdtd_solver_fp[lev].get(); }


 private:

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

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

 };


 #endif

AMReX.H

AMReX_AmrCoreFwd.H

AMReX_AmrCore.H

AMReX_Array.H

AMReX_BaseFwd.H

AMReX_EBFabFactory.H

AMReX_GpuContainers.H

AMReX_IntVect.H

AMReX_LayoutData.H

AMReX_Parser.H

AMReX_REAL.H

AMReX_RealBox.H

AMReX_RealVect.H

AMReX_Vector.H

AMReX_VisMF.H

AcceleratorLattice.H

BilinearFilter.H

ElectrostaticSolver.H

FiniteDifferenceSolver_fwd.H

GuardCellManager.H

HybridPICModel_fwd.H

IntervalsParser.H

MacroscopicProperties_fwd.H

MagnetostaticSolver.H

MultiDiagnostics_fwd.H

MultiParticleContainer_fwd.H

MultiReducedDiags_fwd.H

NCIGodfreyFilter_fwd.H

PML_RZ_fwd.H

PML_fwd.H

ParticleBoundaryBuffer_fwd.H

SpectralSolver_fwd.H

SpectralSolverRZ_fwd.H

PatchType
PatchType
Definition: WarpX.H:73

PatchType::coarse
@ coarse

PatchType::fine
@ fine

WarpXAlgorithmSelection.H

WarpXDtType.H

DtType
DtType
Definition: WarpXDtType.H:11

DtType::Full
@ Full

WarpXFaceInfoBox_fwd.H

WarpXParticleContainer_fwd.H

AcceleratorLattice
Definition: AcceleratorLattice.H:21

BilinearFilter
Definition: BilinearFilter.H:17

ElectrostaticSolver::PoissonBoundaryHandler
Definition: ElectrostaticSolver.H:35

FiniteDifferenceSolver
Top-level class for the electromagnetic finite-difference solver.
Definition: FiniteDifferenceSolver.H:34

HybridPICModel
This class contains the parameters needed to evaluate hybrid field solutions (kinetic ions with fluid...
Definition: HybridPICModel.H:30

MacroscopicProperties
This class contains the macroscopic properties of the medium needed to evaluate macroscopic Maxwell e...
Definition: MacroscopicProperties.H:32

MagnetostaticSolver::VectorPoissonBoundaryHandler
Definition: MagnetostaticSolver.H:21

MultiDiagnostics
This class contains a vector of all diagnostics in the simulation.
Definition: MultiDiagnostics.H:21

MultiParticleContainer
Definition: MultiParticleContainer.H:65

PML_RZ
Definition: PML_RZ.H:30

PML
Definition: PML.H:128

ParticleBoundaryBuffer
Definition: ParticleBoundaryBuffer.H:20

SpectralSolver
Top-level class for the electromagnetic spectral solver.
Definition: SpectralSolver.H:33

SpectralSolverRZ
Definition: SpectralSolverRZ.H:22

WarpX
Definition: WarpX.H:80

WarpX::DampFieldsInGuards
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 ...
Definition: WarpXPushFieldsEM.cpp:1066

WarpX::m_particle_boundary_buffer
std::unique_ptr< ParticleBoundaryBuffer > m_particle_boundary_buffer
particle buffer for scraped particles on the boundaries
Definition: WarpX.H:1578

WarpX::self_fields_max_iters
static int self_fields_max_iters
Definition: WarpX.H:918

WarpX::PSATDMoveRhoNewToRhoOld
void PSATDMoveRhoNewToRhoOld()
Copy rho_new to rho_old in spectral space (when rho is linear in time)
Definition: WarpXPushFieldsEM.cpp:561

WarpX::getrho_fp
const amrex::MultiFab & getrho_fp(int lev)
Definition: WarpX.H:511

WarpX::field_centering_nox
static int field_centering_nox
Order of finite centering of fields (from staggered grid to nodal grid), along x.
Definition: WarpX.H:258

WarpX::costs
amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > > costs
Definition: WarpX.H:1492

WarpX::current_deposition_algo
static short current_deposition_algo
Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay)
Definition: WarpX.H:160

WarpX::G_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_fp
Definition: WarpX.H:1362

WarpX::device_field_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_y
Definition: WarpX.H:1068

WarpX::moving_window_dir
static int moving_window_dir
Definition: WarpX.H:934

WarpX::SyncCurrent
void SyncCurrent(const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_fp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_cp, const amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 >> &J_buffer)
Apply filter and sum guard cells across MR levels. If current centering is used, center the current f...
Definition: WarpXComm.cpp:857

WarpX::device_current_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_x
Definition: WarpX.H:1072

WarpX::computePhi
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
Definition: ElectrostaticSolver.cpp:275

WarpX::InitFilter
void InitFilter()

WarpX::ComputeSpaceChargeField
void ComputeSpaceChargeField(bool const reset_fields)
Definition: ElectrostaticSolver.cpp:58

WarpX::BuildBufferMasks
void BuildBufferMasks()
Definition: WarpX.cpp:2886

WarpX::use_hybrid_QED
bool use_hybrid_QED
Definition: WarpX.H:1527

WarpX::do_dive_cleaning
static bool do_dive_cleaning
Definition: WarpX.H:246

WarpX::zmax_plasma_to_compute_max_step
static amrex::Real zmax_plasma_to_compute_max_step
Definition: WarpX.H:316

WarpX::doFieldIonization
void doFieldIonization()
Definition: WarpXEvolve.cpp:937

WarpX::get_pointer_edge_lengths
amrex::MultiFab * get_pointer_edge_lengths(int lev, int direction) const
Definition: WarpX.H:495

WarpX::get_ng_fieldgather
const amrex::IntVect get_ng_fieldgather() const
Definition: WarpX.H:954

WarpX::get_pointer_Efield_fp
amrex::MultiFab * get_pointer_Efield_fp(int lev, int direction) const
Definition: WarpX.H:478

WarpX::getEfield_fp
const amrex::MultiFab & getEfield_fp(int lev, int direction)
Definition: WarpX.H:509

WarpX::getngEB
const amrex::IntVect getngEB() const
Definition: WarpX.H:949

WarpX::Version
static std::string Version()
Version of WarpX executable.
Definition: WarpXVersion.cpp:14

WarpX::getnsubsteps
amrex::Vector< int > getnsubsteps() const
Definition: WarpX.H:857

WarpX::PSATDVayDeposition
void PSATDVayDeposition()
Vay deposition in Fourier space (https://doi.org/10.1016/j.jcp.2013.03.010)
Definition: WarpXPushFieldsEM.cpp:417

WarpX::do_multi_J
static bool do_multi_J
Definition: WarpX.H:340

WarpX::m_macroscopic_properties
std::unique_ptr< MacroscopicProperties > m_macroscopic_properties
Definition: WarpX.H:1481

WarpX::GetMultiDiags
MultiDiagnostics & GetMultiDiags()
Definition: WarpX.H:103

WarpX::DoPML
bool DoPML() const
Definition: WarpX.H:521

WarpX::getcurrent_cp
const amrex::MultiFab & getcurrent_cp(int lev, int direction)
Definition: WarpX.H:501

WarpX::rho_in_time
static short rho_in_time
Definition: WarpX.H:208

WarpX::UpdateAuxilaryDataSameType
void UpdateAuxilaryDataSameType()
Definition: WarpXComm.cpp:274

WarpX::PostProcessBaseGrids
virtual void PostProcessBaseGrids(amrex::BoxArray &ba0) const final
Definition: WarpXInitData.cpp:86

WarpX::pml_delta
int pml_delta
Definition: WarpX.H:1456

WarpX::m_field_factory
amrex::Vector< std::unique_ptr< amrex::FabFactory< amrex::FArrayBox > > > m_field_factory
Definition: WarpX.H:1588

WarpX::getis_synchronized
bool getis_synchronized() const
Definition: WarpX.H:871

WarpX::do_pml_j_damping
int do_pml_j_damping
Definition: WarpX.H:1458

WarpX::noy_fft
int noy_fft
Definition: WarpX.H:1571

WarpX::current_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_cp
Definition: WarpX.H:1436

WarpX::m_distance_to_eb
amrex::Vector< std::unique_ptr< amrex::MultiFab > > m_distance_to_eb
Definition: WarpX.H:1424

WarpX::Efield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_slice
Definition: WarpX.H:1566

WarpX::PSATDBackwardTransformEB
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)
Definition: WarpXPushFieldsEM.cpp:123

WarpX::NodalSyncPML
void NodalSyncPML()
Synchronize the nodal points of the PML MultiFabs.
Definition: WarpXComm.cpp:1477

WarpX::str_Ex_ext_grid_function
static std::string str_Ex_ext_grid_function
String storing parser function to initialize x-component of the electric field on the grid.
Definition: WarpX.H:139

WarpX::ComputeFaceExtensions
void ComputeFaceExtensions()
Main function computing the cell extension. Where possible it computes one-way extensions and,...
Definition: WarpXFaceExtensions.cpp:202

WarpX::CheckSignals
static void CheckSignals()
Check and clear signal flags and asynchronously broadcast them from process 0.
Definition: WarpXEvolve.cpp:1116

WarpX::m_v_galilean
amrex::Vector< amrex::Real > m_v_galilean
Definition: WarpX.H:560

WarpX::DampJPML
void DampJPML()
Definition: WarpXEvolvePML.cpp:220

WarpX::psatd_solution_type
static short psatd_solution_type
Definition: WarpX.H:203

WarpX::ResetProbDomain
void ResetProbDomain(const amrex::RealBox &rb)
Definition: WarpXMovingWindow.cpp:636

WarpX::gather_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > gather_buffer_masks
Definition: WarpX.H:1446

WarpX::updateStopTime
void updateStopTime(const amrex::Real new_stop_time)
Definition: WarpX.H:876

WarpX::get_array_Efield_aux
std::array< const amrex::MultiFab *const, 3 > get_array_Efield_aux(const int lev) const
Definition: WarpX.H:467

WarpX::mirror_z_npoints
amrex::Vector< int > mirror_z_npoints
Definition: WarpX.H:568

WarpX::zmin_domain_boost_step_0
static amrex::Real zmin_domain_boost_step_0
Definition: WarpX.H:323

WarpX::current_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_slice
Definition: WarpX.H:1565

WarpX::GatherBufferMasks
static const amrex::iMultiFab * GatherBufferMasks(int lev)
Definition: WarpX.cpp:3070

WarpX::do_compute_max_step_from_zmax
static bool do_compute_max_step_from_zmax
Definition: WarpX.H:320

WarpX::field_boundary_lo
static amrex::Vector< int > field_boundary_lo
Definition: WarpX.H:183

WarpX::sort_particles_for_deposition
static bool sort_particles_for_deposition
If true, particles will be sorted in the order x -> y -> z -> ppc for faster deposition.
Definition: WarpX.H:335

WarpX::get_spectral_solver_fp
SpectralSolverRZ & get_spectral_solver_fp(int lev)
Definition: WarpX.H:1861

WarpX::n_field_gather_buffer
static int n_field_gather_buffer
Definition: WarpX.H:349

WarpX::shiftMF
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={})
Definition: WarpXMovingWindow.cpp:414

WarpX::do_multi_J_n_depositions
static int do_multi_J_n_depositions
Definition: WarpX.H:341

WarpX::current_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_nodal
Definition: WarpX.H:1430

WarpX::MacroscopicEvolveE
void MacroscopicEvolveE(amrex::Real dt)
Definition: WarpXPushFieldsEM.cpp:1011

WarpX::t_new
amrex::Vector< amrex::Real > t_new
Definition: WarpX.H:1344

WarpX::do_single_precision_comms
static bool do_single_precision_comms
perform field communications in single precision
Definition: WarpX.H:224

WarpX::slice_cr_ratio
amrex::IntVect slice_cr_ratio
Definition: WarpX.H:1561

WarpX::SyncCurrentAndRho
void SyncCurrentAndRho()
Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels and apply...
Definition: WarpXEvolve.cpp:522

WarpX::field_io_nfiles
int field_io_nfiles
Definition: WarpX.H:1544

WarpX::particle_boundary_lo
static amrex::Vector< ParticleBoundaryType > particle_boundary_lo
Definition: WarpX.H:193

WarpX::AddSpaceChargeFieldLabFrame
void AddSpaceChargeFieldLabFrame()
Definition: ElectrostaticSolver.cpp:194

WarpX::B_external_grid
static amrex::Vector< amrex::Real > B_external_grid
Initial magnetic field on the grid.
Definition: WarpX.H:120

WarpX::current_store
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_store
Definition: WarpX.H:1427

WarpX::prepareFields
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

WarpX::CheckKnownIssues
void CheckKnownIssues()
Checks for known numerical issues involving different WarpX modules.

WarpX::guard_cells
guardCellManager guard_cells
Definition: WarpX.H:1555

WarpX::do_shared_mem_charge_deposition
static bool do_shared_mem_charge_deposition
used shared memory algorithm for charge deposition
Definition: WarpX.H:227

WarpX::slice_plotfile_headerversion
amrex::VisMF::Header::Version slice_plotfile_headerversion
Definition: WarpX.H:1539

WarpX::em_solver_medium
static int em_solver_medium
Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1)
Definition: WarpX.H:174

WarpX::ComputeMagnetostaticField
void ComputeMagnetostaticField()
Definition: MagnetostaticSolver.cpp:59

WarpX::computeB
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
Definition: ElectrostaticSolver.cpp:571

WarpX::stop_time
amrex::Real stop_time
Definition: WarpX.H:1530

WarpX::GetPartContainer
MultiParticleContainer & GetPartContainer()
Definition: WarpX.H:100

WarpX::boost_direction
static amrex::Vector< int > boost_direction
Direction of the Lorentz transform that defines the boosted frame of the simulation.
Definition: WarpX.H:312

WarpX::ComputeDt
void ComputeDt()
Definition: WarpXComputeDt.cpp:33

WarpX::PSATDSubtractCurrentPartialSumsAvg
void PSATDSubtractCurrentPartialSumsAvg()
Subtract the average of the cumulative sums of the preliminary current D from the current J (computed...
Definition: WarpXPushFieldsEM.cpp:430

WarpX::use_fdtd_nci_corr
static bool use_fdtd_nci_corr
Definition: WarpX.H:281

WarpX::verboncoeur_axis_correction
static bool verboncoeur_axis_correction
Definition: WarpX.H:295

WarpX::moving_window_v
static amrex::Real moving_window_v
Definition: WarpX.H:935

WarpX::do_shared_mem_current_deposition
static bool do_shared_mem_current_deposition
use shared memory algorithm for current deposition
Definition: WarpX.H:230

WarpX::do_pml_Hi
amrex::Vector< amrex::IntVect > do_pml_Hi
Definition: WarpX.H:1464

WarpX::setistep
void setistep(int lev, int ii)
Definition: WarpX.H:861

WarpX::get_pointer_vector_potential_fp
amrex::MultiFab * get_pointer_vector_potential_fp(int lev, int direction) const
Definition: WarpX.H:486

WarpX::BuildBufferMasksInBox
void BuildBufferMasksInBox(const amrex::Box tbx, amrex::IArrayBox &buffer_mask, const amrex::IArrayBox &guard_mask, const int ng)
Build buffer mask within given FArrayBox.
Definition: WarpX.cpp:2927

WarpX::fft_do_time_averaging
static bool fft_do_time_averaging
Definition: WarpX.H:936

WarpX::EvolveF
void EvolveF(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:917

WarpX::particle_pusher_algo
static short particle_pusher_algo
Integer that corresponds to the particle push algorithm (Boris, Vay, Higuera-Cary)
Definition: WarpX.H:166

WarpX::ClearLevel
virtual void ClearLevel(int lev) final
Delete level data. Called by AmrCore::regrid.
Definition: WarpX.cpp:1882

WarpX::pml
amrex::Vector< std::unique_ptr< PML > > pml
Definition: WarpX.H:1465

WarpX::FillBoundaryE_avg
void FillBoundaryE_avg(amrex::IntVect ng)
Definition: WarpXComm.cpp:521

WarpX::fine_tag_lo
amrex::RealVect fine_tag_lo
Definition: WarpX.H:1547

WarpX::restart_chkfile
std::string restart_chkfile
Definition: WarpX.H:1536

WarpX::m_instance
static WarpX * m_instance
Definition: WarpX.H:1140

WarpX::getG_fp
const amrex::MultiFab & getG_fp(int lev)
Definition: WarpX.H:514

WarpX::rho_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_cp
Definition: WarpX.H:1435

WarpX::get_pointer_G_fp
amrex::MultiFab * get_pointer_G_fp(int lev) const
Definition: WarpX.H:484

WarpX::getRealBox
static amrex::RealBox getRealBox(const amrex::Box &bx, int lev)
Definition: WarpX.cpp:2679

WarpX::do_dynamic_scheduling
static bool do_dynamic_scheduling
Definition: WarpX.H:328

WarpX::PostRestart
void PostRestart()

WarpX::getBfield_cp
const amrex::MultiFab & getBfield_cp(int lev, int direction)
Definition: WarpX.H:503

WarpX::ReorderFornbergCoefficients
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 cente...
Definition: WarpX.cpp:2992

WarpX::InitFromCheckpoint
void InitFromCheckpoint()
Definition: WarpXIO.cpp:94

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

WarpX::RestrictCurrentFromFineToCoarsePatch
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 fin...
Definition: WarpXComm.cpp:1101

WarpX::CellSize
static std::array< amrex::Real, 3 > CellSize(int lev)
Definition: WarpX.cpp:2665

WarpX::E_ext_grid_s
static std::string E_ext_grid_s
Initialization type for external electric field on the grid.
Definition: WarpX.H:125

WarpX::device_field_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_z
Definition: WarpX.H:1069

WarpX::AllocateCenteringCoefficients
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 ...
Definition: WarpX.cpp:3005

WarpX::get_pointer_phi_fp
amrex::MultiFab * get_pointer_phi_fp(int lev) const
Definition: WarpX.H:485

WarpX::PSATDForwardTransformEB
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.
Definition: WarpXPushFieldsEM.cpp:102

WarpX::self_fields_verbosity
static int self_fields_verbosity
Definition: WarpX.H:919

WarpX::stopTime
amrex::Real stopTime() const
Definition: WarpX.H:875

WarpX::Byfield_parser
std::unique_ptr< amrex::Parser > Byfield_parser
User-defined parser to initialize y-component of the magnetic field on the grid.
Definition: WarpX.H:148

WarpX::pml_rz
amrex::Vector< std::unique_ptr< PML_RZ > > pml_rz
Definition: WarpX.H:1467

WarpX::FillBoundaryE
void FillBoundaryE(amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
Definition: WarpXComm.cpp:485

WarpX::CountExtFaces
amrex::Array1D< int, 0, 2 > CountExtFaces()
Auxiliary function to count the amount of faces which still need to be extended.
Definition: WarpXFaceExtensions.cpp:166

WarpX::getphi_fp
const amrex::MultiFab & getphi_fp(int lev)
Definition: WarpX.H:512

WarpX::m_v_comoving
amrex::Vector< amrex::Real > m_v_comoving
Definition: WarpX.H:563

WarpX::InitData
void InitData()

WarpX::multifab_map
static std::map< std::string, amrex::MultiFab * > multifab_map
Definition: WarpX.H:435

WarpX::RestoreCurrent
void RestoreCurrent(const int lev)
Definition: WarpX.cpp:3087

WarpX::InitializeExternalFieldsOnGridUsingParser
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 func...

WarpX::PSATDBackwardTransformG
void PSATDBackwardTransformG()
Backward FFT of G on all mesh refinement levels.
Definition: WarpXPushFieldsEM.cpp:242

WarpX::m_galilean_shift
amrex::Array< amrex::Real, 3 > m_galilean_shift
Definition: WarpX.H:561

WarpX::device_field_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_x
Definition: WarpX.H:1067

WarpX::get_pointer_current_fp
amrex::MultiFab * get_pointer_current_fp(int lev, int direction) const
Definition: WarpX.H:480

WarpX::m_hybrid_pic_model
std::unique_ptr< HybridPICModel > m_hybrid_pic_model
Definition: WarpX.H:1484

WarpX::AddExternalFields
void AddExternalFields()

WarpX::UpdateCurrentNodalToStag
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 gr...
Definition: WarpXComm.cpp:428

WarpX::get_ng_depos_rho
const amrex::IntVect get_ng_depos_rho() const
Definition: WarpX.H:953

WarpX::get_pointer_current_cp
amrex::MultiFab * get_pointer_current_cp(int lev, int direction) const
Definition: WarpX.H:490

WarpX::getdt
amrex::Vector< amrex::Real > getdt() const
Definition: WarpX.H:867

WarpX::noz
static int noz
Order of the particle shape factors (splines) along z.
Definition: WarpX.H:255

WarpX::device_current_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_z
Definition: WarpX.H:1074

WarpX::gett_new
amrex::Vector< amrex::Real > gett_new() const
Definition: WarpX.H:864

WarpX::getBfield_avg_cp
const amrex::MultiFab & getBfield_avg_cp(int lev, int direction)
Definition: WarpX.H:519

WarpX::mffile_nstreams
int mffile_nstreams
Definition: WarpX.H:1543

WarpX::num_mirrors
static int num_mirrors
Definition: WarpX.H:565

WarpX::getPMLdirections
std::vector< bool > getPMLdirections() const
Definition: WarpX.cpp:2856

WarpX::ApplyElectronPressureBoundary
void ApplyElectronPressureBoundary(const int lev, PatchType patch_type)
When the Ohm's law solver is used, the electron pressure values on PEC boundaries are set to enforce ...
Definition: WarpXFieldBoundaries.cpp:94

WarpX::get_pointer_face_areas
amrex::MultiFab * get_pointer_face_areas(int lev, int direction) const
Definition: WarpX.H:496

WarpX::phi_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > phi_fp
Definition: WarpX.H:1364

WarpX::AddMagnetostaticFieldLabFrame
void AddMagnetostaticFieldLabFrame()
Definition: MagnetostaticSolver.cpp:71

WarpX::GetParticleBoundaryBuffer
ParticleBoundaryBuffer & GetParticleBoundaryBuffer()
Definition: WarpX.H:105

WarpX::WriteUsedInputsFile
void WriteUsedInputsFile() const

WarpX::AddSpaceChargeField
void AddSpaceChargeField(WarpXParticleContainer &pc)
Definition: ElectrostaticSolver.cpp:140

WarpX::OneStep_nosub
void OneStep_nosub(amrex::Real t)
Definition: WarpXEvolve.cpp:417

WarpX::do_pml_divb_cleaning
bool do_pml_divb_cleaning
Definition: WarpX.H:1462

WarpX::getistep
amrex::Vector< int > getistep() const
Definition: WarpX.H:859

WarpX::current_centering_noy
static int current_centering_noy
Order of finite centering of currents (from nodal grid to staggered grid), along y.
Definition: WarpX.H:267

WarpX::ReadParameters
void ReadParameters()
Definition: WarpX.cpp:499

WarpX::ResetInstance
static void ResetInstance()
Definition: WarpX.cpp:245

WarpX::AddToMultiFabMap
static void AddToMultiFabMap(const std::string &name, const std::unique_ptr< amrex::MultiFab > &mf)
Add the MultiFab to the map of MultiFabs.
Definition: WarpX.H:444

WarpX::verbose
int verbose
Definition: WarpX.H:1525

WarpX::device_current_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_y
Definition: WarpX.H:1073

WarpX::add_external_E_field
static bool add_external_E_field
Whether to apply the effect of an externally-defined electric field.
Definition: WarpX.H:128

WarpX::get_pointer_Efield_aux
amrex::MultiFab * get_pointer_Efield_aux(int lev, int direction) const
Definition: WarpX.H:475

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

WarpX::InitDiagnostics
void InitDiagnostics()

WarpX::MoveWindow
int MoveWindow(const int step, bool move_j)
Move the moving window.
Definition: WarpXMovingWindow.cpp:128

WarpX::Efield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_cp
Definition: WarpX.H:1439

WarpX::InitLevelData
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 initiali...

WarpX::getrho_cp
const amrex::MultiFab & getrho_cp(int lev)
Definition: WarpX.H:504

WarpX::load_balance_knapsack_factor
amrex::Real load_balance_knapsack_factor
Definition: WarpX.H:1499

WarpX::setVectorPotentialBC
void setVectorPotentialBC(amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, 3 > > &A) const
Definition: MagnetostaticSolver.cpp:206

WarpX::load_balance_efficiency
amrex::Vector< amrex::Real > load_balance_efficiency
Definition: WarpX.H:1507

WarpX::self_fields_required_precision
static amrex::Real self_fields_required_precision
Definition: WarpX.H:916

WarpX::sort_bin_size
static amrex::IntVect sort_bin_size
Definition: WarpX.H:332

WarpX::str_Bx_ext_grid_function
static std::string str_Bx_ext_grid_function
String storing parser function to initialize x-component of the magnetic field on the grid.
Definition: WarpX.H:133

WarpX::m_rho_nodal_flag
amrex::IntVect m_rho_nodal_flag
Definition: WarpX.H:360

WarpX::imultifab_map
static std::map< std::string, amrex::iMultiFab * > imultifab_map
Definition: WarpX.H:436

WarpX::load_balance_intervals
utils::parser::IntervalsParser load_balance_intervals
Definition: WarpX.H:1489

WarpX::m_flag_ext_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > > m_flag_ext_face
Definition: WarpX.H:1400

WarpX::current_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp
Definition: WarpX.H:1365

WarpX::LowerCorner
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.
Definition: WarpX.cpp:2687

WarpX::override_sync_intervals
utils::parser::IntervalsParser override_sync_intervals
Definition: WarpX.H:1522

WarpX::EvolveB
void EvolveB(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:795

WarpX::Bxfield_parser
std::unique_ptr< amrex::Parser > Bxfield_parser
User-defined parser to initialize x-component of the magnetic field on the grid.
Definition: WarpX.H:146

WarpX::isAnyBoundaryPML
bool isAnyBoundaryPML()
Definition: WarpX.cpp:3097

WarpX::get_load_balance_intervals
utils::parser::IntervalsParser get_load_balance_intervals() const
returns the load balance interval
Definition: WarpX.H:675

WarpX::ComputeCostsHeuristic
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,...
Definition: WarpXRegrid.cpp:370

WarpX::m_face_areas
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > m_face_areas
EB: Areas of the mesh faces.
Definition: WarpX.H:1385

WarpX::gett_old
amrex::Real gett_old(int lev) const
Definition: WarpX.H:863

WarpX::Exfield_parser
std::unique_ptr< amrex::Parser > Exfield_parser
User-defined parser to initialize x-component of the electric field on the grid.
Definition: WarpX.H:152

WarpX::Bfield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cax
Definition: WarpX.H:1444

WarpX::get_pointer_F_cp
amrex::MultiFab * get_pointer_F_cp(int lev) const
Definition: WarpX.H:492

WarpX::getF_fp
const amrex::MultiFab & getF_fp(int lev)
Definition: WarpX.H:513

WarpX::StoreCurrent
void StoreCurrent(const int lev)
Definition: WarpX.cpp:3076

WarpX::do_moving_window
static int do_moving_window
Definition: WarpX.H:921

WarpX::MakeNewLevelFromCoarse
virtual void MakeNewLevelFromCoarse(int, amrex::Real, const amrex::BoxArray &, const amrex::DistributionMapping &) final
Definition: WarpX.cpp:1875

WarpX::moving_window_x
amrex::Real moving_window_x
Definition: WarpX.H:1471

WarpX::get_pointer_Efield_cp
amrex::MultiFab * get_pointer_Efield_cp(int lev, int direction) const
Definition: WarpX.H:488

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

WarpX::str_By_ext_grid_function
static std::string str_By_ext_grid_function
String storing parser function to initialize y-component of the magnetic field on the grid.
Definition: WarpX.H:135

WarpX::maxStep
int maxStep() const
Definition: WarpX.H:873

WarpX::nox
static int nox
Order of the particle shape factors (splines) along x.
Definition: WarpX.H:251

WarpX::getnsubsteps
int getnsubsteps(int lev) const
Definition: WarpX.H:858

WarpX::quantum_xi_c2
static amrex::Real quantum_xi_c2
Definition: WarpX.H:664

WarpX::getngF
const amrex::IntVect getngF() const
Definition: WarpX.H:950

WarpX::GotoNextLine
static void GotoNextLine(std::istream &is)
Definition: WarpXIO.cpp:54

WarpX::InitFromScratch
void InitFromScratch()

WarpX::getFornbergStencilCoefficients
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 i...
Definition: WarpX.cpp:2949

WarpX::AllocLevelData
void AllocLevelData(int lev, const amrex::BoxArray &new_grids, const amrex::DistributionMapping &new_dmap)
Definition: WarpX.cpp:1950

WarpX::Bfield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_slice
Definition: WarpX.H:1567

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

WarpX::m_flag_info_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > > m_flag_info_face
Definition: WarpX.H:1393

WarpX::current_fp_vay
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_vay
Definition: WarpX.H:1366

WarpX::AddToMultiFabMap
static void AddToMultiFabMap(const std::string &name, const std::unique_ptr< amrex::iMultiFab > &mf)
Add the iMultiFab to the map of MultiFabs.
Definition: WarpX.H:454

WarpX::updateMaxStep
void updateMaxStep(const int new_max_step)
Definition: WarpX.H:874

WarpX::GetHybridPICModel
HybridPICModel & GetHybridPICModel()
Definition: WarpX.H:102

WarpX::PSATDMoveJNewToJOld
void PSATDMoveJNewToJOld()
Copy J_new to J_old in spectral space (when J is linear in time)
Definition: WarpXPushFieldsEM.cpp:577

WarpX::Bfield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cp
Definition: WarpX.H:1438

WarpX::serialize_initial_conditions
static bool serialize_initial_conditions
If true, the initial conditions from random number generators are serialized (useful for reproducible...
Definition: WarpX.H:305

WarpX::getGatherBufferMasks
const amrex::iMultiFab * getGatherBufferMasks(int lev) const
Definition: WarpX.H:1283

WarpX::Bzfield_parser
std::unique_ptr< amrex::Parser > Bzfield_parser
User-defined parser to initialize z-component of the magnetic field on the grid.
Definition: WarpX.H:150

WarpX::doQEDEvents
void doQEDEvents()
Definition: WarpXEvolve.cpp:954

WarpX::spectral_solver_fp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_fp
Definition: WarpX.H:1847

WarpX::ApplyInverseVolumeScalingToChargeDensity
void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab *Rho, int lev)
Definition: WarpXPushFieldsEM.cpp:1387

WarpX::m_fill_guards_fields
static amrex::IntVect m_fill_guards_fields
Whether to fill guard cells when computing inverse FFTs of fields.
Definition: WarpX.H:239

WarpX::CopyJPML
void CopyJPML()
Copy the current J from the regular grid to the PML.
Definition: WarpXEvolvePML.cpp:340

WarpX::grid_type
static short grid_type
Definition: WarpX.H:357

WarpX::vector_potential_grad_buf_b_stag
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > vector_potential_grad_buf_b_stag
Definition: WarpX.H:1376

WarpX::NodalSyncJ
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)
Definition: WarpXComm.cpp:1429

WarpX::Efield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_aux
Definition: WarpX.H:1357

WarpX::getEfield_cp
const amrex::MultiFab & getEfield_cp(int lev, int direction)
Definition: WarpX.H:502

WarpX::PSATDCurrentCorrection
void PSATDCurrentCorrection()
Correct current in Fourier space so that the continuity equation is satisfied.
Definition: WarpXPushFieldsEM.cpp:404

WarpX::current_centering_nox
static int current_centering_nox
Order of finite centering of currents (from nodal grid to staggered grid), along x.
Definition: WarpX.H:265

WarpX::get_pointer_Bfield_aux
amrex::MultiFab * get_pointer_Bfield_aux(int lev, int direction) const
Definition: WarpX.H:476

WarpX::use_filter_compensation
static bool use_filter_compensation
If true, a compensation step is added to the bilinear filtering of charge and currents.
Definition: WarpX.H:302

WarpX::vector_potential_grad_buf_e_stag
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > vector_potential_grad_buf_e_stag
Definition: WarpX.H:1375

WarpX::m_borrowing
amrex::Vector< std::array< std::unique_ptr< amrex::LayoutData< FaceInfoBox > >, 3 > > m_borrowing
Definition: WarpX.H:1408

WarpX::PSATDPushSpectralFields
void PSATDPushSpectralFields()
Update all necessary fields in spectral space.
Definition: WarpXPushFieldsEM.cpp:547

WarpX::add_external_B_field
static bool add_external_B_field
Whether to apply the effect of an externally-defined magnetic field.
Definition: WarpX.H:130

WarpX::charge_deposition_algo
static short charge_deposition_algo
Integer that corresponds to the charge deposition algorithm (only standard deposition)
Definition: WarpX.H:162

WarpX::PushParticlesandDepose
void PushParticlesandDepose(int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false)
Definition: WarpXEvolve.cpp:981

WarpX::cfl
amrex::Real cfl
Definition: WarpX.H:1534

WarpX::gett_new
amrex::Real gett_new(int lev) const
Definition: WarpX.H:865

WarpX::dt
amrex::Vector< amrex::Real > dt
Definition: WarpX.H:1346

WarpX::rho_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_slice
Definition: WarpX.H:1564

WarpX::F_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_cp
Definition: WarpX.H:1433

WarpX::HybridPICEvolveFields
void HybridPICEvolveFields()
Hybrid-PIC field evolve function. This function contains the logic involved in evolving the electric ...
Definition: WarpXPushFieldsHybridPIC.cpp:18

WarpX::nox_fft
int nox_fft
Definition: WarpX.H:1570

WarpX::UpdateAuxilaryData
void UpdateAuxilaryData()
Definition: WarpXComm.cpp:53

WarpX::particle_io_nfiles
int particle_io_nfiles
Definition: WarpX.H:1545

WarpX::is_synchronized
bool is_synchronized
Definition: WarpX.H:1550

WarpX::GetInstance
static WarpX & GetInstance()
Definition: WarpX.cpp:236

WarpX::fine_tag_hi
amrex::RealVect fine_tag_hi
Definition: WarpX.H:1548

WarpX::start_moving_window_step
static int start_moving_window_step
Definition: WarpX.H:922

WarpX::GetPML_RZ
PML_RZ * GetPML_RZ(int lev)
Definition: WarpX.cpp:2833

WarpX::PSATDForwardTransformF
void PSATDForwardTransformF()
Forward FFT of F on all mesh refinement levels.
Definition: WarpXPushFieldsEM.cpp:180

WarpX::do_silver_mueller
int do_silver_mueller
Definition: WarpX.H:1454

WarpX::setPhiBC
void setPhiBC(amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi) const
Definition: ElectrostaticSolver.cpp:372

WarpX::istep
amrex::Vector< int > istep
Definition: WarpX.H:1341

WarpX::electrostatic_solver_id
static int electrostatic_solver_id
Definition: WarpX.H:913

WarpX::PrintMainPICparameters
void PrintMainPICparameters()

WarpX::FillBoundaryB
void FillBoundaryB(amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
Definition: WarpXComm.cpp:476

WarpX::UpdatePlasmaInjectionPosition
void UpdatePlasmaInjectionPosition(amrex::Real dt)
Definition: WarpXMovingWindow.cpp:56

WarpX::RestrictRhoFromFineToCoarsePatch
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)
Definition: WarpXComm.cpp:1290

WarpX::get_accelerator_lattice
const AcceleratorLattice & get_accelerator_lattice(int lev)
Definition: WarpX.H:1081

WarpX::HandleSignals
void HandleSignals()
Complete the asynchronous broadcast of signal flags, and initiate a checkpoint if requested.
Definition: WarpXEvolve.cpp:1122

WarpX::G_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_slice
Definition: WarpX.H:1563

WarpX::n_current_deposition_buffer
static int n_current_deposition_buffer
Definition: WarpX.H:353

WarpX::F_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_fp
Definition: WarpX.H:1361

WarpX::field_boundary_hi
static amrex::Vector< int > field_boundary_hi
Definition: WarpX.H:188

WarpX::UpdateAuxilaryDataStagToNodal
void UpdateAuxilaryDataStagToNodal()
Definition: WarpXComm.cpp:65

WarpX::Verbose
int Verbose() const
Definition: WarpX.H:94

WarpX::Efield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cax
Definition: WarpX.H:1443

WarpX::charge_buf
amrex::Vector< std::unique_ptr< amrex::MultiFab > > charge_buf
Definition: WarpX.H:1450

WarpX::GetRestartDMap
amrex::DistributionMapping GetRestartDMap(const std::string &chkfile, const amrex::BoxArray &ba, int lev) const
Definition: WarpXIO.cpp:61

WarpX::get_array_Bfield_aux
std::array< const amrex::MultiFab *const, 3 > get_array_Bfield_aux(const int lev) const
Definition: WarpX.H:459

WarpX::m_edge_lengths
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > m_edge_lengths
EB: Lengths of the mesh edges.
Definition: WarpX.H:1383

WarpX::getCurrentBufferMasks
const amrex::iMultiFab * getCurrentBufferMasks(int lev) const
Definition: WarpX.H:1280

WarpX::ShiftGalileanBoundary
void ShiftGalileanBoundary()
This function shifts the boundary of the grid by 'm_v_galilean*dt'. In doding so, only positions attr...
Definition: WarpXMovingWindow.cpp:585

WarpX::Efield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_fp
Definition: WarpX.H:1369

WarpX::injected_plasma_species
amrex::Vector< int > injected_plasma_species
Definition: WarpX.H:1476

WarpX::do_device_synchronize
static bool do_device_synchronize
Definition: WarpX.H:343

WarpX::Evolve
void Evolve(int numsteps=-1)
Definition: WarpXEvolve.cpp:61

WarpX::CheckGuardCells
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,...

WarpX::use_kspace_filter
static bool use_kspace_filter
If true, the bilinear filtering of charge and currents is done in Fourier space.
Definition: WarpX.H:300

WarpX::get_pointer_F_fp
amrex::MultiFab * get_pointer_F_fp(int lev) const
Definition: WarpX.H:483

WarpX::InitNCICorrector
void InitNCICorrector()

WarpX::getistep
int getistep(int lev) const
Definition: WarpX.H:860

WarpX::multi_diags
std::unique_ptr< MultiDiagnostics > multi_diags
Definition: WarpX.H:1350

WarpX::Ezfield_parser
std::unique_ptr< amrex::Parser > Ezfield_parser
User-defined parser to initialize z-component of the electric field on the grid.
Definition: WarpX.H:156

WarpX::noy
static int noy
Order of the particle shape factors (splines) along y.
Definition: WarpX.H:253

WarpX::EvolveEM
void EvolveEM(int numsteps)

WarpX::nsubsteps
amrex::Vector< int > nsubsteps
Definition: WarpX.H:1342

WarpX::ComputeMaxStep
void ComputeMaxStep()
Compute the last time step of the simulation Calls computeMaxStepBoostAccelerator() if required.

WarpX::SyncRho
void SyncRho()
Definition: WarpXComm.cpp:1019

WarpX::noz_fft
int noz_fft
Definition: WarpX.H:1572

WarpX::PSATDForwardTransformRho
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)
Definition: WarpXPushFieldsEM.cpp:368

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

WarpX::field_centering_noz
static int field_centering_noz
Order of finite centering of fields (from staggered grid to nodal grid), along z.
Definition: WarpX.H:262

WarpX::sett_new
void sett_new(int lev, amrex::Real time)
Definition: WarpX.H:866

WarpX::computePhiTriDiagonal
void computePhiTriDiagonal(const amrex::Vector< std::unique_ptr< amrex::MultiFab > > &rho, amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi) const
Definition: ElectrostaticSolver.cpp:680

WarpX::load_balance_efficiency_ratio_threshold
amrex::Real load_balance_efficiency_ratio_threshold
Definition: WarpX.H:1505

WarpX::PSATDBackwardTransformEBavg
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.
Definition: WarpXPushFieldsEM.cpp:154

WarpX::DampPML
void DampPML()
Definition: WarpXEvolvePML.cpp:43

WarpX::PicsarVersion
static std::string PicsarVersion()
Version of PICSAR dependency.
Definition: WarpXVersion.cpp:27

WarpX::beta_boost
static amrex::Real beta_boost
Beta value corresponding to the Lorentz factor of the boosted frame of the simulation.
Definition: WarpX.H:310

WarpX::FillBoundaryAux
void FillBoundaryAux(amrex::IntVect ng)
Definition: WarpXComm.cpp:836

WarpX::PSATDBackwardTransformJ
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.
Definition: WarpXPushFieldsEM.cpp:332

WarpX::FillBoundaryB_avg
void FillBoundaryB_avg(amrex::IntVect ng)
Definition: WarpXComm.cpp:512

WarpX::ShrinkBorrowing
void ShrinkBorrowing()
Shrink the vectors in the FaceInfoBoxes.
Definition: WarpXFaceExtensions.cpp:739

WarpX::Efield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp_external
Definition: WarpX.H:1379

WarpX::ComputeDivE
void ComputeDivE(amrex::MultiFab &divE, const int lev)
Definition: WarpX.cpp:2817

WarpX::get_pointer_G_cp
amrex::MultiFab * get_pointer_G_cp(int lev) const
Definition: WarpX.H:493

WarpX::InitializeEBGridData
void InitializeEBGridData(int lev)
This function initializes and calculates grid quantities used along with EBs such as edge lengths,...

WarpX::CheckGuardCells
void CheckGuardCells()
Check that the number of guard cells is smaller than the number of valid cells, for all available Mul...

WarpX::do_divb_cleaning
static bool do_divb_cleaning
Solve additional Maxwell equation for G in order to control errors in magnetic Gauss' law.
Definition: WarpX.H:248

WarpX::NodalSyncRho
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)
Definition: WarpXComm.cpp:1453

WarpX::WarpX
WarpX()
Definition: WarpX.cpp:251

WarpX::get_ng_depos_J
const amrex::IntVect get_ng_depos_J() const
Definition: WarpX.H:952

WarpX::load_balance_with_sfc
int load_balance_with_sfc
Definition: WarpX.H:1494

WarpX::getLoadBalanceEfficiency
amrex::Real getLoadBalanceEfficiency(const int lev)
Definition: WarpX.H:543

WarpX::mypc
std::unique_ptr< MultiParticleContainer > mypc
Definition: WarpX.H:1349

WarpX::current_buf
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_buf
Definition: WarpX.H:1449

WarpX::use_filter
static bool use_filter
If true, a bilinear filter is used to smooth charge and currents.
Definition: WarpX.H:298

WarpX::get_pointer_rho_fp
amrex::MultiFab * get_pointer_rho_fp(int lev) const
Definition: WarpX.H:482

WarpX::m_fill_guards_current
static amrex::IntVect m_fill_guards_current
Whether to fill guard cells when computing inverse FFTs of currents.
Definition: WarpX.H:242

WarpX::GetMacroscopicProperties
MacroscopicProperties & GetMacroscopicProperties()
Definition: WarpX.H:101

WarpX::m_vector_poisson_boundary_handler
MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler
Definition: WarpX.H:990

WarpX::getG_cp
const amrex::MultiFab & getG_cp(int lev)
Definition: WarpX.H:506

WarpX::vector_potential_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > vector_potential_fp_nodal
Definition: WarpX.H:1374

WarpX::m_poisson_boundary_handler
ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler
Definition: WarpX.H:965

WarpX::shared_tilesize
static amrex::IntVect shared_tilesize
tileSize to use for shared current deposition operations
Definition: WarpX.H:236

WarpX::do_similar_dm_pml
static int do_similar_dm_pml
Definition: WarpX.H:1460

WarpX::str_Ey_ext_grid_function
static std::string str_Ey_ext_grid_function
String storing parser function to initialize y-component of the electric field on the grid.
Definition: WarpX.H:141

WarpX::m_fdtd_solver_fp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_fp
Definition: WarpX.H:1868

WarpX::ApplyInverseVolumeScalingToCurrentDensity
void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab *Jx, amrex::MultiFab *Jy, amrex::MultiFab *Jz, int lev)
Definition: WarpXPushFieldsEM.cpp:1214

WarpX::gett_old
amrex::Vector< amrex::Real > gett_old() const
Definition: WarpX.H:862

WarpX::current_centering_noz
static int current_centering_noz
Order of finite centering of currents (from nodal grid to staggered grid), along z.
Definition: WarpX.H:269

WarpX::safe_guard_cells
static bool safe_guard_cells
Definition: WarpX.H:344

WarpX::PSATDScaleAverageFields
void PSATDScaleAverageFields(const amrex::Real scale_factor)
Scale averaged E,B fields to account for time integration.
Definition: WarpXPushFieldsEM.cpp:623

WarpX::Efield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cp
Definition: WarpX.H:1437

WarpX::rho_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_fp
Definition: WarpX.H:1363

WarpX::slice_plot_int
int slice_plot_int
Definition: WarpX.H:1559

WarpX::get_pointer_rho_cp
amrex::MultiFab * get_pointer_rho_cp(int lev) const
Definition: WarpX.H:491

WarpX::InitEB
void InitEB()
Definition: WarpXInitEB.cpp:81

WarpX::BackwardCompatibility
void BackwardCompatibility()
Definition: WarpX.cpp:1624

WarpX::Bfield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp
Definition: WarpX.H:1368

WarpX::ECTRhofield
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > ECTRhofield
Definition: WarpX.H:1417

WarpX::ApplyEfieldBoundary
void ApplyEfieldBoundary(const int lev, PatchType patch_type)
Definition: WarpXFieldBoundaries.cpp:21

WarpX::num_injected_species
int num_injected_species
Definition: WarpX.H:1475

WarpX::AllocLevelSpectralSolverRZ
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)
Definition: WarpX.cpp:2575

WarpX::t_old
amrex::Vector< amrex::Real > t_old
Definition: WarpX.H:1345

WarpX::sort_idx_type
static amrex::IntVect sort_idx_type
Specifies the type of grid used for the above sorting, i.e. cell-centered, nodal, or mixed.
Definition: WarpX.H:337

WarpX::regrid_int
int regrid_int
Definition: WarpX.H:1532

WarpX::use_single_write
bool use_single_write
Definition: WarpX.H:1542

WarpX::AllocInitMultiFab
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 int level, const std::string &name, std::optional< const amrex::Real > initial_value={})
Allocate and optionally initialize the MultiFab. This also adds the MultiFab to the map of MultiFabs ...
Definition: WarpX.cpp:3115

WarpX::refine_plasma
static bool refine_plasma
Definition: WarpX.H:329

WarpX::fieldFactory
amrex::FabFactory< amrex::FArrayBox > const  & fieldFactory(int lev) const noexcept
Definition: WarpX.H:1590

WarpX::macroscopic_solver_algo
static int macroscopic_solver_algo
Definition: WarpX.H:178

WarpX::use_single_read
bool use_single_read
Definition: WarpX.H:1541

WarpX::Bfield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_aux
Definition: WarpX.H:1358

WarpX::numprocs
amrex::IntVect numprocs
Domain decomposition on Level 0.
Definition: WarpX.H:1575

WarpX::ncomps
static int ncomps
Definition: WarpX.H:277

WarpX::moving_window_active
static int moving_window_active(int const step)
Definition: WarpX.H:929

WarpX::PSATDForwardTransformG
void PSATDForwardTransformG()
Forward FFT of G on all mesh refinement levels.
Definition: WarpXPushFieldsEM.cpp:226

WarpX::sync_nodal_points
const bool sync_nodal_points
Definition: WarpX.H:1553

WarpX::DampPML_Cartesian
void DampPML_Cartesian(const int lev, PatchType patch_type)
Definition: WarpXEvolvePML.cpp:76

WarpX::getngUpdateAux
const amrex::IntVect getngUpdateAux() const
Definition: WarpX.H:951

WarpX::warpx_do_continuous_injection
int warpx_do_continuous_injection
Definition: WarpX.H:1474

WarpX::galerkin_interpolation
static bool galerkin_interpolation
Definition: WarpX.H:291

WarpX::str_Ez_ext_grid_function
static std::string str_Ez_ext_grid_function
String storing parser function to initialize z-component of the electric field on the grid.
Definition: WarpX.H:143

WarpX::do_pml_in_domain
int do_pml_in_domain
Definition: WarpX.H:1459

WarpX::PSATDForwardTransformJ
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)
Definition: WarpXPushFieldsEM.cpp:271

WarpX::nci_godfrey_filter_bxbyez
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > > nci_godfrey_filter_bxbyez
Definition: WarpX.H:557

WarpX::ErrorEst
virtual void ErrorEst(int lev, amrex::TagBoxArray &tags, amrex::Real time, int) final
Tagging cells for refinement.
Definition: WarpXTagging.cpp:28

WarpX::m_area_mod
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > m_area_mod
Definition: WarpX.H:1404

WarpX::AllocLevelMFs
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)
Definition: WarpX.cpp:2030

WarpX::PrintDtDxDyDz
void PrintDtDxDyDz()
Definition: WarpXComputeDt.cpp:102

WarpX::MakeNewLevelFromScratch
virtual void MakeNewLevelFromScratch(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final
Definition: WarpX.cpp:1866

WarpX::filter_npass_each_dir
static amrex::IntVect filter_npass_each_dir
Definition: WarpX.H:554

WarpX::getBfield_fp
const amrex::MultiFab & getBfield_fp(int lev, int direction)
Definition: WarpX.H:510

WarpX::ComputeDistanceToEB
void ComputeDistanceToEB()
Compute the length of the mesh edges. Here the length is a value in [0, 1]. An edge of length 0 is fu...
Definition: WarpXInitEB.cpp:408

WarpX::Venl
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Venl
Definition: WarpX.H:1421

WarpX::setLoadBalanceEfficiency
void setLoadBalanceEfficiency(const int lev, const amrex::Real efficiency)
Definition: WarpX.H:532

WarpX::electromagnetic_solver_id
static short electromagnetic_solver_id
Integer that corresponds to the type of Maxwell solver (Yee, CKC, PSATD, ECT)
Definition: WarpX.H:168

WarpX::InitPML
void InitPML()

WarpX::GetPML
PML * GetPML(int lev)
Definition: WarpX.cpp:2845

WarpX::v_particle_pml
amrex::Real v_particle_pml
Definition: WarpX.H:1469

WarpX::OneStep_sub1
void OneStep_sub1(amrex::Real t)
Definition: WarpXEvolve.cpp:778

WarpX::bilinear_filter
BilinearFilter bilinear_filter
Definition: WarpX.H:555

WarpX::FillBoundaryF
void FillBoundaryF(amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
Definition: WarpXComm.cpp:494

WarpX::get_pointer_current_fp_nodal
amrex::MultiFab * get_pointer_current_fp_nodal(int lev, int direction) const
Definition: WarpX.H:481

WarpX::fft_periodic_single_box
bool fft_periodic_single_box
Definition: WarpX.H:1569

WarpX::getEfield_avg_fp
const amrex::MultiFab & getEfield_avg_fp(int lev, int direction)
Definition: WarpX.H:516

WarpX::Bfield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_fp
Definition: WarpX.H:1370

WarpX::getBfield_avg_fp
const amrex::MultiFab & getBfield_avg_fp(int lev, int direction)
Definition: WarpX.H:517

WarpX::getCosts
static amrex::LayoutData< amrex::Real > * getCosts(int lev)
Definition: WarpX.cpp:2874

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

WarpX::PushPSATD
void PushPSATD()
Definition: WarpXPushFieldsEM.cpp:650

WarpX::field_centering_noy
static int field_centering_noy
Order of finite centering of fields (from staggered grid to nodal grid), along y.
Definition: WarpX.H:260

WarpX::do_pml
int do_pml
Definition: WarpX.H:1453

WarpX::str_Bz_ext_grid_function
static std::string str_Bz_ext_grid_function
String storing parser function to initialize z-component of the magnetic field on the grid.
Definition: WarpX.H:137

WarpX::getdt
amrex::Real getdt(int lev) const
Definition: WarpX.H:868

WarpX::Bfield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp_external
Definition: WarpX.H:1380

WarpX::RefRatio
static amrex::IntVect RefRatio(int lev)
Definition: WarpX.cpp:2737

WarpX::max_step
int max_step
Definition: WarpX.H:1529

WarpX::ApplyBfieldBoundary
void ApplyBfieldBoundary(const int lev, PatchType patch_type, DtType dt_type)
Definition: WarpXFieldBoundaries.cpp:46

WarpX::EvolveG
void EvolveG(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:967

WarpX::getEfield_avg_cp
const amrex::MultiFab & getEfield_avg_cp(int lev, int direction)
Definition: WarpX.H:518

WarpX::costs_heuristic_particles_wt
amrex::Real costs_heuristic_particles_wt
Definition: WarpX.H:1519

WarpX::pml_has_particles
int pml_has_particles
Definition: WarpX.H:1457

WarpX::nci_godfrey_filter_exeybz
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > > nci_godfrey_filter_exeybz
Definition: WarpX.H:556

WarpX::do_current_centering
static bool do_current_centering
Definition: WarpX.H:213

WarpX::mirror_z
amrex::Vector< amrex::Real > mirror_z
Definition: WarpX.H:566

WarpX::F_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_slice
Definition: WarpX.H:1562

WarpX::getdo_moving_window
int getdo_moving_window() const
Definition: WarpX.H:869

WarpX::do_subcycling
static bool do_subcycling
Definition: WarpX.H:339

WarpX::pml_ncell
int pml_ncell
Definition: WarpX.H:1455

WarpX::ComputeDivB
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)
Definition: WarpX.cpp:2743

WarpX::AliasInitMultiFab
static void AliasInitMultiFab(std::unique_ptr< amrex::MultiFab > &mf, const amrex::MultiFab &mf_to_alias, const int scomp, const int ncomp, const int level, const std::string &name, std::optional< const amrex::Real > initial_value)
Create an alias of a MultiFab, adding the alias to the MultiFab map.
Definition: WarpX.cpp:3155

WarpX::n_rz_azimuthal_modes
static int n_rz_azimuthal_modes
Number of modes for the RZ multi-mode version.
Definition: WarpX.H:272

WarpX::J_in_time
static short J_in_time
Definition: WarpX.H:207

WarpX::PSATDBackwardTransformF
void PSATDBackwardTransformF()
Backward FFT of F on all mesh refinement levels.
Definition: WarpXPushFieldsEM.cpp:196

WarpX::~WarpX
~WarpX()
Definition: WarpX.cpp:490

WarpX::gamma_boost
static amrex::Real gamma_boost
Lorentz factor of the boosted frame in which a boosted-frame simulation is run.
Definition: WarpX.H:308

WarpX::field_gathering_algo
static short field_gathering_algo
Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving)
Definition: WarpX.H:164

WarpX::Bfield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_cp
Definition: WarpX.H:1440

WarpX::shared_mem_current_tpb
static int shared_mem_current_tpb
number of threads to use per block in shared deposition
Definition: WarpX.H:233

WarpX::load_balance_costs_update_algo
static short load_balance_costs_update_algo
Definition: WarpX.H:172

WarpX::get_pointer_Bfield_fp
amrex::MultiFab * get_pointer_Bfield_fp(int lev, int direction) const
Definition: WarpX.H:479

WarpX::m_fdtd_solver_cp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_cp
Definition: WarpX.H:1869

WarpX::ResetCosts
void ResetCosts()
resets costs to zero
Definition: WarpXRegrid.cpp:400

WarpX::InitBorrowing
void InitBorrowing()
Initialize the memory for the FaceInfoBoxes.
Definition: WarpXFaceExtensions.cpp:277

WarpX::computeMaxStepBoostAccelerator
void computeMaxStepBoostAccelerator()

WarpX::OneStep_multiJ
void OneStep_multiJ(const amrex::Real t)
Perform one PIC iteration, with the multiple J deposition per time step.
Definition: WarpXEvolve.cpp:591

WarpX::mirror_z_width
amrex::Vector< amrex::Real > mirror_z_width
Definition: WarpX.H:567

WarpX::getcurrent_fp
const amrex::MultiFab & getcurrent_fp(int lev, int direction)
Definition: WarpX.H:508

WarpX::reduced_diags
std::unique_ptr< MultiReducedDiags > reduced_diags
object with all reduced diagnotics, similar to MultiParticleContainer for species.
Definition: WarpX.H:571

WarpX::getBfield
const amrex::MultiFab & getBfield(int lev, int direction)
Definition: WarpX.H:499

WarpX::PerformanceHints
void PerformanceHints()

WarpX::ApplyBCKCorrection
void ApplyBCKCorrection(const int idim)
Whenever an unstable cell cannot be extended we increase its area to be the minimal for stability....
Definition: WarpXFaceExtensions.cpp:706

WarpX::getF_cp
const amrex::MultiFab & getF_cp(int lev)
Definition: WarpX.H:505

WarpX::current_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > current_buffer_masks
Definition: WarpX.H:1445

WarpX::get_numprocs
const amrex::IntVect get_numprocs() const
Definition: WarpX.H:963

WarpX::ScrapeParticles
void ScrapeParticles()

WarpX::get_pointer_Bfield_cp
amrex::MultiFab * get_pointer_Bfield_cp(int lev, int direction) const
Definition: WarpX.H:489

WarpX::slice_max_grid_size
int slice_max_grid_size
Definition: WarpX.H:1558

WarpX::B_ext_grid_s
static std::string B_ext_grid_s
Initialization type for external magnetic field on the grid.
Definition: WarpX.H:123

WarpX::PSATDEraseAverageFields
void PSATDEraseAverageFields()
Set averaged E,B fields to zero before new iteration.
Definition: WarpXPushFieldsEM.cpp:597

WarpX::RemakeLevel
virtual void RemakeLevel(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final
Definition: WarpXRegrid.cpp:162

WarpX::G_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_cp
Definition: WarpX.H:1434

WarpX::FillBoundaryG
void FillBoundaryG(amrex::IntVect ng, std::optional< bool > nodal_sync=std::nullopt)
Definition: WarpXComm.cpp:503

WarpX::getEfield
const amrex::MultiFab & getEfield(int lev, int direction)
Definition: WarpX.H:498

WarpX::ComputeEightWaysExtensions
void ComputeEightWaysExtensions()
Do the eight-ways extension.
Definition: WarpXFaceExtensions.cpp:548

WarpX::ApplyFilterandSumBoundaryRho
void ApplyFilterandSumBoundaryRho(int lev, int glev, amrex::MultiFab &rho, int icomp, int ncomp)
Definition: WarpXComm.cpp:1317

WarpX::Eyfield_parser
std::unique_ptr< amrex::Parser > Eyfield_parser
User-defined parser to initialize y-component of the electric field on the grid.
Definition: WarpX.H:154

WarpX::self_fields_absolute_tolerance
static amrex::Real self_fields_absolute_tolerance
Definition: WarpX.H:917

WarpX::m_accelerator_lattice
amrex::Vector< std::unique_ptr< AcceleratorLattice > > m_accelerator_lattice
Definition: WarpX.H:1581

WarpX::EvolveE
void EvolveE(amrex::Real dt)
Definition: WarpXPushFieldsEM.cpp:844

WarpX::particle_boundary_hi
static amrex::Vector< ParticleBoundaryType > particle_boundary_hi
Definition: WarpX.H:198

WarpX::m_const_dt
std::optional< amrex::Real > m_const_dt
Definition: WarpX.H:1478

WarpX::UpperCorner
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.
Definition: WarpX.cpp:2712

WarpX::ComputeOneWayExtensions
void ComputeOneWayExtensions()
Do the one-way extension.
Definition: WarpXFaceExtensions.cpp:424

WarpX::Hybrid_QED_Push
void Hybrid_QED_Push(amrex::Vector< amrex::Real > dt)
Definition: WarpX_QED_Field_Pushers.cpp:46

WarpX::get_pointer_fdtd_solver_fp
FiniteDifferenceSolver * get_pointer_fdtd_solver_fp(int lev)
Definition: WarpX.H:1865

WarpX::slice_realbox
amrex::RealBox slice_realbox
Definition: WarpX.H:1560

WarpX::do_pml_Lo
amrex::Vector< amrex::IntVect > do_pml_Lo
Definition: WarpX.H:1463

WarpX::applyMirrors
void applyMirrors(amrex::Real time)
Definition: WarpXEvolve.cpp:1046

WarpX::spectral_solver_cp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_cp
Definition: WarpX.H:1848

WarpX::getmoving_window_x
amrex::Real getmoving_window_x() const
Definition: WarpX.H:870

WarpX::costs_heuristic_cells_wt
amrex::Real costs_heuristic_cells_wt
Definition: WarpX.H:1513

WarpX::E_external_grid
static amrex::Vector< amrex::Real > E_external_grid
Initial electric field on the grid.
Definition: WarpX.H:118

WarpX::do_pml_dive_cleaning
bool do_pml_dive_cleaning
Definition: WarpX.H:1461

WarpX::authors
static std::string authors
Author of an input file / simulation setup.
Definition: WarpX.H:115

WarpX::plotfile_headerversion
amrex::VisMF::Header::Version plotfile_headerversion
Definition: WarpX.H:1538

WarpX::AddBoundaryField
void AddBoundaryField()
Definition: ElectrostaticSolver.cpp:100

WarpX::getPMLRZ
const PML_RZ * getPMLRZ()
Definition: WarpX.H:524

WarpX::ApplyRhofieldBoundary
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 refle...
Definition: WarpXFieldBoundaries.cpp:81

WarpX::compute_max_step_from_btd
static bool compute_max_step_from_btd
If true, the code will compute max_step from the back transformed diagnostics.
Definition: WarpX.H:326

WarpX::computeE
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
Definition: ElectrostaticSolver.cpp:453

WarpX::current_correction
bool current_correction
If true, a correction is applied to the current in Fourier space,.
Definition: WarpX.H:217

WarpX::CurrentBufferMasks
static const amrex::iMultiFab * CurrentBufferMasks(int lev)
Definition: WarpX.cpp:3064

WarpX::ComputePMLFactors
void ComputePMLFactors()

WarpX::end_moving_window_step
static int end_moving_window_step
Definition: WarpX.H:923

WarpX::sort_intervals
static utils::parser::IntervalsParser sort_intervals
Definition: WarpX.H:331

WarpX::computeVectorPotential
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
Definition: MagnetostaticSolver.cpp:142

WarpX::Efield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp
Definition: WarpX.H:1367

WarpX::ApplyJfieldBoundary
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 refl...
Definition: WarpXFieldBoundaries.cpp:87

WarpX::update_with_rho
bool update_with_rho
Definition: WarpX.H:221

WarpX::HybridPICDepositInitialRhoAndJ
void HybridPICDepositInitialRhoAndJ()
Hybrid-PIC initial deposition function. The hybrid-PIC algorithm uses the charge and current density ...
Definition: WarpXPushFieldsHybridPIC.cpp:171

WarpX::LoadBalance
void LoadBalance()
perform load balance; compute and communicate new amrex::DistributionMapping
Definition: WarpXRegrid.cpp:52

WarpX::time_of_last_gal_shift
amrex::Real time_of_last_gal_shift
Definition: WarpX.H:559

WarpXParticleContainer
Definition: WarpXParticleContainer.H:105

amrex::AmrCore

amrex::AmrMesh::geom
Vector< Geometry > geom

amrex::BoxArray

amrex::Box

amrex::DistributionMapping

amrex::EBFArrayBoxFactory

amrex::FabFactory

amrex::Geometry

amrex::IArrayBox

amrex::IntVect

amrex::LayoutData

amrex::MultiFab

amrex::PODVector

amrex::Periodicity

amrex::RealBox

amrex::RealVect

amrex::TagBoxArray

amrex::Vector

amrex::iMultiFab

guardCellManager
This class computes and stores the number of guard cells needed for the allocation of the MultiFabs a...
Definition: GuardCellManager.H:20

guardCellManager::ng_depos_rho
amrex::IntVect ng_depos_rho
Definition: GuardCellManager.H:108

guardCellManager::ng_depos_J
amrex::IntVect ng_depos_J
Definition: GuardCellManager.H:107

guardCellManager::ng_alloc_F
amrex::IntVect ng_alloc_F
Definition: GuardCellManager.H:85

guardCellManager::ng_alloc_EB
amrex::IntVect ng_alloc_EB
Definition: GuardCellManager.H:79

guardCellManager::ng_UpdateAux
amrex::IntVect ng_UpdateAux
Definition: GuardCellManager.H:100

guardCellManager::ng_FieldGather
amrex::IntVect ng_FieldGather
Definition: GuardCellManager.H:98

utils::parser::IntervalsParser
This class is a parser for multiple slices of the form x,y,z,... where x, y and z are slices of the f...
Definition: IntervalsParser.H:103

AnyFFT::direction
direction
Definition: AnyFFT.H:75

int
const int[]

amrex::Array
std::array< T, N > Array

check_interp_points_and_weights.ii
ii
Definition: check_interp_points_and_weights.py:148

compute_domain.cell_size
cell_size
Definition: compute_domain.py:37

stencil.dx
int dx
Definition: stencil.py:436

stencil.name
string name
Definition: stencil.py:452

video_yt.field
string field
Definition: video_yt.py:31

amrex::Array1D

amrex::ParserExecutor

amrex::VisMF::Header::Version
Version

amrex::VisMF::Header::Version_v1
Version_v1

verbosity
int verbosity()