WarpX
WarpX.H
Go to the documentation of this file.
1 /* Copyright 2016-2020 Andrew Myers, Ann Almgren, Aurore Blelly
2  * Axel Huebl, Burlen Loring, David Grote
3  * Glenn Richardson, Junmin Gu, Luca Fedeli
4  * Mathieu Lobet, Maxence Thevenet, Michael Rowan
5  * Remi Lehe, Revathi Jambunathan, Weiqun Zhang
6  * Yinjian Zhao
7  *
8  * This file is part of WarpX.
9  *
10  * License: BSD-3-Clause-LBNL
11  */
12 #ifndef WARPX_H_
13 #define WARPX_H_
14 
15 #include "BoundaryConditions/PML_fwd.H"
16 #include "Diagnostics/MultiDiagnostics_fwd.H"
17 #include "Diagnostics/ReducedDiags/MultiReducedDiags_fwd.H"
18 #include "EmbeddedBoundary/WarpXFaceInfoBox_fwd.H"
19 #include "FieldSolver/FiniteDifferenceSolver/FiniteDifferenceSolver_fwd.H"
20 #include "FieldSolver/FiniteDifferenceSolver/MacroscopicProperties/MacroscopicProperties_fwd.H"
21 #include "FieldSolver/FiniteDifferenceSolver/HybridPICModel/HybridPICModel_fwd.H"
22 #include "Filter/NCIGodfreyFilter_fwd.H"
23 #include "Initialization/ExternalField_fwd.H"
24 #include "Particles/ParticleBoundaryBuffer_fwd.H"
25 #include "Particles/MultiParticleContainer_fwd.H"
26 #include "Particles/WarpXParticleContainer_fwd.H"
27 #include "Fluids/MultiFluidContainer_fwd.H"
28 #include "Fluids/WarpXFluidContainer_fwd.H"
29 
30 #ifdef WARPX_USE_PSATD
31 # ifdef WARPX_DIM_RZ
32 # include "FieldSolver/SpectralSolver/SpectralSolverRZ_fwd.H"
33 # include "BoundaryConditions/PML_RZ_fwd.H"
34 # else
35 # include "FieldSolver/SpectralSolver/SpectralSolver_fwd.H"
36 # endif
37 #endif
38 #include "AcceleratorLattice/AcceleratorLattice.H"
39 #include "Evolve/WarpXDtType.H"
40 #include "Evolve/WarpXPushType.H"
41 #include "FieldSolver/Fields.H"
42 #include "FieldSolver/ElectrostaticSolver.H"
43 #include "FieldSolver/MagnetostaticSolver/MagnetostaticSolver.H"
44 #include "Filter/BilinearFilter.H"
45 #include "Parallelization/GuardCellManager.H"
46 #include "Utils/Parser/IntervalsParser.H"
47 #include "Utils/WarpXAlgorithmSelection.H"
48 #include "Utils/export.H"
49 
50 #include <AMReX.H>
51 #include <AMReX_AmrCore.H>
52 #include <AMReX_Array.H>
53 #include <AMReX_Config.H>
54 #ifdef AMREX_USE_EB
55 # include <AMReX_EBFabFactory.H>
56 #endif
57 #include <AMReX_GpuContainers.H>
58 #include <AMReX_IntVect.H>
59 #include <AMReX_LayoutData.H>
60 #include <AMReX_Parser.H>
61 #include <AMReX_REAL.H>
62 #include <AMReX_RealBox.H>
63 #include <AMReX_RealVect.H>
64 #include <AMReX_Vector.H>
65 #include <AMReX_VisMF.H>
66 
67 #include <AMReX_BaseFwd.H>
68 #include <AMReX_AmrCoreFwd.H>
69 
70 #include <array>
71 #include <iostream>
72 #include <limits>
73 #include <map>
74 #include <memory>
75 #include <optional>
76 #include <string>
77 #include <vector>
78 
79 class WARPX_EXPORT WarpX
80  : public amrex::AmrCore
81 {
82 public:
83 
84  static WarpX& GetInstance ();
85 
86  static void ResetInstance ();
87 
92  static void Finalize();
93 
95  ~WarpX () override;
96 
98  WarpX ( WarpX const &) = delete;
100  WarpX& operator= ( WarpX const & ) = delete;
101 
103  WarpX ( WarpX && ) = default;
105  WarpX& operator= ( WarpX && ) = default;
106 
107  static std::string Version ();
108  static std::string PicsarVersion ();
109 
110  [[nodiscard]] int Verbose () const { return verbose; }
111 
112  void InitData ();
113 
114  void Evolve (int numsteps = -1);
115 
116  void EvolveImplicitPicardInit (int lev);
117  void SaveParticlesAtImplicitStepStart (WarpXParticleContainer& pc, int lev);
118  void FinishImplicitParticleUpdate (WarpXParticleContainer& pc, int lev);
119  void FinishImplicitFieldUpdate(amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > >& Efield_fp,
120  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > >& Efield_n);
121 
122  MultiParticleContainer& GetPartContainer () { return *mypc; }
123  MultiFluidContainer& GetFluidContainer () { return *myfl; }
124  MacroscopicProperties& GetMacroscopicProperties () { return *m_macroscopic_properties; }
125  HybridPICModel& GetHybridPICModel () { return *m_hybrid_pic_model; }
126  [[nodiscard]] HybridPICModel * get_pointer_HybridPICModel () const { return m_hybrid_pic_model.get(); }
127  MultiDiagnostics& GetMultiDiags () {return *multi_diags;}
128 #ifdef AMREX_USE_EB
129  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& GetDistanceToEB () {return m_distance_to_eb;}
130 #endif
131  ParticleBoundaryBuffer& GetParticleBoundaryBuffer () { return *m_particle_boundary_buffer; }
132 
133  static void shiftMF (amrex::MultiFab& mf, const amrex::Geometry& geom,
134  int num_shift, int dir, int lev, bool update_cost_flag,
135  amrex::Real external_field=0.0, bool useparser = false,
136  amrex::ParserExecutor<3> const& field_parser={});
137 
143  [[nodiscard]] std::string GetAuthors () const { return m_authors; }
144 
149  int maxlevel_extEMfield_init;
150 
151  // Algorithms
153  static short current_deposition_algo;
155  static short charge_deposition_algo;
157  static short field_gathering_algo;
159  static short particle_pusher_algo;
161  static short electromagnetic_solver_id;
163  static short evolve_scheme;
165  static int max_picard_iterations;
167  static amrex::Real picard_iteration_tolerance;
169  static bool require_picard_convergence;
173  static short load_balance_costs_update_algo;
175  static int em_solver_medium;
179  static int macroscopic_solver_algo;
184  static amrex::Vector<FieldBoundaryType> field_boundary_lo;
189  static amrex::Vector<FieldBoundaryType> field_boundary_hi;
194  static amrex::Vector<ParticleBoundaryType> particle_boundary_lo;
199  static amrex::Vector<ParticleBoundaryType> particle_boundary_hi;
200 
204  static short psatd_solution_type;
205 
208  static short J_in_time;
209  static short rho_in_time;
210 
214  static bool do_current_centering;
215 
217  // to satisfy the continuity equation and charge conservation
218  bool current_correction;
219 
222  bool update_with_rho = false;
223 
225  static bool do_single_precision_comms;
226 
228  static bool do_shared_mem_charge_deposition;
229 
231  static bool do_shared_mem_current_deposition;
232 
234  static int shared_mem_current_tpb;
235 
237  static amrex::IntVect shared_tilesize;
238 
240  static amrex::IntVect m_fill_guards_fields;
241 
243  static amrex::IntVect m_fill_guards_current;
244 
247  static bool do_dive_cleaning;
249  static bool do_divb_cleaning;
250 
252  static int nox;
254  static int noy;
256  static int noz;
257 
259  static int field_centering_nox;
261  static int field_centering_noy;
263  static int field_centering_noz;
264 
266  static int current_centering_nox;
268  static int current_centering_noy;
270  static int current_centering_noz;
271 
273  static int n_rz_azimuthal_modes;
278  static int ncomps;
279 
282  static bool use_fdtd_nci_corr;
292  static bool galerkin_interpolation;
293 
296  static bool verboncoeur_axis_correction;
297 
299  static bool use_filter;
301  static bool use_kspace_filter;
303  static bool use_filter_compensation;
304 
306  static bool serialize_initial_conditions;
307 
309  static amrex::Real gamma_boost;
311  static amrex::Real beta_boost;
313  static amrex::Vector<int> boost_direction;
317  static amrex::Real zmax_plasma_to_compute_max_step;
321  static bool do_compute_max_step_from_zmax;
324  static amrex::Real zmin_domain_boost_step_0;
325 
327  static bool compute_max_step_from_btd;
328 
329  static bool do_dynamic_scheduling;
330  static bool refine_plasma;
331 
332  static utils::parser::IntervalsParser sort_intervals;
333  static amrex::IntVect sort_bin_size;
334 
336  static bool sort_particles_for_deposition;
338  static amrex::IntVect sort_idx_type;
339 
340  static bool do_subcycling;
341  static bool do_multi_J;
342  static int do_multi_J_n_depositions;
343 
344  static bool do_device_synchronize;
345  static bool safe_guard_cells;
346 
350  static int n_field_gather_buffer;
354  static int n_current_deposition_buffer;
355 
358  static short grid_type;
359 
360  // Global rho nodal flag to know about rho index type when rho MultiFab is not allocated
361  amrex::IntVect m_rho_nodal_flag;
362 
378  static void AllocInitMultiFab (
379  std::unique_ptr<amrex::MultiFab>& mf,
380  const amrex::BoxArray& ba,
381  const amrex::DistributionMapping& dm,
382  int ncomp,
383  const amrex::IntVect& ngrow,
384  int level,
385  const std::string& name,
386  std::optional<const amrex::Real> initial_value = {});
387 
403  static void AllocInitMultiFab (
404  std::unique_ptr<amrex::iMultiFab>& mf,
405  const amrex::BoxArray& ba,
406  const amrex::DistributionMapping& dm,
407  int ncomp,
408  const amrex::IntVect& ngrow,
409  int level,
410  const std::string& name,
411  std::optional<const int> initial_value = {});
412 
424  static void AliasInitMultiFab (
425  std::unique_ptr<amrex::MultiFab>& mf,
426  const amrex::MultiFab& mf_to_alias,
427  int scomp,
428  int ncomp,
429  int level,
430  const std::string& name,
431  std::optional<const amrex::Real> initial_value);
432 
445  static void AllocInitMultiFabFromModel (
446  std::unique_ptr<amrex::MultiFab>& mf,
447  amrex::MultiFab& mf_model,
448  int level,
449  const std::string& name,
450  std::optional<const amrex::Real> initial_value = {});
451 
452  // Maps of all of the MultiFabs and iMultiFabs used (this can include MFs from other classes)
453  // This is a convenience for the Python interface, allowing all MultiFabs
454  // to be easily referenced from Python.
455  static std::map<std::string, amrex::MultiFab *> multifab_map;
456  static std::map<std::string, amrex::iMultiFab *> imultifab_map;
457 
468  [[nodiscard]] bool
469  isFieldInitialized (warpx::fields::FieldType field_type, int lev, int direction = 0) const;
470 
481  [[nodiscard]] amrex::MultiFab*
482  getFieldPointer (warpx::fields::FieldType field_type, int lev, int direction = 0) const;
483 
493  [[nodiscard]] std::array<const amrex::MultiFab* const, 3>
494  getFieldPointerArray (warpx::fields::FieldType field_type, int lev) const;
495 
506  [[nodiscard]] const amrex::MultiFab&
507  getField(warpx::fields::FieldType field_type, int lev, int direction = 0) const;
508 
509  [[nodiscard]] bool DoPML () const {return do_pml;}
510  [[nodiscard]] bool DoFluidSpecies () const {return do_fluid_species;}
511 
512 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
513  const PML_RZ* getPMLRZ() {return pml_rz[0].get();}
514 #endif
515 
517  [[nodiscard]] std::vector<bool> getPMLdirections() const;
518 
519  static amrex::LayoutData<amrex::Real>* getCosts (int lev);
520 
521  void setLoadBalanceEfficiency (int lev, amrex::Real efficiency);
522 
523  amrex::Real getLoadBalanceEfficiency (int lev);
524 
525  static amrex::IntVect filter_npass_each_dir;
526  BilinearFilter bilinear_filter;
527  amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > nci_godfrey_filter_exeybz;
528  amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > nci_godfrey_filter_bxbyez;
529 
530  amrex::Real time_of_last_gal_shift = 0;
531  amrex::Vector<amrex::Real> m_v_galilean = amrex::Vector<amrex::Real>(3, amrex::Real(0.));
532  amrex::Array<amrex::Real,3> m_galilean_shift = {{0}};
533 
534  amrex::Vector<amrex::Real> m_v_comoving = amrex::Vector<amrex::Real>(3, amrex::Real(0.));
535 
536  static int num_mirrors;
537  amrex::Vector<amrex::Real> mirror_z;
538  amrex::Vector<amrex::Real> mirror_z_width;
539  amrex::Vector<int> mirror_z_npoints;
540 
542  std::unique_ptr<MultiReducedDiags> reduced_diags;
543 
544  void applyMirrors(amrex::Real time);
545 
547  void ComputeDt ();
548 
550  void PrintMainPICparameters ();
551 
553  void WriteUsedInputsFile () const;
554 
556  void PrintDtDxDyDz ();
557 
563  void ComputeMaxStep ();
564  // Compute max_step automatically for simulations in a boosted frame.
565  void computeMaxStepBoostAccelerator();
566 
571  int MoveWindow (int step, bool move_j);
572 
578  void ShiftGalileanBoundary ();
579 
584  void UpdateInjectionPosition (amrex::Real dt);
585 
586  void ResetProbDomain (const amrex::RealBox& rb);
587  void EvolveE ( amrex::Real dt);
588  void EvolveE (int lev, amrex::Real dt);
589  void EvolveB ( amrex::Real dt, DtType dt_type);
590  void EvolveB (int lev, amrex::Real dt, DtType dt_type);
591  void EvolveF ( amrex::Real dt, DtType dt_type);
592  void EvolveF (int lev, amrex::Real dt, DtType dt_type);
593  void EvolveG ( amrex::Real dt, DtType dt_type);
594  void EvolveG (int lev, amrex::Real dt, DtType dt_type);
595  void EvolveB (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
596  void EvolveE (int lev, PatchType patch_type, amrex::Real dt);
597  void EvolveF (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
598  void EvolveG (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
599 
600  void MacroscopicEvolveE ( amrex::Real dt);
601  void MacroscopicEvolveE (int lev, amrex::Real dt);
602  void MacroscopicEvolveE (int lev, PatchType patch_type, amrex::Real dt);
603 
609  void HybridPICEvolveFields ();
610 
618  void HybridPICDepositInitialRhoAndJ ();
619 
624  void Hybrid_QED_Push ( amrex::Vector<amrex::Real> dt);
625 
631  void Hybrid_QED_Push (int lev, amrex::Real dt);
632 
639  void Hybrid_QED_Push (int lev, PatchType patch_type, amrex::Real dt);
640 
641  static amrex::Real quantum_xi_c2;
642 
645  void CheckLoadBalance (int step);
646 
649  void LoadBalance ();
650 
653  void ResetCosts ();
654 
661  void RescaleCosts (int step);
662 
665  [[nodiscard]] utils::parser::IntervalsParser get_load_balance_intervals () const
666  {
667  return load_balance_intervals;
668  }
669 
677  void DampFieldsInGuards (int lev,
678  const std::array<std::unique_ptr<amrex::MultiFab>,3>& Efield,
679  const std::array<std::unique_ptr<amrex::MultiFab>,3>& Bfield);
680 
688  void DampFieldsInGuards (int lev, std::unique_ptr<amrex::MultiFab>& mf);
689 
690 #ifdef WARPX_DIM_RZ
691  void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab* Jx,
692  amrex::MultiFab* Jy,
693  amrex::MultiFab* Jz,
694  int lev);
695 
696  void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab* Rho,
697  int lev);
698 #endif
699 
705  void ApplyRhofieldBoundary (int lev, amrex::MultiFab* Rho,
706  PatchType patch_type);
707 
713  void ApplyJfieldBoundary (int lev, amrex::MultiFab* Jx,
714  amrex::MultiFab* Jy, amrex::MultiFab* Jz,
715  PatchType patch_type);
716 
717  void ApplyEfieldBoundary (int lev, PatchType patch_type);
718  void ApplyBfieldBoundary (int lev, PatchType patch_type, DtType dt_type);
719 
720 #ifdef WARPX_DIM_RZ
721  // Applies the boundary conditions that are specific to the axis when in RZ.
722  void ApplyFieldBoundaryOnAxis (amrex::MultiFab* Er, amrex::MultiFab* Et, amrex::MultiFab* Ez, int lev) const;
723 #endif
724 
733  void ApplyElectronPressureBoundary (int lev, PatchType patch_type);
734 
735  void DampPML ();
736  void DampPML (int lev);
737  void DampPML (int lev, PatchType patch_type);
738  void DampPML_Cartesian (int lev, PatchType patch_type);
739 
740  void DampJPML ();
741  void DampJPML (int lev);
742  void DampJPML (int lev, PatchType patch_type);
743 
744  void CopyJPML ();
745  bool isAnyBoundaryPML();
747  static bool isAnyParticleBoundaryThermal();
748 
749  PML* GetPML (int lev);
750 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
751  PML_RZ* GetPML_RZ (int lev);
752 #endif
753 
755  void doFieldIonization ();
759  void doFieldIonization (int lev);
760 
761 #ifdef WARPX_QED
763  void doQEDEvents ();
767  void doQEDEvents (int lev);
768 #endif
769 
770  void PushParticlesandDeposit (int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false,
771  PushType push_type=PushType::Explicit);
772  void PushParticlesandDeposit (amrex::Real cur_time, bool skip_current=false,
773  PushType push_type=PushType::Explicit);
774 
775  // This function does aux(lev) = fp(lev) + I(aux(lev-1)-cp(lev)).
776  // Caller must make sure fp and cp have ghost cells filled.
777  void UpdateAuxilaryData ();
778  void UpdateAuxilaryDataStagToNodal ();
779  void UpdateAuxilaryDataSameType ();
780 
789  void UpdateCurrentNodalToStag (amrex::MultiFab& dst, amrex::MultiFab const& src);
790 
791  // Fill boundary cells including coarse/fine boundaries
792  void FillBoundaryB (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
793  void FillBoundaryE (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
794  void FillBoundaryB_avg (amrex::IntVect ng);
795  void FillBoundaryE_avg (amrex::IntVect ng);
796 
797  void FillBoundaryF (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
798  void FillBoundaryG (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
799  void FillBoundaryAux (amrex::IntVect ng);
800  void FillBoundaryE (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
801  void FillBoundaryB (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
802  void FillBoundaryE_avg (int lev, amrex::IntVect ng);
803  void FillBoundaryB_avg (int lev, amrex::IntVect ng);
804 
805  void FillBoundaryF (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
806  void FillBoundaryG (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
807  void FillBoundaryAux (int lev, amrex::IntVect ng);
808 
815  void SyncCurrentAndRho ();
816 
829  void SyncCurrent (
830  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
831  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
832  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_buffer);
833 
834  void SyncRho ();
835 
836  void SyncRho (
837  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
838  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
839  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_buffer);
840 
841  [[nodiscard]] amrex::Vector<int> getnsubsteps () const {return nsubsteps;}
842  [[nodiscard]] int getnsubsteps (int lev) const {return nsubsteps[lev];}
843  [[nodiscard]] amrex::Vector<int> getistep () const {return istep;}
844  [[nodiscard]] int getistep (int lev) const {return istep[lev];}
845  void setistep (int lev, int ii) {istep[lev] = ii;}
846  [[nodiscard]] amrex::Vector<amrex::Real> gett_old () const {return t_old;}
847  [[nodiscard]] amrex::Real gett_old (int lev) const {return t_old[lev];}
848  [[nodiscard]] amrex::Vector<amrex::Real> gett_new () const {return t_new;}
849  [[nodiscard]] amrex::Real gett_new (int lev) const {return t_new[lev];}
850  void sett_new (int lev, amrex::Real time) {t_new[lev] = time;}
851  [[nodiscard]] amrex::Vector<amrex::Real> getdt () const {return dt;}
852  [[nodiscard]] amrex::Real getdt (int lev) const {return dt.at(lev);}
853  [[nodiscard]] int getdo_moving_window() const {return do_moving_window;}
854  [[nodiscard]] amrex::Real getmoving_window_x() const {return moving_window_x;}
855  [[nodiscard]] bool getis_synchronized() const {return is_synchronized;}
856 
857  [[nodiscard]] int maxStep () const {return max_step;}
858  void updateMaxStep (const int new_max_step) {max_step = new_max_step;}
859  [[nodiscard]] amrex::Real stopTime () const {return stop_time;}
860  void updateStopTime (const amrex::Real new_stop_time) {stop_time = new_stop_time;}
861 
862  void AverageAndPackFields( amrex::Vector<std::string>& varnames,
863  amrex::Vector<amrex::MultiFab>& mf_avg, amrex::IntVect ngrow) const;
864 
865  void prepareFields( int step, amrex::Vector<std::string>& varnames,
866  amrex::Vector<amrex::MultiFab>& mf_avg,
867  amrex::Vector<const amrex::MultiFab*>& output_mf,
868  amrex::Vector<amrex::Geometry>& output_geom ) const;
869 
870  static std::array<amrex::Real,3> CellSize (int lev);
871  static amrex::RealBox getRealBox(const amrex::Box& bx, int lev);
872 
881  static std::array<amrex::Real,3> LowerCorner (const amrex::Box& bx, int lev, amrex::Real time_shift_delta);
890  static std::array<amrex::Real,3> UpperCorner (const amrex::Box& bx, int lev, amrex::Real time_shift_delta);
891 
892  static amrex::IntVect RefRatio (int lev);
893 
894  static const amrex::iMultiFab* CurrentBufferMasks (int lev);
895  static const amrex::iMultiFab* GatherBufferMasks (int lev);
896 
897  static int electrostatic_solver_id;
898  static int poisson_solver_id;
899 
900  // Parameters for lab frame electrostatic
901  static amrex::Real self_fields_required_precision;
902  static amrex::Real self_fields_absolute_tolerance;
903  static int self_fields_max_iters;
904  static int self_fields_verbosity;
905 
906  static int do_moving_window; // boolean
907  static int start_moving_window_step; // the first step to move window
908  static int end_moving_window_step; // the last step to move window
914  static int moving_window_active (int const step) {
915  bool const step_before_end = (step < end_moving_window_step) || (end_moving_window_step < 0);
916  bool const step_after_start = (step >= start_moving_window_step);
917  return do_moving_window && step_before_end && step_after_start;
918  }
919  static int moving_window_dir;
920  static amrex::Real moving_window_v;
921  static bool fft_do_time_averaging;
922 
923  // these should be private, but can't due to Cuda limitations
924  static void ComputeDivB (amrex::MultiFab& divB, int dcomp,
925  const std::array<const amrex::MultiFab* const, 3>& B,
926  const std::array<amrex::Real,3>& dx);
927 
928  static void ComputeDivB (amrex::MultiFab& divB, int dcomp,
929  const std::array<const amrex::MultiFab* const, 3>& B,
930  const std::array<amrex::Real,3>& dx, amrex::IntVect ngrow);
931 
932  void ComputeDivE(amrex::MultiFab& divE, int lev);
933 
934  [[nodiscard]] amrex::IntVect getngEB() const { return guard_cells.ng_alloc_EB; }
935  [[nodiscard]] amrex::IntVect getngF() const { return guard_cells.ng_alloc_F; }
936  [[nodiscard]] amrex::IntVect getngUpdateAux() const { return guard_cells.ng_UpdateAux; }
937  [[nodiscard]] amrex::IntVect get_ng_depos_J() const {return guard_cells.ng_depos_J;}
938  [[nodiscard]] amrex::IntVect get_ng_depos_rho() const {return guard_cells.ng_depos_rho;}
939  [[nodiscard]] amrex::IntVect get_ng_fieldgather () const {return guard_cells.ng_FieldGather;}
940 
948  [[nodiscard]] amrex::IntVect get_numprocs() const {return numprocs;}
949 
950  bool m_boundary_potential_specified = false;
951  ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler;
952  void ComputeSpaceChargeField (bool reset_fields);
953  void AddBoundaryField ();
954  void AddSpaceChargeField (WarpXParticleContainer& pc);
955  void AddSpaceChargeFieldLabFrame ();
956  void computePhi (const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& rho,
957  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
958  std::array<amrex::Real, 3> beta = {{0,0,0}},
959  amrex::Real required_precision=amrex::Real(1.e-11),
960  amrex::Real absolute_tolerance=amrex::Real(0.0),
961  int max_iters=200,
962  int verbosity=2) const;
963 
964  void setPhiBC (amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi ) const;
965 
966  void computeE (amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3> >& E,
967  const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
968  std::array<amrex::Real, 3> beta = {{0,0,0}} ) const;
969  void computeB (amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3> >& B,
970  const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
971  std::array<amrex::Real, 3> beta = {{0,0,0}} ) const;
972  void computePhiTriDiagonal (const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& rho,
973  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi) const;
974 
975  // Magnetostatic Solver Interface
976  MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler;
977  void ComputeMagnetostaticField ();
978  void AddMagnetostaticFieldLabFrame ();
979  void computeVectorPotential (const amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& curr,
980  amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& A,
981  amrex::Real required_precision=amrex::Real(1.e-11),
982  amrex::Real absolute_tolerance=amrex::Real(0.0),
983  int max_iters=200,
984  int verbosity=2) const;
985 
986  void setVectorPotentialBC (amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& A) const;
987 
1009  void InitializeExternalFieldsOnGridUsingParser (
1010  amrex::MultiFab *mfx, amrex::MultiFab *mfy, amrex::MultiFab *mfz,
1011  amrex::ParserExecutor<3> const& xfield_parser,
1012  amrex::ParserExecutor<3> const& yfield_parser,
1013  amrex::ParserExecutor<3> const& zfield_parser,
1014  std::array< std::unique_ptr<amrex::MultiFab>, 3 > const& edge_lengths,
1015  std::array< std::unique_ptr<amrex::MultiFab>, 3 > const& face_areas,
1016  char field,
1017  int lev, PatchType patch_type);
1018 
1023  void LoadExternalFieldsFromFile (int lev);
1024 
1029  void ReadExternalFieldFromFile (
1030  const std::string& read_fields_from_path, amrex::MultiFab* mf,
1031  const std::string& F_name, const std::string& F_component);
1032 
1041  void InitializeEBGridData(int lev);
1042 
1048  void ComputeCostsHeuristic (amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > >& costs);
1049 
1050  void ApplyFilterandSumBoundaryRho (int lev, int glev, amrex::MultiFab& rho, int icomp, int ncomp);
1051 
1060  static amrex::Vector<amrex::Real> getFornbergStencilCoefficients(int n_order, short a_grid_type);
1061 
1062  // Device vectors of stencil coefficients used for finite-order centering of fields
1063  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_x;
1064  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_y;
1065  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_z;
1066 
1067  // Device vectors of stencil coefficients used for finite-order centering of currents
1068  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_x;
1069  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_y;
1070  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_z;
1071 
1072  // This needs to be public for CUDA.
1074  void ErrorEst (int lev, amrex::TagBoxArray& tags, amrex::Real time, int /*ngrow*/) final;
1075 
1076  // Return the accelerator lattice instance defined at the given refinement level
1077  const AcceleratorLattice& get_accelerator_lattice (int lev) {return *(m_accelerator_lattice[lev]);}
1078 
1079  // for cuda
1080  void BuildBufferMasksInBox ( amrex::Box tbx, amrex::IArrayBox &buffer_mask,
1081  const amrex::IArrayBox &guard_mask, int ng );
1082 #ifdef AMREX_USE_EB
1083  amrex::EBFArrayBoxFactory const& fieldEBFactory (int lev) const noexcept {
1084  return static_cast<amrex::EBFArrayBoxFactory const&>(*m_field_factory[lev]);
1085  }
1086 #endif
1087 
1088  void InitEB ();
1089 
1090 #ifdef AMREX_USE_EB
1095  static void ComputeEdgeLengths (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,
1096  const amrex::EBFArrayBoxFactory& eb_fact);
1101  static void ComputeFaceAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,
1102  const amrex::EBFArrayBoxFactory& eb_fact);
1103 
1107  static void ScaleEdges (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,
1108  const std::array<amrex::Real,3>& cell_size);
1112  static void ScaleAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,
1113  const std::array<amrex::Real,3>& cell_size);
1122  void MarkCells();
1123 #endif
1124 
1128  void ComputeDistanceToEB ();
1132  amrex::Array1D<int, 0, 2> CountExtFaces();
1137  void ComputeFaceExtensions();
1141  void InitBorrowing();
1145  void ShrinkBorrowing();
1149  void ComputeOneWayExtensions();
1153  void ComputeEightWaysExtensions();
1162  void ApplyBCKCorrection(int idim);
1163 
1168  void PSATDSubtractCurrentPartialSumsAvg ();
1169 
1170 #ifdef WARPX_USE_PSATD
1171 
1172 # ifdef WARPX_DIM_RZ
1173  SpectralSolverRZ&
1174 # else
1175  SpectralSolver&
1176 # endif
1177  get_spectral_solver_fp (int lev) {return *spectral_solver_fp[lev];}
1178 #endif
1179 
1180  FiniteDifferenceSolver * get_pointer_fdtd_solver_fp (int lev) { return m_fdtd_solver_fp[lev].get(); }
1181 
1182 protected:
1183 
1209  void InitLevelData (int lev, amrex::Real time);
1210 
1213  void PostProcessBaseGrids (amrex::BoxArray& ba0) const final;
1214 
1218  void MakeNewLevelFromScratch (int lev, amrex::Real time, const amrex::BoxArray& new_grids,
1219  const amrex::DistributionMapping& new_dmap) final;
1220 
1224  void MakeNewLevelFromCoarse (int /*lev*/, amrex::Real /*time*/, const amrex::BoxArray& /*ba*/,
1225  const amrex::DistributionMapping& /*dm*/) final;
1226 
1230  void RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray& ba,
1231  const amrex::DistributionMapping& dm) final;
1232 
1234  void ClearLevel (int lev) final;
1235 
1236 private:
1237 
1244  WarpX ();
1245 
1250  static void MakeWarpX ();
1251 
1252  // Singleton is used when the code is run from python
1253  static WarpX* m_instance;
1254 
1256  void HandleSignals ();
1257 
1258  void FillBoundaryB (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1259  void FillBoundaryE (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1260  void FillBoundaryF (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1261  void FillBoundaryG (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1262 
1263  void FillBoundaryB_avg (int lev, PatchType patch_type, amrex::IntVect ng);
1264  void FillBoundaryE_avg (int lev, PatchType patch_type, amrex::IntVect ng);
1265 
1266  void AddExternalFields ();
1267 
1268  void OneStep_nosub (amrex::Real cur_time);
1269  void OneStep_sub1 (amrex::Real cur_time);
1270 
1271  void OneStep_ImplicitPicard(amrex::Real cur_time);
1272 
1276  void OneStep_multiJ (amrex::Real cur_time);
1277 
1278  void RestrictCurrentFromFineToCoarsePatch (
1279  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1280  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1281  int lev);
1282  void AddCurrentFromFineLevelandSumBoundary (
1283  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1284  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1285  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_buffer,
1286  int lev);
1287  void StoreCurrent (int lev);
1288  void RestoreCurrent (int lev);
1289  void ApplyFilterJ (
1290  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1291  int lev,
1292  int idim);
1293  void ApplyFilterJ (
1294  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1295  int lev);
1296  void SumBoundaryJ (
1297  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1298  int lev,
1299  int idim,
1300  const amrex::Periodicity& period);
1301  void SumBoundaryJ (
1302  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1303  int lev,
1304  const amrex::Periodicity& period);
1305  void NodalSyncJ (
1306  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1307  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1308  int lev,
1309  PatchType patch_type);
1310 
1311  void RestrictRhoFromFineToCoarsePatch (
1312  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1313  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1314  int lev);
1315  void ApplyFilterandSumBoundaryRho (
1316  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1317  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1318  int lev,
1319  PatchType patch_type,
1320  int icomp,
1321  int ncomp);
1322  void AddRhoFromFineLevelandSumBoundary (
1323  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1324  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1325  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_buffer,
1326  int lev,
1327  int icomp,
1328  int ncomp);
1329  void NodalSyncRho (
1330  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1331  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1332  int lev,
1333  PatchType patch_type,
1334  int icomp,
1335  int ncomp);
1336 
1337  void ReadParameters ();
1338 
1341  void BackwardCompatibility ();
1342 
1343  void InitFromScratch ();
1344 
1345  void AllocLevelData (int lev, const amrex::BoxArray& ba,
1346  const amrex::DistributionMapping& dm);
1347 
1348  [[nodiscard]] amrex::DistributionMapping
1349  GetRestartDMap (const std::string& chkfile, const amrex::BoxArray& ba, int lev) const;
1350 
1351  void InitFromCheckpoint ();
1352  void PostRestart ();
1353 
1354  void InitPML ();
1355  void ComputePMLFactors ();
1356 
1357  void InitFilter ();
1358 
1359  void InitDiagnostics ();
1360 
1361  void InitNCICorrector ();
1362 
1367  void CheckGuardCells();
1368 
1372  void CheckKnownIssues();
1373 
1375  void PerformanceHints ();
1376 
1377  void BuildBufferMasks ();
1378 
1379  [[nodiscard]] const amrex::iMultiFab* getCurrentBufferMasks (int lev) const {
1380  return current_buffer_masks[lev].get();
1381  }
1382 
1383  [[nodiscard]] const amrex::iMultiFab* getGatherBufferMasks (int lev) const
1384  {
1385  return gather_buffer_masks[lev].get();
1386  }
1387 
1397  void ReorderFornbergCoefficients (amrex::Vector<amrex::Real>& ordered_coeffs,
1398  amrex::Vector<amrex::Real>& unordered_coeffs,
1399  int order);
1412  void AllocateCenteringCoefficients (amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_x,
1413  amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_y,
1414  amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_z,
1415  int centering_nox,
1416  int centering_noy,
1417  int centering_noz,
1418  short a_grid_type);
1419 
1420  void AllocLevelMFs (int lev, const amrex::BoxArray& ba, const amrex::DistributionMapping& dm,
1421  const amrex::IntVect& ngEB, amrex::IntVect& ngJ,
1422  const amrex::IntVect& ngRho, const amrex::IntVect& ngF,
1423  const amrex::IntVect& ngG, bool aux_is_nodal);
1424 
1425 #ifdef WARPX_USE_PSATD
1426 # ifdef WARPX_DIM_RZ
1427  void AllocLevelSpectralSolverRZ (amrex::Vector<std::unique_ptr<SpectralSolverRZ>>& spectral_solver,
1428  int lev,
1429  const amrex::BoxArray& realspace_ba,
1430  const amrex::DistributionMapping& dm,
1431  const std::array<amrex::Real,3>& dx);
1432 # else
1433  void AllocLevelSpectralSolver (amrex::Vector<std::unique_ptr<SpectralSolver>>& spectral_solver,
1434  int lev,
1435  const amrex::BoxArray& realspace_ba,
1436  const amrex::DistributionMapping& dm,
1437  const std::array<amrex::Real,3>& dx,
1438  bool pml_flag=false);
1439 # endif
1440 #endif
1441 
1443  std::string m_authors;
1444 
1445  amrex::Vector<int> istep; // which step?
1446  amrex::Vector<int> nsubsteps; // how many substeps on each level?
1447 
1448  amrex::Vector<amrex::Real> t_new;
1449  amrex::Vector<amrex::Real> t_old;
1450  amrex::Vector<amrex::Real> dt;
1451 
1452  // Particle container
1453  std::unique_ptr<MultiParticleContainer> mypc;
1454  std::unique_ptr<MultiDiagnostics> multi_diags;
1455 
1456  // Fluid container
1457  bool do_fluid_species = false;
1458  std::unique_ptr<MultiFluidContainer> myfl;
1459 
1460  //
1461  // Fields: First array for level, second for direction
1462  //
1463 
1464  // Full solution
1465  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_aux;
1466  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_aux;
1467 
1468  // Fine patch
1469  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_fp;
1470  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_fp;
1471  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_fp;
1472  amrex::Vector< std::unique_ptr<amrex::MultiFab> > phi_fp;
1473  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_fp;
1474  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_fp_vay;
1475  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_fp;
1476  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_fp;
1477  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_fp;
1478  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_fp;
1479 
1480  // Implicit, fields at start of step and from the previous iteration
1481  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_n;
1482  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_n;
1483  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_save;
1484  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_save;
1485 
1486  // Memory buffers for computing magnetostatic fields
1487  // Vector Potential A and previous step. Time buffer needed for computing dA/dt to first order
1488  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_fp_nodal;
1489  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_grad_buf_e_stag;
1490  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_grad_buf_b_stag;
1491 
1492  // Same as Bfield_fp/Efield_fp for reading external field data
1493  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_fp_external;
1494  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_fp_external;
1495 
1497  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_edge_lengths;
1499  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_face_areas;
1500 
1507  amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > m_flag_info_face;
1514  amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > m_flag_ext_face;
1518  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_area_mod;
1522  amrex::Vector<std::array< std::unique_ptr<amrex::LayoutData<FaceInfoBox> >, 3 > > m_borrowing;
1523 
1531  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > ECTRhofield;
1535  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Venl;
1536 
1537  //EB level set
1538  amrex::Vector<std::unique_ptr<amrex::MultiFab> > m_distance_to_eb;
1539 
1540  // store fine patch
1541  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_store;
1542 
1543  // Nodal MultiFab for nodal current deposition if warpx.do_current_centering = 1
1544  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>> current_fp_nodal;
1545 
1546  // Coarse patch
1547  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_cp;
1548  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_cp;
1549  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_cp;
1550  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_cp;
1551  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_cp;
1552  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_cp;
1553  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_cp;
1554  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_cp;
1555 
1556  // Copy of the coarse aux
1557  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Efield_cax;
1558  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_cax;
1559  amrex::Vector<std::unique_ptr<amrex::iMultiFab> > current_buffer_masks;
1560  amrex::Vector<std::unique_ptr<amrex::iMultiFab> > gather_buffer_masks;
1561 
1562  // If charge/current deposition buffers are used
1563  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_buf;
1564  amrex::Vector<std::unique_ptr<amrex::MultiFab> > charge_buf;
1565 
1577  [[nodiscard]] amrex::MultiFab*
1578  getFieldPointerUnchecked (warpx::fields::FieldType field_type, int lev, int direction = 0) const;
1579 
1580  // PML
1581  int do_pml = 0;
1582  int do_silver_mueller = 0;
1583  int pml_ncell = 10;
1584  int pml_delta = 10;
1585  int pml_has_particles = 0;
1586  int do_pml_j_damping = 0;
1587  int do_pml_in_domain = 0;
1588  bool do_similar_dm_pml = true;
1589  bool do_pml_dive_cleaning; // default set in WarpX.cpp
1590  bool do_pml_divb_cleaning; // default set in WarpX.cpp
1591  amrex::Vector<amrex::IntVect> do_pml_Lo;
1592  amrex::Vector<amrex::IntVect> do_pml_Hi;
1593  amrex::Vector<std::unique_ptr<PML> > pml;
1594 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
1595  amrex::Vector<std::unique_ptr<PML_RZ> > pml_rz;
1596 #endif
1597  amrex::Real v_particle_pml;
1598 
1599  // External fields parameters
1600  std::unique_ptr<ExternalFieldParams> m_p_ext_field_params;
1601 
1602  amrex::Real moving_window_x = std::numeric_limits<amrex::Real>::max();
1603 
1604  // Plasma injection parameters
1605  int warpx_do_continuous_injection = 0;
1606  int num_injected_species = -1;
1607  amrex::Vector<int> injected_plasma_species;
1608 
1609  std::optional<amrex::Real> m_const_dt;
1610 
1611  // Macroscopic properties
1612  std::unique_ptr<MacroscopicProperties> m_macroscopic_properties;
1613 
1614  // Hybrid PIC algorithm parameters
1615  std::unique_ptr<HybridPICModel> m_hybrid_pic_model;
1616 
1617  // Load balancing
1620  utils::parser::IntervalsParser load_balance_intervals;
1623  amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > > costs;
1625  int load_balance_with_sfc = 0;
1630  amrex::Real load_balance_knapsack_factor = amrex::Real(1.24);
1636  amrex::Real load_balance_efficiency_ratio_threshold = amrex::Real(1.1);
1638  amrex::Vector<amrex::Real> load_balance_efficiency;
1644  amrex::Real costs_heuristic_cells_wt = amrex::Real(0);
1650  amrex::Real costs_heuristic_particles_wt = amrex::Real(0);
1651 
1652  // Determines timesteps for override sync
1653  utils::parser::IntervalsParser override_sync_intervals;
1654 
1655  // Other runtime parameters
1656  int verbose = 1;
1657 
1658  bool use_hybrid_QED = false;
1659 
1660  int max_step = std::numeric_limits<int>::max();
1661  amrex::Real stop_time = std::numeric_limits<amrex::Real>::max();
1662 
1663  int regrid_int = -1;
1664 
1665  amrex::Real cfl = amrex::Real(0.999);
1666 
1667  std::string restart_chkfile;
1668 
1670  bool write_diagnostics_on_restart = false;
1671 
1672  amrex::VisMF::Header::Version plotfile_headerversion = amrex::VisMF::Header::Version_v1;
1673  amrex::VisMF::Header::Version slice_plotfile_headerversion = amrex::VisMF::Header::Version_v1;
1674 
1675  bool use_single_read = true;
1676  bool use_single_write = true;
1677  int mffile_nstreams = 4;
1678  int field_io_nfiles = 1024;
1679  int particle_io_nfiles = 1024;
1680 
1681  amrex::RealVect fine_tag_lo;
1682  amrex::RealVect fine_tag_hi;
1684  std::unique_ptr<amrex::Parser> ref_patch_parser;
1685 
1686  bool is_synchronized = true;
1687 
1688  // Synchronization of nodal points
1689  static constexpr bool sync_nodal_points = true;
1690 
1691  guardCellManager guard_cells;
1692 
1693  //Slice Parameters
1694  int slice_max_grid_size;
1695  int slice_plot_int = -1;
1696  amrex::RealBox slice_realbox;
1697  amrex::IntVect slice_cr_ratio;
1698  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_slice;
1699  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_slice;
1700  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_slice;
1701  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_slice;
1702  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_slice;
1703  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_slice;
1704 
1705  bool fft_periodic_single_box = false;
1706  int nox_fft = 16;
1707  int noy_fft = 16;
1708  int noz_fft = 16;
1709 
1711  amrex::IntVect numprocs{0};
1712 
1714  std::unique_ptr<ParticleBoundaryBuffer> m_particle_boundary_buffer;
1715 
1716  // Accelerator lattice elements
1717  amrex::Vector< std::unique_ptr<AcceleratorLattice> > m_accelerator_lattice;
1718 
1719  //
1720  // Embedded Boundary
1721  //
1722 
1723  // Factory for field data
1724  amrex::Vector<std::unique_ptr<amrex::FabFactory<amrex::FArrayBox> > > m_field_factory;
1725 
1726  [[nodiscard]]
1727  amrex::FabFactory<amrex::FArrayBox> const& fieldFactory (int lev) const noexcept
1728  {
1729  return *m_field_factory[lev];
1730  }
1731 
1734  bool m_exit_loop_due_to_interrupt_signal = false;
1735 
1738  [[nodiscard]]
1739  bool checkStopSimulation (amrex::Real cur_time);
1740 
1746  void checkEarlyUnusedParams ();
1747 
1756  void HandleParticlesAtBoundaries (int step, amrex::Real cur_time, int num_moved);
1757 
1758  void ScrapeParticles ();
1759 
1765  void ExplicitFillBoundaryEBUpdateAux ();
1766 
1767  void PushPSATD ();
1768 
1769 #ifdef WARPX_USE_PSATD
1770 
1783  void PSATDForwardTransformEB (
1784  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_fp,
1785  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_fp,
1786  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_cp,
1787  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_cp);
1788 
1802  void PSATDBackwardTransformEB (
1803  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_fp,
1804  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_fp,
1805  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_cp,
1806  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_cp);
1807 
1820  void PSATDBackwardTransformEBavg (
1821  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_avg_fp,
1822  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_avg_fp,
1823  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_avg_cp,
1824  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_avg_cp);
1825 
1837  void PSATDForwardTransformJ (
1838  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1839  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1840  bool apply_kspace_filter=true);
1841 
1850  void PSATDBackwardTransformJ (
1851  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1852  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp);
1853 
1865  void PSATDForwardTransformRho (
1866  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1867  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1868  int icomp, int dcomp, bool apply_kspace_filter=true);
1869 
1873  void PSATDMoveRhoNewToRhoOld ();
1874 
1878  void PSATDMoveJNewToJOld ();
1879 
1883  void PSATDForwardTransformF ();
1884 
1888  void PSATDBackwardTransformF ();
1889 
1893  void PSATDForwardTransformG ();
1894 
1898  void PSATDBackwardTransformG ();
1899 
1903  void PSATDCurrentCorrection ();
1904 
1908  void PSATDVayDeposition ();
1909 
1913  void PSATDPushSpectralFields ();
1914 
1920  void PSATDScaleAverageFields (amrex::Real scale_factor);
1921 
1925  void PSATDEraseAverageFields ();
1926 
1927 # ifdef WARPX_DIM_RZ
1928  amrex::Vector<std::unique_ptr<SpectralSolverRZ>> spectral_solver_fp;
1929  amrex::Vector<std::unique_ptr<SpectralSolverRZ>> spectral_solver_cp;
1930 # else
1931  amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_fp;
1932  amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_cp;
1933 # endif
1934 
1935 #endif
1936 
1937  amrex::Vector<std::unique_ptr<FiniteDifferenceSolver>> m_fdtd_solver_fp;
1938  amrex::Vector<std::unique_ptr<FiniteDifferenceSolver>> m_fdtd_solver_cp;
1939 };
1940 
1941 #endif
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
ExternalField_fwd.H
FiniteDifferenceSolver_fwd.H
HybridPICModel_fwd.H
MacroscopicProperties_fwd.H
MultiDiagnostics_fwd.H
MultiFluidContainer_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: WarpXAlgorithmSelection.H:59
DtType
DtType
Definition: WarpXDtType.H:11
WarpXFaceInfoBox_fwd.H
WarpXFluidContainer_fwd.H
WarpXParticleContainer_fwd.H
PushType
PushType
Definition: WarpXPushType.H:12
AcceleratorLattice
Definition: AcceleratorLattice.H:21
BilinearFilter
Definition: BilinearFilter.H:17
ElectrostaticSolver::PoissonBoundaryHandler
Definition: ElectrostaticSolver.H:41
FiniteDifferenceSolver
Top-level class for the electromagnetic finite-difference solver.
Definition: FiniteDifferenceSolver.H:35
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:34
MagnetostaticSolver::VectorPoissonBoundaryHandler
Definition: MagnetostaticSolver.H:21
MultiDiagnostics
This class contains a vector of all diagnostics in the simulation.
Definition: MultiDiagnostics.H:21
MultiFluidContainer
Definition: MultiFluidContainer.H:33
MultiParticleContainer
Definition: MultiParticleContainer.H:66
PML_RZ
Definition: PML_RZ.H:31
PML
Definition: PML.H:137
ParticleBoundaryBuffer
Definition: ParticleBoundaryBuffer.H:22
SpectralSolver
Top-level class for the electromagnetic spectral solver.
Definition: SpectralSolver.H:33
SpectralSolverRZ
Definition: SpectralSolverRZ.H:22
WarpX
Definition: WarpX.H:81
WarpX::m_particle_boundary_buffer
std::unique_ptr< ParticleBoundaryBuffer > m_particle_boundary_buffer
particle buffer for scraped particles on the boundaries
Definition: WarpX.H:1714
WarpX::self_fields_max_iters
static int self_fields_max_iters
Definition: WarpX.H:903
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:259
WarpX::costs
amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > > costs
Definition: WarpX.H:1623
WarpX::current_deposition_algo
static short current_deposition_algo
Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay,...
Definition: WarpX.H:153
WarpX::maxlevel_extEMfield_init
int maxlevel_extEMfield_init
Definition: WarpX.H:149
WarpX::G_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_fp
Definition: WarpX.H:1470
WarpX::device_field_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_y
Definition: WarpX.H:1064
WarpX::moving_window_dir
static int moving_window_dir
Definition: WarpX.H:919
WarpX::device_current_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_x
Definition: WarpX.H:1068
WarpX::InitFilter
void InitFilter()
WarpX::do_dive_cleaning
static bool do_dive_cleaning
Definition: WarpX.H:247
WarpX::zmax_plasma_to_compute_max_step
static amrex::Real zmax_plasma_to_compute_max_step
Definition: WarpX.H:317
WarpX::DoFluidSpecies
bool DoFluidSpecies() const
Definition: WarpX.H:510
WarpX::getnsubsteps
amrex::Vector< int > getnsubsteps() const
Definition: WarpX.H:841
WarpX::do_multi_J
static bool do_multi_J
Definition: WarpX.H:341
WarpX::m_macroscopic_properties
std::unique_ptr< MacroscopicProperties > m_macroscopic_properties
Definition: WarpX.H:1612
WarpX::GetMultiDiags
MultiDiagnostics & GetMultiDiags()
Definition: WarpX.H:127
WarpX::DoPML
bool DoPML() const
Definition: WarpX.H:509
WarpX::rho_in_time
static short rho_in_time
Definition: WarpX.H:209
WarpX::m_field_factory
amrex::Vector< std::unique_ptr< amrex::FabFactory< amrex::FArrayBox > > > m_field_factory
Definition: WarpX.H:1724
WarpX::getis_synchronized
bool getis_synchronized() const
Definition: WarpX.H:855
WarpX::current_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_cp
Definition: WarpX.H:1550
WarpX::m_distance_to_eb
amrex::Vector< std::unique_ptr< amrex::MultiFab > > m_distance_to_eb
Definition: WarpX.H:1538
WarpX::Efield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_slice
Definition: WarpX.H:1702
WarpX::GetFluidContainer
MultiFluidContainer & GetFluidContainer()
Definition: WarpX.H:123
WarpX::psatd_solution_type
static short psatd_solution_type
Definition: WarpX.H:204
WarpX::gather_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > gather_buffer_masks
Definition: WarpX.H:1560
WarpX::updateStopTime
void updateStopTime(const amrex::Real new_stop_time)
Definition: WarpX.H:860
WarpX::mirror_z_npoints
amrex::Vector< int > mirror_z_npoints
Definition: WarpX.H:539
WarpX::zmin_domain_boost_step_0
static amrex::Real zmin_domain_boost_step_0
Definition: WarpX.H:324
WarpX::current_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_slice
Definition: WarpX.H:1701
WarpX::do_compute_max_step_from_zmax
static bool do_compute_max_step_from_zmax
Definition: WarpX.H:321
WarpX::evolve_scheme
static short evolve_scheme
Integer that corresponds to the evolve scheme (explicit, implicit_picard, semi_implicit_picard)
Definition: WarpX.H:163
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:336
WarpX::get_spectral_solver_fp
SpectralSolverRZ & get_spectral_solver_fp(int lev)
Definition: WarpX.H:1177
WarpX::n_field_gather_buffer
static int n_field_gather_buffer
Definition: WarpX.H:350
WarpX::do_multi_J_n_depositions
static int do_multi_J_n_depositions
Definition: WarpX.H:342
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, char field, int lev, PatchType patch_type)
This function initializes the E and B fields on each level using the parser and the user-defined func...
WarpX::current_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_nodal
Definition: WarpX.H:1544
WarpX::t_new
amrex::Vector< amrex::Real > t_new
Definition: WarpX.H:1448
WarpX::do_single_precision_comms
static bool do_single_precision_comms
perform field communications in single precision
Definition: WarpX.H:225
WarpX::slice_cr_ratio
amrex::IntVect slice_cr_ratio
Definition: WarpX.H:1697
WarpX::particle_boundary_lo
static amrex::Vector< ParticleBoundaryType > particle_boundary_lo
Definition: WarpX.H:194
WarpX::current_store
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_store
Definition: WarpX.H:1541
WarpX::CheckKnownIssues
void CheckKnownIssues()
Checks for known numerical issues involving different WarpX modules.
WarpX::guard_cells
guardCellManager guard_cells
Definition: WarpX.H:1691
WarpX::do_shared_mem_charge_deposition
static bool do_shared_mem_charge_deposition
used shared memory algorithm for charge deposition
Definition: WarpX.H:228
WarpX::em_solver_medium
static int em_solver_medium
Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1)
Definition: WarpX.H:175
WarpX::GetPartContainer
MultiParticleContainer & GetPartContainer()
Definition: WarpX.H:122
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:313
WarpX::use_fdtd_nci_corr
static bool use_fdtd_nci_corr
Definition: WarpX.H:282
WarpX::verboncoeur_axis_correction
static bool verboncoeur_axis_correction
Definition: WarpX.H:296
WarpX::AverageAndPackFields
void AverageAndPackFields(amrex::Vector< std::string > &varnames, amrex::Vector< amrex::MultiFab > &mf_avg, amrex::IntVect ngrow) const
WarpX::moving_window_v
static amrex::Real moving_window_v
Definition: WarpX.H:920
WarpX::do_shared_mem_current_deposition
static bool do_shared_mem_current_deposition
use shared memory algorithm for current deposition
Definition: WarpX.H:231
WarpX::do_pml_Hi
amrex::Vector< amrex::IntVect > do_pml_Hi
Definition: WarpX.H:1592
WarpX::GetAuthors
std::string GetAuthors() const
If an authors' string is specified in the inputfile, this method returns that string....
Definition: WarpX.H:143
WarpX::setistep
void setistep(int lev, int ii)
Definition: WarpX.H:845
WarpX::fft_do_time_averaging
static bool fft_do_time_averaging
Definition: WarpX.H:921
WarpX::particle_pusher_algo
static short particle_pusher_algo
Integer that corresponds to the particle push algorithm (Boris, Vay, Higuera-Cary)
Definition: WarpX.H:159
WarpX::pml
amrex::Vector< std::unique_ptr< PML > > pml
Definition: WarpX.H:1593
WarpX::fine_tag_lo
amrex::RealVect fine_tag_lo
Definition: WarpX.H:1681
WarpX::restart_chkfile
std::string restart_chkfile
Definition: WarpX.H:1667
WarpX::m_instance
static WarpX * m_instance
Definition: WarpX.H:1253
WarpX::rho_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_cp
Definition: WarpX.H:1549
WarpX::do_dynamic_scheduling
static bool do_dynamic_scheduling
Definition: WarpX.H:329
WarpX::PostRestart
void PostRestart()
WarpX::ref_patch_parser
std::unique_ptr< amrex::Parser > ref_patch_parser
User-defined parser to define refinement patches.
Definition: WarpX.H:1684
WarpX::device_field_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_z
Definition: WarpX.H:1065
WarpX::self_fields_verbosity
static int self_fields_verbosity
Definition: WarpX.H:904
WarpX::stopTime
amrex::Real stopTime() const
Definition: WarpX.H:859
WarpX::pml_rz
amrex::Vector< std::unique_ptr< PML_RZ > > pml_rz
Definition: WarpX.H:1595
WarpX::InitData
void InitData()
WarpX::multifab_map
static std::map< std::string, amrex::MultiFab * > multifab_map
Definition: WarpX.H:455
WarpX::myfl
std::unique_ptr< MultiFluidContainer > myfl
Definition: WarpX.H:1458
WarpX::device_field_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_x
Definition: WarpX.H:1063
WarpX::m_hybrid_pic_model
std::unique_ptr< HybridPICModel > m_hybrid_pic_model
Definition: WarpX.H:1615
WarpX::AddExternalFields
void AddExternalFields()
WarpX::getdt
amrex::Vector< amrex::Real > getdt() const
Definition: WarpX.H:851
WarpX::noz
static int noz
Order of the particle shape factors (splines) along z.
Definition: WarpX.H:256
WarpX::device_current_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_z
Definition: WarpX.H:1070
WarpX::gett_new
amrex::Vector< amrex::Real > gett_new() const
Definition: WarpX.H:848
WarpX::num_mirrors
static int num_mirrors
Definition: WarpX.H:536
WarpX::phi_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > phi_fp
Definition: WarpX.H:1472
WarpX::GetParticleBoundaryBuffer
ParticleBoundaryBuffer & GetParticleBoundaryBuffer()
Definition: WarpX.H:131
WarpX::WriteUsedInputsFile
void WriteUsedInputsFile() const
WarpX::Bfield_n
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_n
Definition: WarpX.H:1482
WarpX::do_pml_divb_cleaning
bool do_pml_divb_cleaning
Definition: WarpX.H:1590
WarpX::getistep
amrex::Vector< int > getistep() const
Definition: WarpX.H:843
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:268
WarpX::field_boundary_lo
static amrex::Vector< FieldBoundaryType > field_boundary_lo
Definition: WarpX.H:184
WarpX::device_current_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_y
Definition: WarpX.H:1069
WarpX::InitDiagnostics
void InitDiagnostics()
WarpX::Efield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_cp
Definition: WarpX.H:1553
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::load_balance_efficiency
amrex::Vector< amrex::Real > load_balance_efficiency
Definition: WarpX.H:1638
WarpX::self_fields_required_precision
static amrex::Real self_fields_required_precision
Definition: WarpX.H:901
WarpX::sort_bin_size
static amrex::IntVect sort_bin_size
Definition: WarpX.H:333
WarpX::WarpX
WarpX(WarpX &&)=default
WarpX::m_rho_nodal_flag
amrex::IntVect m_rho_nodal_flag
Definition: WarpX.H:361
WarpX::imultifab_map
static std::map< std::string, amrex::iMultiFab * > imultifab_map
Definition: WarpX.H:456
WarpX::load_balance_intervals
utils::parser::IntervalsParser load_balance_intervals
Definition: WarpX.H:1620
WarpX::m_flag_ext_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > > m_flag_ext_face
Definition: WarpX.H:1514
WarpX::current_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp
Definition: WarpX.H:1473
WarpX::getngEB
amrex::IntVect getngEB() const
Definition: WarpX.H:934
WarpX::override_sync_intervals
utils::parser::IntervalsParser override_sync_intervals
Definition: WarpX.H:1653
WarpX::get_load_balance_intervals
utils::parser::IntervalsParser get_load_balance_intervals() const
returns the load balance interval
Definition: WarpX.H:665
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:1499
WarpX::gett_old
amrex::Real gett_old(int lev) const
Definition: WarpX.H:847
WarpX::Bfield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cax
Definition: WarpX.H:1558
WarpX::do_moving_window
static int do_moving_window
Definition: WarpX.H:906
WarpX::maxStep
int maxStep() const
Definition: WarpX.H:857
WarpX::nox
static int nox
Order of the particle shape factors (splines) along x.
Definition: WarpX.H:252
WarpX::getnsubsteps
int getnsubsteps(int lev) const
Definition: WarpX.H:842
WarpX::WarpX
WarpX(WarpX const &)=delete
WarpX::quantum_xi_c2
static amrex::Real quantum_xi_c2
Definition: WarpX.H:641
WarpX::InitFromScratch
void InitFromScratch()
WarpX::Bfield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_slice
Definition: WarpX.H:1703
WarpX::m_flag_info_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > > m_flag_info_face
Definition: WarpX.H:1507
WarpX::current_fp_vay
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_vay
Definition: WarpX.H:1474
WarpX::updateMaxStep
void updateMaxStep(const int new_max_step)
Definition: WarpX.H:858
WarpX::GetHybridPICModel
HybridPICModel & GetHybridPICModel()
Definition: WarpX.H:125
WarpX::Bfield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cp
Definition: WarpX.H:1552
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:306
WarpX::getGatherBufferMasks
const amrex::iMultiFab * getGatherBufferMasks(int lev) const
Definition: WarpX.H:1383
WarpX::spectral_solver_fp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_fp
Definition: WarpX.H:1928
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:240
WarpX::grid_type
static short grid_type
Definition: WarpX.H:358
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:1490
WarpX::Efield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_aux
Definition: WarpX.H:1465
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:266
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:303
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:1489
WarpX::m_borrowing
amrex::Vector< std::array< std::unique_ptr< amrex::LayoutData< FaceInfoBox > >, 3 > > m_borrowing
Definition: WarpX.H:1522
WarpX::charge_deposition_algo
static short charge_deposition_algo
Integer that corresponds to the charge deposition algorithm (only standard deposition)
Definition: WarpX.H:155
WarpX::gett_new
amrex::Real gett_new(int lev) const
Definition: WarpX.H:849
WarpX::dt
amrex::Vector< amrex::Real > dt
Definition: WarpX.H:1450
WarpX::rho_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_slice
Definition: WarpX.H:1700
WarpX::F_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_cp
Definition: WarpX.H:1547
WarpX::fine_tag_hi
amrex::RealVect fine_tag_hi
Definition: WarpX.H:1682
WarpX::get_ng_fieldgather
amrex::IntVect get_ng_fieldgather() const
Definition: WarpX.H:939
WarpX::get_ng_depos_rho
amrex::IntVect get_ng_depos_rho() const
Definition: WarpX.H:938
WarpX::poisson_solver_id
static int poisson_solver_id
Definition: WarpX.H:898
WarpX::start_moving_window_step
static int start_moving_window_step
Definition: WarpX.H:907
WarpX::istep
amrex::Vector< int > istep
Definition: WarpX.H:1445
WarpX::electrostatic_solver_id
static int electrostatic_solver_id
Definition: WarpX.H:897
WarpX::PrintMainPICparameters
void PrintMainPICparameters()
WarpX::prepareFields
void prepareFields(int step, amrex::Vector< std::string > &varnames, amrex::Vector< amrex::MultiFab > &mf_avg, amrex::Vector< const amrex::MultiFab * > &output_mf, amrex::Vector< amrex::Geometry > &output_geom) const
WarpX::get_accelerator_lattice
const AcceleratorLattice & get_accelerator_lattice(int lev)
Definition: WarpX.H:1077
WarpX::G_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_slice
Definition: WarpX.H:1699
WarpX::n_current_deposition_buffer
static int n_current_deposition_buffer
Definition: WarpX.H:354
WarpX::F_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_fp
Definition: WarpX.H:1469
WarpX::Verbose
int Verbose() const
Definition: WarpX.H:110
WarpX::Efield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cax
Definition: WarpX.H:1557
WarpX::charge_buf
amrex::Vector< std::unique_ptr< amrex::MultiFab > > charge_buf
Definition: WarpX.H:1564
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:1497
WarpX::getCurrentBufferMasks
const amrex::iMultiFab * getCurrentBufferMasks(int lev) const
Definition: WarpX.H:1379
WarpX::Efield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_fp
Definition: WarpX.H:1477
WarpX::injected_plasma_species
amrex::Vector< int > injected_plasma_species
Definition: WarpX.H:1607
WarpX::do_device_synchronize
static bool do_device_synchronize
Definition: WarpX.H:344
WarpX::max_picard_iterations
static int max_picard_iterations
The maximum number of Picard iterations to do each time step.
Definition: WarpX.H:165
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:301
WarpX::InitNCICorrector
void InitNCICorrector()
WarpX::getistep
int getistep(int lev) const
Definition: WarpX.H:844
WarpX::multi_diags
std::unique_ptr< MultiDiagnostics > multi_diags
Definition: WarpX.H:1454
WarpX::noy
static int noy
Order of the particle shape factors (splines) along y.
Definition: WarpX.H:254
WarpX::nsubsteps
amrex::Vector< int > nsubsteps
Definition: WarpX.H:1446
WarpX::ComputeMaxStep
void ComputeMaxStep()
Compute the last time step of the simulation Calls computeMaxStepBoostAccelerator() if required.
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:263
WarpX::sett_new
void sett_new(int lev, amrex::Real time)
Definition: WarpX.H:850
WarpX::picard_iteration_tolerance
static amrex::Real picard_iteration_tolerance
The tolerance for the Picard iteration convergence.
Definition: WarpX.H:167
WarpX::getngF
amrex::IntVect getngF() const
Definition: WarpX.H:935
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:311
WarpX::Efield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp_external
Definition: WarpX.H:1493
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::ReadExternalFieldFromFile
void ReadExternalFieldFromFile(const std::string &read_fields_from_path, amrex::MultiFab *mf, const std::string &F_name, const std::string &F_component)
Load field values from a user-specified openPMD file for a specific field (specified by F_name)
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:249
WarpX::mypc
std::unique_ptr< MultiParticleContainer > mypc
Definition: WarpX.H:1453
WarpX::current_buf
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_buf
Definition: WarpX.H:1563
WarpX::use_filter
static bool use_filter
If true, a bilinear filter is used to smooth charge and currents.
Definition: WarpX.H:299
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:243
WarpX::LoadExternalFieldsFromFile
void LoadExternalFieldsFromFile(int lev)
Load field values from a user-specified openPMD file, for the fields Ex, Ey, Ez, Bx,...
WarpX::GetMacroscopicProperties
MacroscopicProperties & GetMacroscopicProperties()
Definition: WarpX.H:124
WarpX::m_vector_poisson_boundary_handler
MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler
Definition: WarpX.H:976
WarpX::vector_potential_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > vector_potential_fp_nodal
Definition: WarpX.H:1488
WarpX::m_poisson_boundary_handler
ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler
Definition: WarpX.H:951
WarpX::shared_tilesize
static amrex::IntVect shared_tilesize
tileSize to use for shared current deposition operations
Definition: WarpX.H:237
WarpX::m_fdtd_solver_fp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_fp
Definition: WarpX.H:1937
WarpX::gett_old
amrex::Vector< amrex::Real > gett_old() const
Definition: WarpX.H:846
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:270
WarpX::safe_guard_cells
static bool safe_guard_cells
Definition: WarpX.H:345
WarpX::getngUpdateAux
amrex::IntVect getngUpdateAux() const
Definition: WarpX.H:936
WarpX::Efield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cp
Definition: WarpX.H:1551
WarpX::rho_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_fp
Definition: WarpX.H:1471
WarpX::Efield_n
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_n
Definition: WarpX.H:1481
WarpX::field_boundary_hi
static amrex::Vector< FieldBoundaryType > field_boundary_hi
Definition: WarpX.H:189
WarpX::Bfield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp
Definition: WarpX.H:1476
WarpX::Efield_save
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_save
Definition: WarpX.H:1483
WarpX::ECTRhofield
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > ECTRhofield
Definition: WarpX.H:1531
WarpX::t_old
amrex::Vector< amrex::Real > t_old
Definition: WarpX.H:1449
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:338
WarpX::refine_plasma
static bool refine_plasma
Definition: WarpX.H:330
WarpX::fieldFactory
amrex::FabFactory< amrex::FArrayBox > const & fieldFactory(int lev) const noexcept
Definition: WarpX.H:1727
WarpX::macroscopic_solver_algo
static int macroscopic_solver_algo
Definition: WarpX.H:179
WarpX::Bfield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_aux
Definition: WarpX.H:1466
WarpX::ncomps
static int ncomps
Definition: WarpX.H:278
WarpX::moving_window_active
static int moving_window_active(int const step)
Definition: WarpX.H:914
WarpX::Bfield_save
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_save
Definition: WarpX.H:1484
WarpX::galerkin_interpolation
static bool galerkin_interpolation
Definition: WarpX.H:292
WarpX::nci_godfrey_filter_bxbyez
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > > nci_godfrey_filter_bxbyez
Definition: WarpX.H:528
WarpX::m_area_mod
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > m_area_mod
Definition: WarpX.H:1518
WarpX::filter_npass_each_dir
static amrex::IntVect filter_npass_each_dir
Definition: WarpX.H:525
WarpX::get_numprocs
amrex::IntVect get_numprocs() const
Definition: WarpX.H:948
WarpX::Venl
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Venl
Definition: WarpX.H:1535
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:161
WarpX::InitPML
void InitPML()
WarpX::v_particle_pml
amrex::Real v_particle_pml
Definition: WarpX.H:1597
WarpX::get_ng_depos_J
amrex::IntVect get_ng_depos_J() const
Definition: WarpX.H:937
WarpX::bilinear_filter
BilinearFilter bilinear_filter
Definition: WarpX.H:526
WarpX::Bfield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_fp
Definition: WarpX.H:1478
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:261
WarpX::getdt
amrex::Real getdt(int lev) const
Definition: WarpX.H:852
WarpX::Bfield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp_external
Definition: WarpX.H:1494
WarpX::get_pointer_HybridPICModel
HybridPICModel * get_pointer_HybridPICModel() const
Definition: WarpX.H:126
WarpX::nci_godfrey_filter_exeybz
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > > nci_godfrey_filter_exeybz
Definition: WarpX.H:527
WarpX::do_current_centering
static bool do_current_centering
Definition: WarpX.H:214
WarpX::mirror_z
amrex::Vector< amrex::Real > mirror_z
Definition: WarpX.H:537
WarpX::F_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_slice
Definition: WarpX.H:1698
WarpX::getdo_moving_window
int getdo_moving_window() const
Definition: WarpX.H:853
WarpX::do_subcycling
static bool do_subcycling
Definition: WarpX.H:340
WarpX::n_rz_azimuthal_modes
static int n_rz_azimuthal_modes
Number of modes for the RZ multi-mode version.
Definition: WarpX.H:273
WarpX::J_in_time
static short J_in_time
Definition: WarpX.H:208
WarpX::m_p_ext_field_params
std::unique_ptr< ExternalFieldParams > m_p_ext_field_params
Definition: WarpX.H:1600
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:309
WarpX::field_gathering_algo
static short field_gathering_algo
Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving)
Definition: WarpX.H:157
WarpX::Bfield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_cp
Definition: WarpX.H:1554
WarpX::shared_mem_current_tpb
static int shared_mem_current_tpb
number of threads to use per block in shared deposition
Definition: WarpX.H:234
WarpX::load_balance_costs_update_algo
static short load_balance_costs_update_algo
Definition: WarpX.H:173
WarpX::m_fdtd_solver_cp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_cp
Definition: WarpX.H:1938
WarpX::computeMaxStepBoostAccelerator
void computeMaxStepBoostAccelerator()
WarpX::mirror_z_width
amrex::Vector< amrex::Real > mirror_z_width
Definition: WarpX.H:538
WarpX::reduced_diags
std::unique_ptr< MultiReducedDiags > reduced_diags
object with all reduced diagnostics, similar to MultiParticleContainer for species.
Definition: WarpX.H:542
WarpX::PerformanceHints
void PerformanceHints()
WarpX::current_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > current_buffer_masks
Definition: WarpX.H:1559
WarpX::m_authors
std::string m_authors
Author of an input file / simulation setup.
Definition: WarpX.H:1443
WarpX::ScrapeParticles
void ScrapeParticles()
WarpX::slice_max_grid_size
int slice_max_grid_size
Definition: WarpX.H:1694
WarpX::G_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_cp
Definition: WarpX.H:1548
WarpX::require_picard_convergence
static bool require_picard_convergence
Flags whether the Picard iterations are required to converge.
Definition: WarpX.H:169
WarpX::self_fields_absolute_tolerance
static amrex::Real self_fields_absolute_tolerance
Definition: WarpX.H:902
WarpX::m_accelerator_lattice
amrex::Vector< std::unique_ptr< AcceleratorLattice > > m_accelerator_lattice
Definition: WarpX.H:1717
WarpX::particle_boundary_hi
static amrex::Vector< ParticleBoundaryType > particle_boundary_hi
Definition: WarpX.H:199
WarpX::m_const_dt
std::optional< amrex::Real > m_const_dt
Definition: WarpX.H:1609
WarpX::get_pointer_fdtd_solver_fp
FiniteDifferenceSolver * get_pointer_fdtd_solver_fp(int lev)
Definition: WarpX.H:1180
WarpX::slice_realbox
amrex::RealBox slice_realbox
Definition: WarpX.H:1696
WarpX::do_pml_Lo
amrex::Vector< amrex::IntVect > do_pml_Lo
Definition: WarpX.H:1591
WarpX::spectral_solver_cp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_cp
Definition: WarpX.H:1929
WarpX::getmoving_window_x
amrex::Real getmoving_window_x() const
Definition: WarpX.H:854
WarpX::do_pml_dive_cleaning
bool do_pml_dive_cleaning
Definition: WarpX.H:1589
WarpX::getPMLRZ
const PML_RZ * getPMLRZ()
Definition: WarpX.H:513
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:327
WarpX::current_correction
bool current_correction
If true, a correction is applied to the current in Fourier space,.
Definition: WarpX.H:218
WarpX::ComputePMLFactors
void ComputePMLFactors()
WarpX::end_moving_window_step
static int end_moving_window_step
Definition: WarpX.H:908
WarpX::sort_intervals
static utils::parser::IntervalsParser sort_intervals
Definition: WarpX.H:332
WarpX::Efield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp
Definition: WarpX.H:1475
WarpXParticleContainer
Definition: WarpXParticleContainer.H:111
amrex::AmrCore::MakeNewLevelFromScratch
void MakeNewLevelFromScratch(int lev, Real time, const BoxArray &ba, const DistributionMapping &dm) override=0
amrex::AmrCore::ClearLevel
virtual void ClearLevel(int lev)=0
amrex::AmrCore::operator=
AmrCore & operator=(AmrCore &&rhs) noexcept
amrex::AmrCore::ErrorEst
void ErrorEst(int lev, TagBoxArray &tags, Real time, int ngrow) override=0
amrex::AmrCore::RemakeLevel
virtual void RemakeLevel(int lev, Real time, const BoxArray &ba, const DistributionMapping &dm)=0
amrex::AmrCore::MakeNewLevelFromCoarse
virtual void MakeNewLevelFromCoarse(int lev, Real time, const BoxArray &ba, const DistributionMapping &dm)=0
amrex::AmrMesh::PostProcessBaseGrids
virtual void PostProcessBaseGrids(BoxArray &) const
FabArray< IArrayBox >::get
const IArrayBox & get(const MFIter &mfi) const noexcept
guardCellManager
This class computes and stores the number of guard cells needed for the allocation of the MultiFabs a...
Definition: GuardCellManager.H:20
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
ablastr::fields::computeVectorPotential
void computeVectorPotential(amrex::Vector< amrex::Array< amrex::MultiFab *, 3 > > const &curr, amrex::Vector< amrex::Array< amrex::MultiFab *, 3 > > &A, amrex::Real const relative_tolerance, amrex::Real absolute_tolerance, int const max_iters, int const verbosity, amrex::Vector< amrex::Geometry > const &geom, amrex::Vector< amrex::DistributionMapping > const &dmap, amrex::Vector< amrex::BoxArray > const &grids, T_BoundaryHandler const boundary_handler, bool const do_single_precision_comms=false, std::optional< amrex::Vector< amrex::IntVect > > rel_ref_ratio=std::nullopt, [[maybe_unused]] T_PostACalculationFunctor post_A_calculation=std::nullopt, [[maybe_unused]] std::optional< amrex::Real const > current_time=std::nullopt, [[maybe_unused]] std::optional< amrex::Vector< T_FArrayBoxFactory const * > > eb_farray_box_factory=std::nullopt)
Definition: VectorPoissonSolver.H:86
ablastr::fields::computePhi
void computePhi(amrex::Vector< amrex::MultiFab * > const &rho, amrex::Vector< amrex::MultiFab * > &phi, std::array< amrex::Real, 3 > const beta, amrex::Real const relative_tolerance, amrex::Real absolute_tolerance, int const max_iters, int const verbosity, amrex::Vector< amrex::Geometry > const &geom, amrex::Vector< amrex::DistributionMapping > const &dmap, amrex::Vector< amrex::BoxArray > const &grids, T_BoundaryHandler const boundary_handler, [[maybe_unused]] bool is_solver_multigrid, bool const do_single_precision_comms=false, std::optional< amrex::Vector< amrex::IntVect > > rel_ref_ratio=std::nullopt, [[maybe_unused]] T_PostPhiCalculationFunctor post_phi_calculation=std::nullopt, [[maybe_unused]] std::optional< amrex::Real const > current_time=std::nullopt, [[maybe_unused]] std::optional< amrex::Vector< T_FArrayBoxFactory const * > > eb_farray_box_factory=std::nullopt)
Definition: PoissonSolver.H:98
verbose
int verbose
amrex::Finalize
void Finalize(AMReX *pamrex)
amrex::Version
std::string Version()
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
run_automated.name
name
Definition: run_automated.py:229
stencil.dt
float dt
Definition: stencil.py:442
stencil.dx
tuple dx
lab frame
Definition: stencil.py:429
stencil.beta
beta
Definition: stencil.py:434
stencil.cfl
float cfl
Definition: stencil.py:439
video_yt.field
string field
Definition: video_yt.py:31
warpx::fields::FieldType
FieldType
Definition: Fields.H:13
verbosity
int verbosity()
Generated by doxygen 1.9.1