ARTEMIS
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 "Filter/NCIGodfreyFilter_fwd.H"
22 #include "Particles/ParticleBoundaryBuffer_fwd.H"
23 #include "Particles/MultiParticleContainer_fwd.H"
24 #include "Particles/WarpXParticleContainer_fwd.H"
25 #ifdef WARPX_USE_PSATD
26 # ifdef WARPX_DIM_RZ
27 # include "FieldSolver/SpectralSolver/SpectralSolverRZ_fwd.H"
28 # include "BoundaryConditions/PML_RZ_fwd.H"
29 # else
30 # include "FieldSolver/SpectralSolver/SpectralSolver_fwd.H"
31 # endif
32 #endif
33 #include "Evolve/WarpXDtType.H"
34 #include "FieldSolver/ElectrostaticSolver.H"
35 #include "FieldSolver/MagnetostaticSolver/MagnetostaticSolver.H"
36 #include "Filter/BilinearFilter.H"
37 #include "Parallelization/GuardCellManager.H"
38 #include "AcceleratorLattice/AcceleratorLattice.H"
39 #include "Utils/Parser/IntervalsParser.H"
40 #include "Utils/WarpXAlgorithmSelection.H"
41 #include "FieldSolver/London/London.H"
42 #include "FieldSolver/LumpedElement/Inductor.H"
43 
44 #include <AMReX.H>
45 #include <AMReX_AmrCore.H>
46 #include <AMReX_Array.H>
47 #include <AMReX_Config.H>
48 #ifdef AMREX_USE_EB
49 # include <AMReX_EBFabFactory.H>
50 #endif
51 #include <AMReX_GpuContainers.H>
52 #include <AMReX_IntVect.H>
53 #include <AMReX_LayoutData.H>
54 #include <AMReX_Parser.H>
55 #include <AMReX_REAL.H>
56 #include <AMReX_RealBox.H>
57 #include <AMReX_RealVect.H>
58 #include <AMReX_Vector.H>
59 #include <AMReX_VisMF.H>
60 
61 #include <AMReX_BaseFwd.H>
62 #include <AMReX_AmrCoreFwd.H>
63 
64 #include <array>
65 #include <iostream>
66 #include <limits>
67 #include <memory>
68 #include <optional>
69 #include <string>
70 #include <vector>
71 #include <map>
72 
73 enum struct PatchType : int
74 {
75  fine,
76  coarse
77 };
78 
79 class WarpX
80  : public amrex::AmrCore
81 {
82 public:
83 
84  friend class PML;
85 
86  static WarpX& GetInstance ();
87  static void ResetInstance ();
88 
89  WarpX ();
90  ~WarpX ();
91 
92  static std::string Version ();
93  static std::string PicsarVersion ();
94 
95  int Verbose () const { return verbose; }
96 
97  void InitData ();
98 
99  void Evolve (int numsteps = -1);
100 
101  MultiParticleContainer& GetPartContainer () { return *mypc; }
102  MacroscopicProperties& GetMacroscopicProperties () { return *m_macroscopic_properties; }
103  London& getLondon () { return *m_london; }
104  Inductor& getInductor () { return *m_inductor; }
105  MultiDiagnostics& GetMultiDiags () {return *multi_diags;}
106 
107  ParticleBoundaryBuffer& GetParticleBoundaryBuffer () { return *m_particle_boundary_buffer; }
108 
109  static void shiftMF (amrex::MultiFab& mf, const amrex::Geometry& geom,
110  int num_shift, int dir, const int lev, bool update_cost_flag,
111  amrex::Real external_field=0.0, bool useparser = false,
112  amrex::ParserExecutor<3> const& field_parser={});
113 
114  static void GotoNextLine (std::istream& is);
115 
117  static std::string authors;
118 
120  static amrex::Vector<amrex::Real> E_external_grid;
122  static amrex::Vector<amrex::Real> B_external_grid;
123 
124 #ifdef WARPX_MAG_LLG
125  static amrex::Vector<amrex::Real> H_external_grid;
126  static amrex::Vector<amrex::Real> M_external_grid;
127  static amrex::Vector<amrex::Real> H_bias_external_grid;
128 #endif
129 
131  static std::string B_ext_grid_s;
133  static std::string E_ext_grid_s;
134 
135  // Initialization Type for External E and B excitation on grid
136  static std::string B_excitation_grid_s;
137  static std::string E_excitation_grid_s;
138 #ifdef WARPX_MAG_LLG
139  static std::string H_excitation_grid_s;
140  static std::string H_bias_excitation_grid_s;
141 #endif
142 
143 #ifdef WARPX_MAG_LLG
144  static std::string H_ext_grid_s; // added for H;
145  static std::string M_ext_grid_s; // added for M;
146  static std::string H_bias_ext_grid_s;
147 #endif
148  static int ApplyExcitationInPML;
150  static bool add_external_E_field;
152  static bool add_external_B_field;
153 
155  static std::string str_Bx_ext_grid_function;
157  static std::string str_By_ext_grid_function;
159  static std::string str_Bz_ext_grid_function;
161  static std::string str_Ex_ext_grid_function;
163  static std::string str_Ey_ext_grid_function;
165  static std::string str_Ez_ext_grid_function;
166 
167  // Function for B excitation (x,y,z,t) on the grid
168  static std::string str_Bx_excitation_grid_function;
169  static std::string str_By_excitation_grid_function;
170  static std::string str_Bz_excitation_grid_function;
171  // Function for E excitation (x,y,z,t) on the grid
172  static std::string str_Ex_excitation_grid_function;
173  static std::string str_Ey_excitation_grid_function;
174  static std::string str_Ez_excitation_grid_function;
175 #ifdef WARPX_MAG_LLG
176  // Function for H excitation (x,y,z,t) on the grid
177  static std::string str_Hx_excitation_grid_function;
178  static std::string str_Hy_excitation_grid_function;
179  static std::string str_Hz_excitation_grid_function;
180  // Function for H bias excitation (x,y,z,t) on the grid
181  static std::string str_Hx_bias_excitation_grid_function;
182  static std::string str_Hy_bias_excitation_grid_function;
183  static std::string str_Hz_bias_excitation_grid_function;
184 #endif
185  // Flag for type of excitation (hard/soft)
186  static std::string str_Ex_excitation_flag_function;
187  static std::string str_Ey_excitation_flag_function;
188  static std::string str_Ez_excitation_flag_function;
189  static std::string str_Bx_excitation_flag_function;
190  static std::string str_By_excitation_flag_function;
191  static std::string str_Bz_excitation_flag_function;
192 #ifdef WARPX_MAG_LLG
193  static std::string str_Hx_excitation_flag_function;
194  static std::string str_Hy_excitation_flag_function;
195  static std::string str_Hz_excitation_flag_function;
196  static std::string str_Hx_bias_excitation_flag_function;
197  static std::string str_Hy_bias_excitation_flag_function;
198  static std::string str_Hz_bias_excitation_flag_function;
199 #endif
200 
201 #ifdef WARPX_MAG_LLG
202  // Parser for H_external on the grid
203  static std::string str_Hx_ext_grid_function;
204  static std::string str_Hy_ext_grid_function;
205  static std::string str_Hz_ext_grid_function;
206  // Parser for M_external on the grid
207  static std::string str_Mx_ext_grid_function;
208  static std::string str_My_ext_grid_function;
209  static std::string str_Mz_ext_grid_function;
210  // Parser for H_bias_external on the grid
211  static std::string str_Hx_bias_ext_grid_function;
212  static std::string str_Hy_bias_ext_grid_function;
213  static std::string str_Hz_bias_ext_grid_function;
214 #endif
215 
217  std::unique_ptr<amrex::Parser> Bxfield_parser;
219  std::unique_ptr<amrex::Parser> Byfield_parser;
221  std::unique_ptr<amrex::Parser> Bzfield_parser;
223  std::unique_ptr<amrex::Parser> Exfield_parser;
225  std::unique_ptr<amrex::Parser> Eyfield_parser;
227  std::unique_ptr<amrex::Parser> Ezfield_parser;
228 
229 
230  // Parser for B_external excitation on the grid
231  std::unique_ptr<amrex::Parser> Bxfield_xt_grid_parser;
232  std::unique_ptr<amrex::Parser> Byfield_xt_grid_parser;
233  std::unique_ptr<amrex::Parser> Bzfield_xt_grid_parser;
234  // Parser for E_external excitation on the grid
235  std::unique_ptr<amrex::Parser> Exfield_xt_grid_parser;
236  std::unique_ptr<amrex::Parser> Eyfield_xt_grid_parser;
237  std::unique_ptr<amrex::Parser> Ezfield_xt_grid_parser;
238 #ifdef WARPX_MAG_LLG
239  // Parser for H_external excitation on the grid
240  std::unique_ptr<amrex::Parser> Hxfield_xt_grid_parser;
241  std::unique_ptr<amrex::Parser> Hyfield_xt_grid_parser;
242  std::unique_ptr<amrex::Parser> Hzfield_xt_grid_parser;
243  // Parser for H_bias external excitation on the grid
244  std::unique_ptr<amrex::Parser> Hx_biasfield_xt_grid_parser;
245  std::unique_ptr<amrex::Parser> Hy_biasfield_xt_grid_parser;
246  std::unique_ptr<amrex::Parser> Hz_biasfield_xt_grid_parser;
247 #endif
248  std::unique_ptr<amrex::Parser> Exfield_flag_parser;
249  std::unique_ptr<amrex::Parser> Eyfield_flag_parser;
250  std::unique_ptr<amrex::Parser> Ezfield_flag_parser;
251  std::unique_ptr<amrex::Parser> Bxfield_flag_parser;
252  std::unique_ptr<amrex::Parser> Byfield_flag_parser;
253  std::unique_ptr<amrex::Parser> Bzfield_flag_parser;
254 #ifdef WARPX_MAG_LLG
255  std::unique_ptr<amrex::Parser> Hxfield_flag_parser;
256  std::unique_ptr<amrex::Parser> Hyfield_flag_parser;
257  std::unique_ptr<amrex::Parser> Hzfield_flag_parser;
258  std::unique_ptr<amrex::Parser> Hx_biasfield_flag_parser;
259  std::unique_ptr<amrex::Parser> Hy_biasfield_flag_parser;
260  std::unique_ptr<amrex::Parser> Hz_biasfield_flag_parser;
261 #endif
262 
263 #ifdef WARPX_MAG_LLG
264  // Parser for H_external on the grid
265  std::unique_ptr<amrex::Parser> Hxfield_parser;
266  std::unique_ptr<amrex::Parser> Hyfield_parser;
267  std::unique_ptr<amrex::Parser> Hzfield_parser;
268  // Parser for M_external on the grid
269  std::unique_ptr<amrex::Parser> Mxfield_parser;
270  std::unique_ptr<amrex::Parser> Myfield_parser;
271  std::unique_ptr<amrex::Parser> Mzfield_parser;
272  // Parser for H_bias_external on the grid
273  std::unique_ptr<amrex::Parser> Hx_biasfield_parser;
274  std::unique_ptr<amrex::Parser> Hy_biasfield_parser;
275  std::unique_ptr<amrex::Parser> Hz_biasfield_parser;
276 #endif
277 
278  // Algorithms
280  static short current_deposition_algo;
282  static short charge_deposition_algo;
284  static short field_gathering_algo;
286  static short particle_pusher_algo;
288  static short electromagnetic_solver_id;
292  static short load_balance_costs_update_algo;
294  static int em_solver_medium;
298  static int macroscopic_solver_algo;
303  static amrex::Vector<int> field_boundary_lo;
308  static amrex::Vector<int> field_boundary_hi;
313  static amrex::Vector<ParticleBoundaryType> particle_boundary_lo;
318  static amrex::Vector<ParticleBoundaryType> particle_boundary_hi;
319  static int yee_coupled_solver_algo;
320 
321  static int use_PEC_mask;
322  static int use_lumped_inductor;
323 
327  static short psatd_solution_type;
328 
331  static short J_in_time;
332  static short rho_in_time;
333 
334 #ifdef WARPX_MAG_LLG
335  // second-order magnetization normalization strategy
336  int mag_M_normalization;
337  // turn on LLG + Maxwell coupling
338  int mag_LLG_coupling = 1;
339  // turn off the exchange coupling term H_exchange in H_eff for the LLG updates
340  int mag_LLG_exchange_coupling = 0;
341  // turn off the anisotropy coupling term H_anisotropy in H_eff for the LLG updates
342  int mag_LLG_anisotropy_coupling = 0;
343 #endif
347  static bool do_current_centering;
348 
350  // to satisfy the continuity equation and charge conservation
351  bool current_correction;
352 
355  bool update_with_rho = false;
356 
358  static bool do_single_precision_comms;
359 
361  static bool do_shared_mem_charge_deposition;
362 
364  static bool do_shared_mem_current_deposition;
365 
367  static int shared_mem_current_tpb;
368 
370  static amrex::IntVect shared_tilesize;
371 
373  static amrex::IntVect m_fill_guards_fields;
374 
376  static amrex::IntVect m_fill_guards_current;
377 
380  static bool do_dive_cleaning;
382  static bool do_divb_cleaning;
383 
385  static int nox;
387  static int noy;
389  static int noz;
390 
392  static int field_centering_nox;
394  static int field_centering_noy;
396  static int field_centering_noz;
397 
399  static int current_centering_nox;
401  static int current_centering_noy;
403  static int current_centering_noz;
404 
406  static int n_rz_azimuthal_modes;
411  static int ncomps;
412 
415  static bool use_fdtd_nci_corr;
425  static bool galerkin_interpolation;
426 
429  static bool verboncoeur_axis_correction;
430 
432  static bool use_filter;
434  static bool use_kspace_filter;
436  static bool use_filter_compensation;
437 
439  static bool serialize_initial_conditions;
440 
442  static amrex::Real gamma_boost;
444  static amrex::Real beta_boost;
446  static amrex::Vector<int> boost_direction;
450  static amrex::Real zmax_plasma_to_compute_max_step;
454  static bool do_compute_max_step_from_zmax;
457  static amrex::Real zmin_domain_boost_step_0;
458 
460  static bool compute_max_step_from_btd;
461 
462  static bool do_dynamic_scheduling;
463  static bool refine_plasma;
464 
465  static utils::parser::IntervalsParser sort_intervals;
466  static amrex::IntVect sort_bin_size;
467 
469  static bool sort_particles_for_deposition;
471  static amrex::IntVect sort_idx_type;
472 
473  static bool do_subcycling;
474  static bool do_multi_J;
475  static int do_multi_J_n_depositions;
476 
477  static bool do_device_synchronize;
478  static bool safe_guard_cells;
479 
483  static int n_field_gather_buffer;
487  static int n_current_deposition_buffer;
488 
491  static short grid_type;
492 
493  // Global rho nodal flag to know about rho index type when rho MultiFab is not allocated
494  amrex::IntVect m_rho_nodal_flag;
495 
510  static void AllocInitMultiFab (
511  std::unique_ptr<amrex::MultiFab>& mf,
512  const amrex::BoxArray& ba,
513  const amrex::DistributionMapping& dm,
514  const int ncomp,
515  const amrex::IntVect& ngrow,
516  const std::string& name,
517  std::optional<const amrex::Real> initial_value = {});
518 
533  static void AllocInitMultiFab (
534  std::unique_ptr<amrex::iMultiFab>& mf,
535  const amrex::BoxArray& ba,
536  const amrex::DistributionMapping& dm,
537  const int ncomp,
538  const amrex::IntVect& ngrow,
539  const std::string& name,
540  std::optional<const int> initial_value = {});
541 
552  static void AliasInitMultiFab (
553  std::unique_ptr<amrex::MultiFab>& mf,
554  const amrex::MultiFab& mf_to_alias,
555  const int scomp,
556  const int ncomp,
557  const std::string& name,
558  std::optional<const amrex::Real> initial_value);
559 
560  // Maps of all of the MultiFabs and iMultiFabs used (this can include MFs from other classes)
561  // This is a convenience for the Python interface, allowing all MultiFabs
562  // to be easily referenced from Python.
563  static std::map<std::string, amrex::MultiFab *> multifab_map;
564  static std::map<std::string, amrex::iMultiFab *> imultifab_map;
565 
572  static void AddToMultiFabMap(const std::string& name, const std::unique_ptr<amrex::MultiFab>& mf) {
573  multifab_map[name] = mf.get();
574  }
575 
582  static void AddToMultiFabMap(const std::string& name, const std::unique_ptr<amrex::iMultiFab>& mf) {
583  imultifab_map[name] = mf.get();
584  }
585 
586  std::array<const amrex::MultiFab* const, 3>
587  get_array_Bfield_aux (const int lev) const {
588  return {
589  Bfield_aux[lev][0].get(),
590  Bfield_aux[lev][1].get(),
591  Bfield_aux[lev][2].get()
592  };
593  }
594  std::array<const amrex::MultiFab* const, 3>
595  get_array_Efield_aux (const int lev) const {
596  return {
597  Efield_aux[lev][0].get(),
598  Efield_aux[lev][1].get(),
599  Efield_aux[lev][2].get()
600  };
601  }
602 
603 #ifdef WARPX_MAG_LLG
604  std::array<const amrex::MultiFab* const, 3>
605  get_array_Hfield_aux (const int lev) const {
606  return {
607  Hfield_aux[lev][0].get(),
608  Hfield_aux[lev][1].get(),
609  Hfield_aux[lev][2].get()
610  };
611  }
612  std::array<const amrex::MultiFab* const, 3>
613  get_array_Mfield_aux (const int lev) const {
614  return {
615  Mfield_aux[lev][0].get(),
616  Mfield_aux[lev][1].get(),
617  Mfield_aux[lev][2].get()
618  };
619  }
620  std::array<const amrex::MultiFab* const, 3>
621  get_array_H_biasfield_aux (const int lev) const {
622  return {
623  H_biasfield_aux[lev][0].get(),
624  H_biasfield_aux[lev][1].get(),
625  H_biasfield_aux[lev][2].get()
626  };
627  }
628 #endif
629  amrex::MultiFab * get_pointer_Efield_aux (int lev, int direction) const { return Efield_aux[lev][direction].get(); }
630  amrex::MultiFab * get_pointer_Bfield_aux (int lev, int direction) const { return Bfield_aux[lev][direction].get(); }
631 #ifdef WARPX_MAG_LLG
632  amrex::MultiFab * get_pointer_Hfield_aux (int lev, int direction) const { return Hfield_aux[lev][direction].get(); }
633  amrex::MultiFab * get_pointer_Mfield_aux (int lev, int direction) const { return Mfield_aux[lev][direction].get(); }
634  amrex::MultiFab * get_pointer_H_biasfield_aux (int lev, int direction) const { return H_biasfield_aux[lev][direction].get(); }
635 #endif
636  amrex::MultiFab * get_pointer_Efield_fp (int lev, int direction) const { return Efield_fp[lev][direction].get(); }
637  amrex::MultiFab * get_pointer_PEC_fp (int lev, int direction) const { return PEC_fp[lev][direction].get(); }
638  amrex::MultiFab * get_pointer_Bfield_fp (int lev, int direction) const { return Bfield_fp[lev][direction].get(); }
639  amrex::MultiFab * get_pointer_Bfield_sc_fp (int lev, int direction) const { return Bfield_sc_fp[lev][direction].get(); }
640 
641 #ifdef WARPX_MAG_LLG
642  amrex::MultiFab * get_pointer_Hfield_fp (int lev, int direction) const { return Hfield_fp[lev][direction].get();}
643  // note "direction" of M means face. For M, each face stores all 3 vector components of M
644  amrex::MultiFab * get_pointer_Mfield_fp (int lev, int direction) const { return Mfield_fp[lev][direction].get();}
645  amrex::MultiFab * get_pointer_H_biasfield_fp (int lev, int direction) const { return H_biasfield_fp[lev][direction].get();}
646 #endif
647  amrex::MultiFab * get_pointer_current_fp (int lev, int direction) const { return current_fp[lev][direction].get(); }
648  amrex::MultiFab * get_pointer_current_fp_nodal (int lev, int direction) const { return current_fp_nodal[lev][direction].get(); }
649  amrex::MultiFab * get_pointer_rho_fp (int lev) const { return rho_fp[lev].get(); }
650  amrex::MultiFab * get_pointer_F_fp (int lev) const { return F_fp[lev].get(); }
651  amrex::MultiFab * get_pointer_G_fp (int lev) const { return G_fp[lev].get(); }
652  amrex::MultiFab * get_pointer_phi_fp (int lev) const { return phi_fp[lev].get(); }
653  amrex::MultiFab * get_pointer_vector_potential_fp (int lev, int direction) const { return vector_potential_fp_nodal[lev][direction].get(); }
654 
655  amrex::MultiFab * get_pointer_Efield_cp (int lev, int direction) const { return Efield_cp[lev][direction].get(); }
656  amrex::MultiFab * get_pointer_Bfield_cp (int lev, int direction) const { return Bfield_cp[lev][direction].get(); }
657 #ifdef WARPX_MAG_LLG
658  amrex::MultiFab * get_pointer_Hfield_cp (int lev, int direction) const { return Hfield_cp[lev][direction].get(); }
659  amrex::MultiFab * get_pointer_Mfield_cp (int lev, int direction) const { return Mfield_cp[lev][direction].get(); }
660  amrex::MultiFab * get_pointer_H_biasfield_cp (int lev, int direction) const { return H_biasfield_cp[lev][direction].get(); }
661 #endif
662  amrex::MultiFab * get_pointer_current_cp (int lev, int direction) const { return current_cp[lev][direction].get(); }
663  amrex::MultiFab * get_pointer_rho_cp (int lev) const { return rho_cp[lev].get(); }
664  amrex::MultiFab * get_pointer_F_cp (int lev) const { return F_cp[lev].get(); }
665  amrex::MultiFab * get_pointer_G_cp (int lev) const { return G_cp[lev].get(); }
666 
667  amrex::MultiFab * get_pointer_edge_lengths (int lev, int direction) const { return m_edge_lengths[lev][direction].get(); }
668  amrex::MultiFab * get_pointer_face_areas (int lev, int direction) const { return m_face_areas[lev][direction].get(); }
669 
670  const amrex::MultiFab& getEfield (int lev, int direction) {return *Efield_aux[lev][direction];}
671  const amrex::MultiFab& getBfield (int lev, int direction) {return *Bfield_aux[lev][direction];}
672 #ifdef WARPX_MAG_LLG
673  const amrex::MultiFab& getHfield (int lev, int direction) {return *Hfield_aux[lev][direction];}
674  const amrex::MultiFab& getMfield (int lev, int direction) {return *Mfield_aux[lev][direction];}
675  const amrex::MultiFab& getH_biasfield (int lev, int direction) {return *H_biasfield_aux[lev][direction];}
676 #endif
677  const amrex::MultiFab& getcurrent_cp (int lev, int direction) {return *current_cp[lev][direction];}
678  const amrex::MultiFab& getEfield_cp (int lev, int direction) {return *Efield_cp[lev][direction];}
679  const amrex::MultiFab& getBfield_cp (int lev, int direction) {return *Bfield_cp[lev][direction];}
680 #ifdef WARPX_MAG_LLG
681  const amrex::MultiFab& getHfield_cp (int lev, int direction) {return *Hfield_cp[lev][direction];}
682  const amrex::MultiFab& getMfield_cp (int lev, int direction) {return *Mfield_cp[lev][direction];}
683  const amrex::MultiFab& getH_biasfield_cp (int lev, int direction) {return *H_biasfield_cp[lev][direction];}
684 #endif
685  const amrex::MultiFab& getrho_cp (int lev) {return *rho_cp[lev];}
686  const amrex::MultiFab& getF_cp (int lev) {return *F_cp[lev];}
687  const amrex::MultiFab& getG_cp (int lev) {return *G_cp[lev];}
688 
689  const amrex::MultiFab& getcurrent_fp (int lev, int direction) {return *current_fp[lev][direction];}
690  const amrex::MultiFab& getEfield_fp (int lev, int direction) {return *Efield_fp[lev][direction];}
691  const amrex::MultiFab& getPEC_fp (int lev, int direction) {return *PEC_fp[lev][direction];}
692  const amrex::MultiFab& getBfield_fp (int lev, int direction) {return *Bfield_fp[lev][direction];}
693  const amrex::MultiFab& getBfield_sc_fp (int lev, int direction) {return *Bfield_sc_fp[lev][direction];}
694 #ifdef WARPX_MAG_LLG
695  const amrex::MultiFab& getHfield_fp (int lev, int direction) {return *Hfield_fp[lev][direction];}
696  const amrex::MultiFab& getMfield_fp (int lev, int direction) {return *Mfield_fp[lev][direction];}
697  const amrex::MultiFab& getH_biasfield_fp (int lev, int direction) {return *H_biasfield_fp[lev][direction];}
698 #endif
699  const amrex::MultiFab& getrho_fp (int lev) {return *rho_fp[lev];}
700  const amrex::MultiFab& getphi_fp (int lev) {return *phi_fp[lev];}
701  const amrex::MultiFab& getF_fp (int lev) {return *F_fp[lev];}
702  const amrex::MultiFab& getG_fp (int lev) {return *G_fp[lev];}
703 
704  const amrex::MultiFab& getEfield_avg_fp (int lev, int direction) {return *Efield_avg_fp[lev][direction];}
705  const amrex::MultiFab& getBfield_avg_fp (int lev, int direction) {return *Bfield_avg_fp[lev][direction];}
706  const amrex::MultiFab& getEfield_avg_cp (int lev, int direction) {return *Efield_avg_cp[lev][direction];}
707  const amrex::MultiFab& getBfield_avg_cp (int lev, int direction) {return *Bfield_avg_cp[lev][direction];}
708 
709  bool DoPML () const {return do_pml;}
710 
711 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
712  const PML_RZ* getPMLRZ() {return pml_rz[0].get();}
713 #endif
714 
716  std::vector<bool> getPMLdirections() const;
717 
718  static amrex::LayoutData<amrex::Real>* getCosts (int lev);
719 
720  void setLoadBalanceEfficiency (const int lev, const amrex::Real efficiency)
721  {
722  if (m_instance)
723  {
724  m_instance->load_balance_efficiency[lev] = efficiency;
725  } else
726  {
727  return;
728  }
729  }
730 
731  amrex::Real getLoadBalanceEfficiency (const int lev)
732  {
733  if (m_instance)
734  {
735  return m_instance->load_balance_efficiency[lev];
736  } else
737  {
738  return -1;
739  }
740  }
741 
742  static amrex::IntVect filter_npass_each_dir;
743  BilinearFilter bilinear_filter;
744  amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > nci_godfrey_filter_exeybz;
745  amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > nci_godfrey_filter_bxbyez;
746 
747  amrex::Real time_of_last_gal_shift = 0;
748  amrex::Vector<amrex::Real> m_v_galilean = amrex::Vector<amrex::Real>(3, amrex::Real(0.));
749  amrex::Array<amrex::Real,3> m_galilean_shift = {{0}};
750 
751  amrex::Vector<amrex::Real> m_v_comoving = amrex::Vector<amrex::Real>(3, amrex::Real(0.));
752 
753  static int num_mirrors;
754  amrex::Vector<amrex::Real> mirror_z;
755  amrex::Vector<amrex::Real> mirror_z_width;
756  amrex::Vector<int> mirror_z_npoints;
757 
759  std::unique_ptr<MultiReducedDiags> reduced_diags;
760 
761  void applyMirrors(amrex::Real time);
762 
764  void ComputeDt ();
765 
767  void PrintMainPICparameters ();
768 
770  void WriteUsedInputsFile () const;
771 
773  void PrintDtDxDyDz ();
774 
780  void ComputeMaxStep ();
781  // Compute max_step automatically for simulations in a boosted frame.
782  void computeMaxStepBoostAccelerator();
783 
788  int MoveWindow (const int step, bool move_j);
789 
795  void ShiftGalileanBoundary ();
796  void UpdatePlasmaInjectionPosition (amrex::Real dt);
797  void ResetProbDomain (const amrex::RealBox& rb);
798  void EvolveE ( amrex::Real dt); // declare this function, defined somewhere else
799  void EvolveE (int lev, amrex::Real dt);
800  void EvolveB ( amrex::Real dt, DtType dt_type);
801  void EvolveB (int lev, amrex::Real dt, DtType dt_type);
802  void EvolveF ( amrex::Real dt, DtType dt_type);
803  void EvolveF (int lev, amrex::Real dt, DtType dt_type);
804  void EvolveG ( amrex::Real dt, DtType dt_type);
805  void EvolveG (int lev, amrex::Real dt, DtType dt_type);
806  void EvolveB (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
807  void EvolveE (int lev, PatchType patch_type, amrex::Real dt);
808  void EvolveF (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
809  void EvolveG (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
810  void EvolveBLondon ( amrex::Real dt, DtType dt_type);
811  void EvolveBLondon (int lev, amrex::Real dt, DtType dt_type);
812  void EvolveBLondon (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
813 
814  void MacroscopicEvolveE ( amrex::Real dt);
815  void MacroscopicEvolveE (int lev, amrex::Real dt);
816  void MacroscopicEvolveE (int lev, PatchType patch_type, amrex::Real dt);
817 
818 #ifdef WARPX_MAG_LLG
819  void MacroscopicEvolveHM ( amrex::Real dt);
820  void MacroscopicEvolveHM (int lev, amrex::Real dt);
821  void MacroscopicEvolveHM (int lev, PatchType patch_type, amrex::Real dt);
822 
823  void MacroscopicEvolveHM_2nd ( amrex::Real dt);
824  void MacroscopicEvolveHM_2nd (int lev, amrex::Real dt);
825  void MacroscopicEvolveHM_2nd (int lev, PatchType patch_type, amrex::Real dt);
826 #endif
827 
832  void Hybrid_QED_Push ( amrex::Vector<amrex::Real> dt);
833 
839  void Hybrid_QED_Push (int lev, amrex::Real dt);
840 
847  void Hybrid_QED_Push (int lev, PatchType patch_type, amrex::Real dt);
848 
849  static amrex::Real quantum_xi_c2;
850 
853  void LoadBalance ();
856  void ResetCosts ();
857 
860  utils::parser::IntervalsParser get_load_balance_intervals () const
861  {
862  return load_balance_intervals;
863  }
864 
872  void DampFieldsInGuards (const int lev,
873  const std::array<std::unique_ptr<amrex::MultiFab>,3>& Efield,
874  const std::array<std::unique_ptr<amrex::MultiFab>,3>& Bfield);
875 
883  void DampFieldsInGuards (const int lev, std::unique_ptr<amrex::MultiFab>& mf);
884 
885 #ifdef WARPX_DIM_RZ
886  void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab* Jx,
887  amrex::MultiFab* Jy,
888  amrex::MultiFab* Jz,
889  int lev);
890 
891  void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab* Rho,
892  int lev);
893 #endif
894 
900  void ApplyRhofieldBoundary (const int lev, amrex::MultiFab* Rho,
901  PatchType patch_type);
902 
908  void ApplyJfieldBoundary (const int lev, amrex::MultiFab* Jx,
909  amrex::MultiFab* Jy, amrex::MultiFab* Jz,
910  PatchType patch_type);
911 
912  void ApplyEfieldBoundary (const int lev, PatchType patch_type);
913  void ApplyBfieldBoundary (const int lev, PatchType patch_type, DtType dt_type);
914 
915  void DampPML ();
916  void DampPML (const int lev);
917  void DampPML (const int lev, PatchType patch_type);
918  void DampPML_Cartesian (const int lev, PatchType patch_type);
919 
920  void DampJPML ();
921  void DampJPML (int lev);
922  void DampJPML (int lev, PatchType patch_type);
923 
924  void CopyJPML ();
925  bool isAnyBoundaryPML();
926 
930  void NodalSyncPML ();
931 
935  void NodalSyncPML (int lev);
936 
940  void NodalSyncPML (int lev, PatchType patch_type);
941 
942  PML* GetPML (int lev);
943 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
944  PML_RZ* GetPML_RZ (int lev);
945 #endif
946 
948  void doFieldIonization ();
952  void doFieldIonization (int lev);
953 
954 #ifdef WARPX_QED
956  void doQEDEvents ();
960  void doQEDEvents (int lev);
961 #endif
962 
963  void PushParticlesandDepose (int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false);
964  void PushParticlesandDepose ( amrex::Real cur_time, bool skip_current=false);
965 
966  // This function does aux(lev) = fp(lev) + I(aux(lev-1)-cp(lev)).
967  // Caller must make sure fp and cp have ghost cells filled.
968  void UpdateAuxilaryData ();
969  void UpdateAuxilaryDataStagToNodal ();
970  void UpdateAuxilaryDataSameType ();
971 
980  void UpdateCurrentNodalToStag (amrex::MultiFab& dst, amrex::MultiFab const& src);
981 
982  // Fill boundary cells including coarse/fine boundaries
983  void FillBoundaryB (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
984  void FillBoundaryE (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
985  void FillBoundaryB_avg (amrex::IntVect ng);
986  void FillBoundaryE_avg (amrex::IntVect ng);
987 #ifdef WARPX_MAG_LLG
988  void FillBoundaryM (amrex::IntVect ng);
989  void FillBoundaryH (amrex::IntVect ng);
990 #endif
991 
992  void FillBoundaryF (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
993  void FillBoundaryG (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
994  void FillBoundaryAux (amrex::IntVect ng);
995  void FillBoundaryE (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
996  void FillBoundaryB (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
997  void FillBoundaryE_avg (int lev, amrex::IntVect ng);
998  void FillBoundaryB_avg (int lev, amrex::IntVect ng);
999 #ifdef WARPX_MAG_LLG
1000  void FillBoundaryM (int lev, amrex::IntVect ng);
1001  void FillBoundaryH (int lev, amrex::IntVect ng);
1002 #endif
1003 
1004  void FillBoundaryF (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1005  void FillBoundaryG (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1006  void FillBoundaryAux (int lev, amrex::IntVect ng);
1007 
1008  void FillBoundaryJ (amrex::IntVect ng);
1009  void FillBoundaryJ (const int lev, amrex::IntVect ng);
1010 
1016  void SyncCurrentAndRho ();
1017 
1029  void SyncCurrent (
1030  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1031  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp);
1032 
1033  void SyncRho ();
1034 
1035  void SyncRho (
1036  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1037  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp);
1038 
1039  amrex::Vector<int> getnsubsteps () const {return nsubsteps;}
1040  int getnsubsteps (int lev) const {return nsubsteps[lev];}
1041  amrex::Vector<int> getistep () const {return istep;}
1042  int getistep (int lev) const {return istep[lev];}
1043  void setistep (int lev, int ii) {istep[lev] = ii;}
1044  amrex::Vector<amrex::Real> gett_old () const {return t_old;}
1045  amrex::Real gett_old (int lev) const {return t_old[lev];}
1046  amrex::Vector<amrex::Real> gett_new () const {return t_new;}
1047  amrex::Real gett_new (int lev) const {return t_new[lev];}
1048  void sett_new (int lev, amrex::Real time) {t_new[lev] = time;}
1049  amrex::Vector<amrex::Real> getdt () const {return dt;}
1050  amrex::Real getdt (int lev) const {return dt[lev];}
1051  int getdo_moving_window() const {return do_moving_window;}
1052  amrex::Real getmoving_window_x() const {return moving_window_x;}
1053  amrex::Real getcurrent_injection_position () const {return current_injection_position;}
1054  bool getis_synchronized() const {return is_synchronized;}
1055 
1056  int maxStep () const {return max_step;}
1057  void updateMaxStep (const int new_max_step) {max_step = new_max_step;}
1058  amrex::Real stopTime () const {return stop_time;}
1059  void updateStopTime (const amrex::Real new_stop_time) {stop_time = new_stop_time;}
1060 
1061  void AverageAndPackFields( amrex::Vector<std::string>& varnames,
1062  amrex::Vector<amrex::MultiFab>& mf_avg, const amrex::IntVect ngrow) const;
1063 
1064  void prepareFields( int const step, amrex::Vector<std::string>& varnames,
1065  amrex::Vector<amrex::MultiFab>& mf_avg,
1066  amrex::Vector<const amrex::MultiFab*>& output_mf,
1067  amrex::Vector<amrex::Geometry>& output_geom ) const;
1068 
1069  static std::array<amrex::Real,3> CellSize (int lev);
1070  static amrex::RealBox getRealBox(const amrex::Box& bx, int lev);
1071 
1080  static std::array<amrex::Real,3> LowerCorner (const amrex::Box& bx, const int lev, const amrex::Real time_shift_delta);
1089  static std::array<amrex::Real,3> UpperCorner (const amrex::Box& bx, const int lev, const amrex::Real time_shift_delta);
1090 
1091  static amrex::IntVect RefRatio (int lev);
1092 
1093  static const amrex::iMultiFab* CurrentBufferMasks (int lev);
1094  static const amrex::iMultiFab* GatherBufferMasks (int lev);
1095 
1096  static int electrostatic_solver_id;
1097 
1098  // Parameters for lab frame electrostatic
1099  static amrex::Real self_fields_required_precision;
1100  static amrex::Real self_fields_absolute_tolerance;
1101  static int self_fields_max_iters;
1102  static int self_fields_verbosity;
1103 
1104  static int do_moving_window; // boolean
1105  static int start_moving_window_step; // the first step to move window
1106  static int end_moving_window_step; // the last step to move window
1112  static int moving_window_active (int const step) {
1113  bool const step_before_end = (step < end_moving_window_step) || (end_moving_window_step < 0);
1114  bool const step_after_start = (step >= start_moving_window_step);
1115  return do_moving_window && step_before_end && step_after_start;
1116  }
1117  static int moving_window_dir;
1118  static amrex::Real moving_window_v;
1119  static bool fft_do_time_averaging;
1120 
1121  // these should be private, but can't due to Cuda limitations
1122  static void ComputeDivB (amrex::MultiFab& divB, int const dcomp,
1123  const std::array<const amrex::MultiFab* const, 3>& B,
1124  const std::array<amrex::Real,3>& dx);
1125 
1126  static void ComputeDivB (amrex::MultiFab& divB, int const dcomp,
1127  const std::array<const amrex::MultiFab* const, 3>& B,
1128  const std::array<amrex::Real,3>& dx, amrex::IntVect const ngrow);
1129 
1130  void ComputeDivE(amrex::MultiFab& divE, const int lev);
1131 
1132  const amrex::IntVect getngEB() const { return guard_cells.ng_alloc_EB; }
1133  const amrex::IntVect getngF() const { return guard_cells.ng_alloc_F; }
1134  const amrex::IntVect getngUpdateAux() const { return guard_cells.ng_UpdateAux; }
1135  const amrex::IntVect get_ng_depos_J() const {return guard_cells.ng_depos_J;}
1136  const amrex::IntVect get_ng_depos_rho() const {return guard_cells.ng_depos_rho;}
1137  const amrex::IntVect get_ng_fieldgather () const {return guard_cells.ng_FieldGather;}
1138 
1146  const amrex::IntVect get_numprocs() const {return numprocs;}
1147 
1148  ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler;
1149  void ComputeSpaceChargeField (bool const reset_fields);
1150  void AddBoundaryField ();
1151  void AddSpaceChargeField (WarpXParticleContainer& pc);
1152  void AddSpaceChargeFieldLabFrame ();
1153  void computePhi (const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& rho,
1154  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
1155  std::array<amrex::Real, 3> const beta = {{0,0,0}},
1156  amrex::Real const required_precision=amrex::Real(1.e-11),
1157  amrex::Real absolute_tolerance=amrex::Real(0.0),
1158  const int max_iters=200,
1159  const int verbosity=2) const;
1160 
1161  void setPhiBC (amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi ) const;
1162 
1163  void computeE (amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3> >& E,
1164  const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
1165  std::array<amrex::Real, 3> const beta = {{0,0,0}} ) const;
1166  void computeB (amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3> >& B,
1167  const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
1168  std::array<amrex::Real, 3> const beta = {{0,0,0}} ) const;
1169  void computePhiTriDiagonal (const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& rho,
1170  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi) const;
1171 
1172  // Magnetostatic Solver Interface
1173  MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler;
1174  void ComputeMagnetostaticField ();
1175  void AddMagnetostaticFieldLabFrame ();
1176  void computeVectorPotential (const amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& curr,
1177  amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& A,
1178  amrex::Real const required_precision=amrex::Real(1.e-11),
1179  amrex::Real absolute_tolerance=amrex::Real(0.0),
1180  const int max_iters=200,
1181  const int verbosity=2) const;
1182 
1183  void setVectorPotentialBC (amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& A) const;
1184 
1206  void InitializeExternalFieldsOnGridUsingParser (
1207  amrex::MultiFab *mfx, amrex::MultiFab *mfy, amrex::MultiFab *mfz,
1208  amrex::ParserExecutor<3> const& xfield_parser,
1209  amrex::ParserExecutor<3> const& yfield_parser,
1210  amrex::ParserExecutor<3> const& zfield_parser,
1211  std::array< std::unique_ptr<amrex::MultiFab>, 3 > const& edge_lengths,
1212  std::array< std::unique_ptr<amrex::MultiFab>, 3 > const& face_areas,
1213  const char field,
1214  const int lev, PatchType patch_type);
1215 
1216  void ReadExternalFieldFromFile (
1217  std::string read_fields_from_path, amrex::MultiFab* mf,
1218  std::string F_name, std::string F_component);
1219 
1228  void InitializeEBGridData(int lev);
1229 
1235  void ComputeCostsHeuristic (amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > >& costs);
1236 
1237  void ApplyFilterandSumBoundaryRho (int lev, int glev, amrex::MultiFab& rho, int icomp, int ncomp);
1238 
1265  void ApplyExternalFieldExcitationOnGrid (int const externalfieldtype, DtType a_dt_type = DtType::Full);
1266  void ApplyExternalFieldExcitationOnGrid ( amrex::MultiFab *mfx,
1267  amrex::MultiFab *mfy, amrex::MultiFab *mfz,
1268  amrex::ParserExecutor<4> const& xfield_parser,
1269  amrex::ParserExecutor<4> const& yfield_parser,
1270  amrex::ParserExecutor<4> const& zfield_parser,
1271  amrex::ParserExecutor<3> const& xflag_parser,
1272  amrex::ParserExecutor<3> const& yflag_parser,
1273  amrex::ParserExecutor<3> const& zflag_parser, const int lev,
1274  DtType a_dt_type );
1276  void ReadExcitationParser ();
1277 
1278 #ifdef WARPX_MAG_LLG
1279  void AverageParsedMtoFaces(amrex::MultiFab& Mx_cc,
1280  amrex::MultiFab& My_cc,
1281  amrex::MultiFab& Mz_cc,
1282  amrex::MultiFab& Mx_face,
1283  amrex::MultiFab& My_face,
1284  amrex::MultiFab& Mz_face);
1285 #endif
1286 
1295  static amrex::Vector<amrex::Real> getFornbergStencilCoefficients(const int n_order, const short a_grid_type);
1296 
1297  // Device vectors of stencil coefficients used for finite-order centering of fields
1298  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_x;
1299  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_y;
1300  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_z;
1301 
1302  // Device vectors of stencil coefficients used for finite-order centering of currents
1303  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_x;
1304  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_y;
1305  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_z;
1306 
1307  // This needs to be public for CUDA.
1309  virtual void ErrorEst (int lev, amrex::TagBoxArray& tags, amrex::Real time, int /*ngrow*/) final;
1310 
1311  // Return the accelerator lattice instance defined at the given refinement level
1312  const AcceleratorLattice& get_accelerator_lattice (int lev) {return *(m_accelerator_lattice[lev]);}
1313 
1314 protected:
1315 
1341  void InitLevelData (int lev, amrex::Real time);
1342 
1345  virtual void PostProcessBaseGrids (amrex::BoxArray& ba0) const final;
1346 
1350  virtual void MakeNewLevelFromScratch (int lev, amrex::Real time, const amrex::BoxArray& ba,
1351  const amrex::DistributionMapping& dm) final;
1352 
1356  virtual void MakeNewLevelFromCoarse (int /*lev*/, amrex::Real /*time*/, const amrex::BoxArray& /*ba*/,
1357  const amrex::DistributionMapping& /*dm*/) final;
1358 
1362  virtual void RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray& ba,
1363  const amrex::DistributionMapping& dm) final;
1364 
1366  virtual void ClearLevel (int lev) final;
1367 
1368 private:
1369 
1370  // Singleton is used when the code is run from python
1371  static WarpX* m_instance;
1372 
1374  static void CheckSignals ();
1376  void HandleSignals ();
1377 
1381  void EvolveEM(int numsteps);
1382 
1383 #ifdef WARPX_MAG_LLG
1384  void FillBoundaryM (const int lev, const PatchType patch_type, const amrex::IntVect ng);
1385  void FillBoundaryH (const int lev, const PatchType patch_type, const amrex::IntVect ng);
1386 #endif
1387  void FillBoundaryB (const int lev, const PatchType patch_type, const amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1388  void FillBoundaryE (const int lev, const PatchType patch_type, const amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1389  void FillBoundaryF (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1390  void FillBoundaryG (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1391 
1392  void FillBoundaryB_avg (int lev, PatchType patch_type, amrex::IntVect ng);
1393  void FillBoundaryE_avg (int lev, PatchType patch_type, amrex::IntVect ng);
1394  void FillBoundaryJ (const int lev, const PatchType patch_type, const amrex::IntVect ng);
1395 
1396  void AddExternalFields ();
1397 
1398  void OneStep_nosub (amrex::Real t);
1399  void OneStep_sub1 (amrex::Real t);
1400 
1404  void OneStep_multiJ (const amrex::Real t);
1405 
1406  void RestrictCurrentFromFineToCoarsePatch (
1407  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1408  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1409  const int lev);
1410  void AddCurrentFromFineLevelandSumBoundary (
1411  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1412  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1413  const int lev);
1414  void StoreCurrent (const int lev);
1415  void RestoreCurrent (const int lev);
1416  void ApplyFilterJ (
1417  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1418  const int lev,
1419  const int idim);
1420  void ApplyFilterJ (
1421  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1422  const int lev);
1423  void SumBoundaryJ (
1424  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1425  const int lev,
1426  const int idim,
1427  const amrex::Periodicity& period);
1428  void SumBoundaryJ (
1429  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1430  const int lev,
1431  const amrex::Periodicity& period);
1432  void NodalSyncJ (
1433  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1434  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1435  const int lev,
1436  PatchType patch_type);
1437 
1438  void RestrictRhoFromFineToCoarsePatch (
1439  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1440  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1441  const int lev);
1442  void ApplyFilterandSumBoundaryRho (
1443  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1444  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1445  const int lev,
1446  PatchType patch_type,
1447  const int icomp,
1448  const int ncomp);
1449  void AddRhoFromFineLevelandSumBoundary (
1450  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1451  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1452  const int lev,
1453  const int icomp,
1454  const int ncomp);
1455  void NodalSyncRho (
1456  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1457  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1458  const int lev,
1459  PatchType patch_type,
1460  const int icomp,
1461  const int ncomp);
1462 
1463  void ReadParameters ();
1464 
1467  void BackwardCompatibility ();
1468 
1469  void InitFromScratch ();
1470 
1471  void AllocLevelData (int lev, const amrex::BoxArray& new_grids,
1472  const amrex::DistributionMapping& new_dmap);
1473 
1474  amrex::DistributionMapping
1475  GetRestartDMap (const std::string& chkfile, const amrex::BoxArray& ba, int lev) const;
1476 
1477  void InitFromCheckpoint ();
1478  void PostRestart ();
1479 
1480  void InitPML ();
1481  void ComputePMLFactors ();
1482 
1483  void InitFilter ();
1484 
1485  void InitDiagnostics ();
1486 
1487  void InitNCICorrector ();
1488 
1493  void CheckGuardCells();
1494 
1499  void CheckGuardCells(amrex::MultiFab const& mf);
1500 
1504  void CheckKnownIssues();
1505 
1507  void PerformanceHints ();
1508 
1509  void BuildBufferMasks ();
1510 public: // for cuda
1511  void BuildBufferMasksInBox ( const amrex::Box tbx, amrex::IArrayBox &buffer_mask,
1512  const amrex::IArrayBox &guard_mask, const int ng );
1513 private:
1514  const amrex::iMultiFab* getCurrentBufferMasks (int lev) const {
1515  return current_buffer_masks[lev].get();
1516  }
1517  const amrex::iMultiFab* getGatherBufferMasks (int lev) const {
1518  return gather_buffer_masks[lev].get();
1519  }
1520 
1530  void ReorderFornbergCoefficients (amrex::Vector<amrex::Real>& ordered_coeffs,
1531  amrex::Vector<amrex::Real>& unordered_coeffs,
1532  const int order);
1545  void AllocateCenteringCoefficients (amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_x,
1546  amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_y,
1547  amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_z,
1548  const int centering_nox,
1549  const int centering_noy,
1550  const int centering_noz,
1551  const short a_grid_type);
1552 
1553  void AllocLevelMFs (int lev, const amrex::BoxArray& ba, const amrex::DistributionMapping& dm,
1554  const amrex::IntVect& ngEB, amrex::IntVect& ngJ,
1555  const amrex::IntVect& ngRho, const amrex::IntVect& ngF,
1556  const amrex::IntVect& ngG, const bool aux_is_nodal);
1557 
1558 #ifdef WARPX_USE_PSATD
1559 # ifdef WARPX_DIM_RZ
1560  void AllocLevelSpectralSolverRZ (amrex::Vector<std::unique_ptr<SpectralSolverRZ>>& spectral_solver,
1561  const int lev,
1562  const amrex::BoxArray& realspace_ba,
1563  const amrex::DistributionMapping& dm,
1564  const std::array<amrex::Real,3>& dx);
1565 # else
1566  void AllocLevelSpectralSolver (amrex::Vector<std::unique_ptr<SpectralSolver>>& spectral_solver,
1567  const int lev,
1568  const amrex::BoxArray& realspace_ba,
1569  const amrex::DistributionMapping& dm,
1570  const std::array<amrex::Real,3>& dx,
1571  const bool pml_flag=false);
1572 # endif
1573 #endif
1574 
1575  amrex::Vector<int> istep; // which step?
1576  amrex::Vector<int> nsubsteps; // how many substeps on each level?
1577 
1578  amrex::Vector<amrex::Real> t_new;
1579  amrex::Vector<amrex::Real> t_old;
1580  amrex::Vector<amrex::Real> dt;
1581 
1582  // Particle container
1583  std::unique_ptr<MultiParticleContainer> mypc;
1584  std::unique_ptr<MultiDiagnostics> multi_diags;
1585 
1586  //
1587  // Fields: First array for level, second for direction
1588  //
1589 
1590  // Full solution
1591  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_aux;
1592  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_aux;
1593 #ifdef WARPX_MAG_LLG
1594  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_aux;
1595  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_aux;
1596  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_aux;
1597 #endif
1598  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_aux;
1599  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_aux;
1600 
1601  // Fine patch
1602  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_fp;
1603  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_fp;
1604  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_fp;
1605  amrex::Vector< std::unique_ptr<amrex::MultiFab> > phi_fp;
1606  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_fp;
1607  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_fp_vay;
1608  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_fp;
1609  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > PEC_fp;
1610  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_fp;
1611 #ifdef WARPX_MAG_LLG
1612  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_fp;
1613  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_fp;
1614  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_fp;
1615 #endif
1616  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_fp;
1617  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_fp;
1618 
1619  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_sc_fp;
1620  // Memory buffers for computing magnetostatic fields
1621  // Vector Potential A and previous step. Time buffer needed for computing dA/dt to first order
1622  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_fp_nodal;
1623  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_grad_buf_e_stag;
1624  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_grad_buf_b_stag;
1625 
1626  // Same as Bfield_fp/Efield_fp for reading external field data
1627  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_fp_external;
1628  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_fp_external;
1629 
1631  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_edge_lengths;
1633  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_face_areas;
1634 
1641  amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > m_flag_info_face;
1648  amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > m_flag_ext_face;
1652  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_area_mod;
1656  amrex::Vector<std::array< std::unique_ptr<amrex::LayoutData<FaceInfoBox> >, 3 > > m_borrowing;
1657 
1665  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > ECTRhofield;
1669  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Venl;
1670 
1671  //EB level set
1672  amrex::Vector<std::unique_ptr<amrex::MultiFab> > m_distance_to_eb;
1673 
1674  // store fine patch
1675  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_store;
1676 
1677  // Nodal MultiFab for nodal current deposition if warpx.do_current_centering = 1
1678  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>> current_fp_nodal;
1679 
1680  // Coarse patch
1681  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_cp;
1682  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_cp;
1683  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_cp;
1684  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_cp;
1685  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_cp;
1686  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_cp;
1687 #ifdef WARPX_MAG_LLG
1688  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_cp;
1689  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_cp;
1690  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_cp;
1691 #endif
1692  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_cp;
1693  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_cp;
1694 
1695  // Copy of the coarse aux
1696  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Efield_cax;
1697  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_cax;
1698 #ifdef WARPX_MAG_LLG
1699  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_cax;
1700  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_cax;
1701  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_cax;
1702 #endif
1703  amrex::Vector<std::unique_ptr<amrex::iMultiFab> > current_buffer_masks;
1704  amrex::Vector<std::unique_ptr<amrex::iMultiFab> > gather_buffer_masks;
1705 
1706  // If charge/current deposition buffers are used
1707  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_buf;
1708  amrex::Vector<std::unique_ptr<amrex::MultiFab> > charge_buf;
1709 
1710  // PML
1711  int do_pml = 0;
1712  int do_silver_mueller = 0;
1713  int pml_ncell = 10;
1714  int pml_delta = 10;
1715  int pml_has_particles = 0;
1716  int do_pml_j_damping = 0;
1717  int do_pml_in_domain = 0;
1718  static int do_similar_dm_pml;
1719  bool do_pml_dive_cleaning; // default set in WarpX.cpp
1720  bool do_pml_divb_cleaning; // default set in WarpX.cpp
1721  amrex::Vector<amrex::IntVect> do_pml_Lo;
1722  amrex::Vector<amrex::IntVect> do_pml_Hi;
1723  amrex::Vector<std::unique_ptr<PML> > pml;
1724 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
1725  amrex::Vector<std::unique_ptr<PML_RZ> > pml_rz;
1726 #endif
1727  amrex::Real v_particle_pml;
1728 
1729  amrex::Real moving_window_x = std::numeric_limits<amrex::Real>::max();
1730  amrex::Real current_injection_position = 0;
1731 
1732  // Plasma injection parameters
1733  int warpx_do_continuous_injection = 0;
1734  int num_injected_species = -1;
1735  amrex::Vector<int> injected_plasma_species;
1736 
1737  std::optional<amrex::Real> m_const_dt;
1738 
1739  // Macroscopic properties
1740  std::unique_ptr<MacroscopicProperties> m_macroscopic_properties;
1741  // London solver
1742  std::unique_ptr<London> m_london;
1743  // Lumped inductor
1744  std::unique_ptr<Inductor> m_inductor;
1745 
1746 #ifdef WARPX_MAG_LLG
1747  // time advancement scheme of M field
1748  int mag_time_scheme_order = 1;
1749 #endif
1750 
1751  // Load balancing
1754  utils::parser::IntervalsParser load_balance_intervals;
1757  amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > > costs;
1759  int load_balance_with_sfc = 0;
1764  amrex::Real load_balance_knapsack_factor = amrex::Real(1.24);
1770  amrex::Real load_balance_efficiency_ratio_threshold = amrex::Real(1.1);
1772  amrex::Vector<amrex::Real> load_balance_efficiency;
1778  amrex::Real costs_heuristic_cells_wt = amrex::Real(0);
1784  amrex::Real costs_heuristic_particles_wt = amrex::Real(0);
1785 
1786  // Determines timesteps for override sync
1787  utils::parser::IntervalsParser override_sync_intervals;
1788 
1789  // Other runtime parameters
1790  int verbose = 1;
1791 
1792  bool use_hybrid_QED = 0;
1793 
1794  int max_step = std::numeric_limits<int>::max();
1795  amrex::Real stop_time = std::numeric_limits<amrex::Real>::max();
1796 
1797  int regrid_int = -1;
1798 
1799  amrex::Real cfl = amrex::Real(0.999);
1800 
1801  std::string restart_chkfile;
1802 
1803  amrex::VisMF::Header::Version plotfile_headerversion = amrex::VisMF::Header::Version_v1;
1804  amrex::VisMF::Header::Version slice_plotfile_headerversion = amrex::VisMF::Header::Version_v1;
1805 
1806  bool use_single_read = true;
1807  bool use_single_write = true;
1808  int mffile_nstreams = 4;
1809  int field_io_nfiles = 1024;
1810  int particle_io_nfiles = 1024;
1811 
1812  amrex::RealVect fine_tag_lo;
1813  amrex::RealVect fine_tag_hi;
1814 
1815  bool is_synchronized = true;
1816 
1817  // Synchronization of nodal points
1818  const bool sync_nodal_points = true;
1819 
1820  guardCellManager guard_cells;
1821 
1822  //Slice Parameters
1823  int slice_max_grid_size;
1824  int slice_plot_int = -1;
1825  amrex::RealBox slice_realbox;
1826  amrex::IntVect slice_cr_ratio;
1827  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_slice;
1828  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_slice;
1829  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_slice;
1830  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_slice;
1831  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_slice;
1832  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_slice;
1833 
1834  bool fft_periodic_single_box = false;
1835  int nox_fft = 16;
1836  int noy_fft = 16;
1837  int noz_fft = 16;
1838 
1840  amrex::IntVect numprocs{0};
1841 
1843  std::unique_ptr<ParticleBoundaryBuffer> m_particle_boundary_buffer;
1844 
1845  // Accelerator lattice elements
1846  amrex::Vector< std::unique_ptr<AcceleratorLattice> > m_accelerator_lattice;
1847 
1848  //
1849  // Embedded Boundary
1850  //
1851 
1852  // Factory for field data
1853  amrex::Vector<std::unique_ptr<amrex::FabFactory<amrex::FArrayBox> > > m_field_factory;
1854 
1855  amrex::FabFactory<amrex::FArrayBox> const& fieldFactory (int lev) const noexcept {
1856  return *m_field_factory[lev];
1857  }
1858 #ifdef AMREX_USE_EB
1859 public:
1860  amrex::EBFArrayBoxFactory const& fieldEBFactory (int lev) const noexcept {
1861  return static_cast<amrex::EBFArrayBoxFactory const&>(*m_field_factory[lev]);
1862  }
1863 #endif
1864 
1865 public:
1866  void InitEB ();
1872 public:
1873 #ifdef AMREX_USE_EB
1874  static void ComputeEdgeLengths (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,
1875  const amrex::EBFArrayBoxFactory& eb_fact);
1880  static void ComputeFaceAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,
1881  const amrex::EBFArrayBoxFactory& eb_fact);
1882 
1886  static void ScaleEdges (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,
1887  const std::array<amrex::Real,3>& cell_size);
1891  static void ScaleAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,
1892  const std::array<amrex::Real,3>& cell_size);
1901  void MarkCells();
1905 #endif
1906  void ComputeDistanceToEB ();
1910  amrex::Array1D<int, 0, 2> CountExtFaces();
1915  void ComputeFaceExtensions();
1919  void InitBorrowing();
1923  void ShrinkBorrowing();
1927  void ComputeOneWayExtensions();
1931  void ComputeEightWaysExtensions();
1940  void ApplyBCKCorrection(const int idim);
1941 
1946  void PSATDSubtractCurrentPartialSumsAvg ();
1947 
1948 private:
1949  void ScrapeParticles ();
1950 
1951  void PushPSATD ();
1952 
1953 #ifdef WARPX_USE_PSATD
1954 
1967  void PSATDForwardTransformEB (
1968  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_fp,
1969  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_fp,
1970  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_cp,
1971  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_cp);
1972 
1986  void PSATDBackwardTransformEB (
1987  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_fp,
1988  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_fp,
1989  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_cp,
1990  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_cp);
1991 
2004  void PSATDBackwardTransformEBavg (
2005  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_avg_fp,
2006  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_avg_fp,
2007  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_avg_cp,
2008  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_avg_cp);
2009 
2021  void PSATDForwardTransformJ (
2022  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
2023  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
2024  const bool apply_kspace_filter=true);
2025 
2034  void PSATDBackwardTransformJ (
2035  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
2036  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp);
2037 
2049  void PSATDForwardTransformRho (
2050  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
2051  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
2052  const int icomp, const int dcomp, const bool apply_kspace_filter=true);
2053 
2057  void PSATDMoveRhoNewToRhoOld ();
2058 
2062  void PSATDMoveJNewToJOld ();
2063 
2067  void PSATDForwardTransformF ();
2068 
2072  void PSATDBackwardTransformF ();
2073 
2077  void PSATDForwardTransformG ();
2078 
2082  void PSATDBackwardTransformG ();
2083 
2087  void PSATDCurrentCorrection ();
2088 
2092  void PSATDVayDeposition ();
2093 
2097  void PSATDPushSpectralFields ();
2098 
2104  void PSATDScaleAverageFields (const amrex::Real scale_factor);
2105 
2109  void PSATDEraseAverageFields ();
2110 
2111 # ifdef WARPX_DIM_RZ
2112  amrex::Vector<std::unique_ptr<SpectralSolverRZ>> spectral_solver_fp;
2113  amrex::Vector<std::unique_ptr<SpectralSolverRZ>> spectral_solver_cp;
2114 # else
2115  amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_fp;
2116  amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_cp;
2117 # endif
2118 
2119 public:
2120 
2121 # ifdef WARPX_DIM_RZ
2122  SpectralSolverRZ&
2123 # else
2124  SpectralSolver&
2125 # endif
2126  get_spectral_solver_fp (int lev) {return *spectral_solver_fp[lev];}
2127 #endif
2128 
2129 private:
2130  amrex::Vector<std::unique_ptr<FiniteDifferenceSolver>> m_fdtd_solver_fp;
2131  amrex::Vector<std::unique_ptr<FiniteDifferenceSolver>> m_fdtd_solver_cp;
2132 
2133 };
2134 
2135 #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
FiniteDifferenceSolver_fwd.H
MacroscopicProperties_fwd.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:74
DtType
DtType
Definition: WarpXDtType.H:11
WarpXFaceInfoBox_fwd.H
WarpXParticleContainer_fwd.H
AcceleratorLattice
Definition: AcceleratorLattice.H:21
BilinearFilter
Definition: BilinearFilter.H:17
ElectrostaticSolver::PoissonBoundaryHandler
Definition: ElectrostaticSolver.H:35
Inductor
Definition: Inductor.H:21
London
Definition: London.H:22
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:81
WarpX::Bfield_avg_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_aux
Definition: WarpX.H:1599
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:1240
WarpX::m_particle_boundary_buffer
std::unique_ptr< ParticleBoundaryBuffer > m_particle_boundary_buffer
particle buffer for scraped particles on the boundaries
Definition: WarpX.H:1843
WarpX::self_fields_max_iters
static int self_fields_max_iters
Definition: WarpX.H:1101
WarpX::PSATDMoveRhoNewToRhoOld
void PSATDMoveRhoNewToRhoOld()
Copy rho_new to rho_old in spectral space (when rho is linear in time)
Definition: WarpXPushFieldsEM.cpp:560
WarpX::getrho_fp
const amrex::MultiFab & getrho_fp(int lev)
Definition: WarpX.H:699
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:392
WarpX::costs
amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > > costs
Definition: WarpX.H:1757
WarpX::current_deposition_algo
static short current_deposition_algo
Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay)
Definition: WarpX.H:280
WarpX::Bzfield_flag_parser
std::unique_ptr< amrex::Parser > Bzfield_flag_parser
Definition: WarpX.H:253
WarpX::G_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_fp
Definition: WarpX.H:1603
WarpX::device_field_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_y
Definition: WarpX.H:1299
WarpX::moving_window_dir
static int moving_window_dir
Definition: WarpX.H:1117
WarpX::device_current_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_x
Definition: WarpX.H:1303
WarpX::Eyfield_flag_parser
std::unique_ptr< amrex::Parser > Eyfield_flag_parser
Definition: WarpX.H:249
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:3145
WarpX::str_Bx_excitation_flag_function
static std::string str_Bx_excitation_flag_function
Definition: WarpX.H:189
WarpX::use_hybrid_QED
bool use_hybrid_QED
Definition: WarpX.H:1792
WarpX::do_dive_cleaning
static bool do_dive_cleaning
Definition: WarpX.H:380
WarpX::zmax_plasma_to_compute_max_step
static amrex::Real zmax_plasma_to_compute_max_step
Definition: WarpX.H:450
WarpX::doFieldIonization
void doFieldIonization()
Definition: WarpXEvolve.cpp:1019
WarpX::get_pointer_edge_lengths
amrex::MultiFab * get_pointer_edge_lengths(int lev, int direction) const
Definition: WarpX.H:667
WarpX::str_Bz_excitation_grid_function
static std::string str_Bz_excitation_grid_function
Definition: WarpX.H:170
WarpX::get_ng_fieldgather
const amrex::IntVect get_ng_fieldgather() const
Definition: WarpX.H:1137
WarpX::str_By_excitation_flag_function
static std::string str_By_excitation_flag_function
Definition: WarpX.H:190
WarpX::get_pointer_Efield_fp
amrex::MultiFab * get_pointer_Efield_fp(int lev, int direction) const
Definition: WarpX.H:636
WarpX::getEfield_fp
const amrex::MultiFab & getEfield_fp(int lev, int direction)
Definition: WarpX.H:690
WarpX::getngEB
const amrex::IntVect getngEB() const
Definition: WarpX.H:1132
WarpX::Version
static std::string Version()
Version of WarpX executable.
Definition: WarpXVersion.cpp:14
WarpX::getnsubsteps
amrex::Vector< int > getnsubsteps() const
Definition: WarpX.H:1039
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:474
WarpX::m_macroscopic_properties
std::unique_ptr< MacroscopicProperties > m_macroscopic_properties
Definition: WarpX.H:1740
WarpX::GetMultiDiags
MultiDiagnostics & GetMultiDiags()
Definition: WarpX.H:105
WarpX::DoPML
bool DoPML() const
Definition: WarpX.H:709
WarpX::getcurrent_cp
const amrex::MultiFab & getcurrent_cp(int lev, int direction)
Definition: WarpX.H:677
WarpX::rho_in_time
static short rho_in_time
Definition: WarpX.H:332
WarpX::UpdateAuxilaryDataSameType
void UpdateAuxilaryDataSameType()
Definition: WarpXComm.cpp:274
WarpX::PostProcessBaseGrids
virtual void PostProcessBaseGrids(amrex::BoxArray &ba0) const final
Definition: WarpXInitData.cpp:85
WarpX::pml_delta
int pml_delta
Definition: WarpX.H:1714
WarpX::m_field_factory
amrex::Vector< std::unique_ptr< amrex::FabFactory< amrex::FArrayBox > > > m_field_factory
Definition: WarpX.H:1853
WarpX::getis_synchronized
bool getis_synchronized() const
Definition: WarpX.H:1054
WarpX::do_pml_j_damping
int do_pml_j_damping
Definition: WarpX.H:1716
WarpX::noy_fft
int noy_fft
Definition: WarpX.H:1836
WarpX::current_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_cp
Definition: WarpX.H:1684
WarpX::m_distance_to_eb
amrex::Vector< std::unique_ptr< amrex::MultiFab > > m_distance_to_eb
Definition: WarpX.H:1672
WarpX::Efield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_slice
Definition: WarpX.H:1831
WarpX::Bfield_sc_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_sc_fp
Definition: WarpX.H:1619
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::Efield_avg_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_aux
Definition: WarpX.H:1598
WarpX::NodalSyncPML
void NodalSyncPML()
Synchronize the nodal points of the PML MultiFabs.
Definition: WarpXComm.cpp:1485
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:161
WarpX::ComputeFaceExtensions
void ComputeFaceExtensions()
Main function computing the cell extension. Where possible it computes one-way extensions and,...
Definition: WarpXFaceExtensions.cpp:183
WarpX::CheckSignals
static void CheckSignals()
Check and clear signal flags and asynchronously broadcast them from process 0.
Definition: WarpXEvolve.cpp:1198
WarpX::m_v_galilean
amrex::Vector< amrex::Real > m_v_galilean
Definition: WarpX.H:748
WarpX::DampJPML
void DampJPML()
Definition: WarpXEvolvePML.cpp:254
WarpX::psatd_solution_type
static short psatd_solution_type
Definition: WarpX.H:327
WarpX::ResetProbDomain
void ResetProbDomain(const amrex::RealBox &rb)
Definition: WarpXMovingWindow.cpp:579
WarpX::gather_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > gather_buffer_masks
Definition: WarpX.H:1704
WarpX::updateStopTime
void updateStopTime(const amrex::Real new_stop_time)
Definition: WarpX.H:1059
WarpX::get_array_Efield_aux
std::array< const amrex::MultiFab *const, 3 > get_array_Efield_aux(const int lev) const
Definition: WarpX.H:595
WarpX::mirror_z_npoints
amrex::Vector< int > mirror_z_npoints
Definition: WarpX.H:756
WarpX::zmin_domain_boost_step_0
static amrex::Real zmin_domain_boost_step_0
Definition: WarpX.H:457
WarpX::current_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_slice
Definition: WarpX.H:1830
WarpX::GatherBufferMasks
static const amrex::iMultiFab * GatherBufferMasks(int lev)
Definition: WarpX.cpp:3329
WarpX::do_compute_max_step_from_zmax
static bool do_compute_max_step_from_zmax
Definition: WarpX.H:454
WarpX::field_boundary_lo
static amrex::Vector< int > field_boundary_lo
Definition: WarpX.H:303
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:469
WarpX::get_spectral_solver_fp
SpectralSolverRZ & get_spectral_solver_fp(int lev)
Definition: WarpX.H:2126
WarpX::Ezfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Ezfield_xt_grid_parser
Definition: WarpX.H:237
WarpX::n_field_gather_buffer
static int n_field_gather_buffer
Definition: WarpX.H:483
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:357
WarpX::do_multi_J_n_depositions
static int do_multi_J_n_depositions
Definition: WarpX.H:475
WarpX::current_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_nodal
Definition: WarpX.H:1678
WarpX::MacroscopicEvolveE
void MacroscopicEvolveE(amrex::Real dt)
Definition: WarpXPushFieldsEM.cpp:1059
WarpX::t_new
amrex::Vector< amrex::Real > t_new
Definition: WarpX.H:1578
WarpX::do_single_precision_comms
static bool do_single_precision_comms
perform field communications in single precision
Definition: WarpX.H:358
WarpX::slice_cr_ratio
amrex::IntVect slice_cr_ratio
Definition: WarpX.H:1826
WarpX::SyncCurrentAndRho
void SyncCurrentAndRho()
Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels....
Definition: WarpXEvolve.cpp:604
WarpX::field_io_nfiles
int field_io_nfiles
Definition: WarpX.H:1809
WarpX::particle_boundary_lo
static amrex::Vector< ParticleBoundaryType > particle_boundary_lo
Definition: WarpX.H:313
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:122
WarpX::Exfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Exfield_xt_grid_parser
Definition: WarpX.H:235
WarpX::current_store
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_store
Definition: WarpX.H:1675
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:1820
WarpX::do_shared_mem_charge_deposition
static bool do_shared_mem_charge_deposition
used shared memory algorithm for charge deposition
Definition: WarpX.H:361
WarpX::slice_plotfile_headerversion
amrex::VisMF::Header::Version slice_plotfile_headerversion
Definition: WarpX.H:1804
WarpX::em_solver_medium
static int em_solver_medium
Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1)
Definition: WarpX.H:294
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:568
WarpX::stop_time
amrex::Real stop_time
Definition: WarpX.H:1795
WarpX::GetPartContainer
MultiParticleContainer & GetPartContainer()
Definition: WarpX.H:101
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:446
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:415
WarpX::verboncoeur_axis_correction
static bool verboncoeur_axis_correction
Definition: WarpX.H:429
WarpX::moving_window_v
static amrex::Real moving_window_v
Definition: WarpX.H:1118
WarpX::do_shared_mem_current_deposition
static bool do_shared_mem_current_deposition
use shared memory algorithm for current deposition
Definition: WarpX.H:364
WarpX::do_pml_Hi
amrex::Vector< amrex::IntVect > do_pml_Hi
Definition: WarpX.H:1722
WarpX::setistep
void setistep(int lev, int ii)
Definition: WarpX.H:1043
WarpX::get_pointer_vector_potential_fp
amrex::MultiFab * get_pointer_vector_potential_fp(int lev, int direction) const
Definition: WarpX.H:653
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:3186
WarpX::fft_do_time_averaging
static bool fft_do_time_averaging
Definition: WarpX.H:1119
WarpX::EvolveF
void EvolveF(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:965
WarpX::particle_pusher_algo
static short particle_pusher_algo
Integer that corresponds to the particle push algorithm (Boris, Vay, Higuera-Cary)
Definition: WarpX.H:286
WarpX::ClearLevel
virtual void ClearLevel(int lev) final
Delete level data. Called by AmrCore::regrid.
Definition: WarpX.cpp:1991
WarpX::pml
amrex::Vector< std::unique_ptr< PML > > pml
Definition: WarpX.H:1723
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:1812
WarpX::m_inductor
std::unique_ptr< Inductor > m_inductor
Definition: WarpX.H:1744
WarpX::restart_chkfile
std::string restart_chkfile
Definition: WarpX.H:1801
WarpX::m_instance
static WarpX * m_instance
Definition: WarpX.H:1371
WarpX::getG_fp
const amrex::MultiFab & getG_fp(int lev)
Definition: WarpX.H:702
WarpX::rho_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_cp
Definition: WarpX.H:1683
WarpX::get_pointer_G_fp
amrex::MultiFab * get_pointer_G_fp(int lev) const
Definition: WarpX.H:651
WarpX::getRealBox
static amrex::RealBox getRealBox(const amrex::Box &bx, int lev)
Definition: WarpX.cpp:2938
WarpX::do_dynamic_scheduling
static bool do_dynamic_scheduling
Definition: WarpX.H:462
WarpX::PostRestart
void PostRestart()
WarpX::ApplyExcitationInPML
static int ApplyExcitationInPML
Definition: WarpX.H:148
WarpX::getBfield_cp
const amrex::MultiFab & getBfield_cp(int lev, int direction)
Definition: WarpX.H:679
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:3251
WarpX::InitFromCheckpoint
void InitFromCheckpoint()
Definition: WarpXIO.cpp:94
WarpX::str_Ez_excitation_grid_function
static std::string str_Ez_excitation_grid_function
Definition: WarpX.H:174
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:1160
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:1111
WarpX::CellSize
static std::array< amrex::Real, 3 > CellSize(int lev)
Definition: WarpX.cpp:2924
WarpX::E_ext_grid_s
static std::string E_ext_grid_s
Initialization type for external electric field on the grid.
Definition: WarpX.H:133
WarpX::device_field_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_z
Definition: WarpX.H:1300
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:3264
WarpX::get_pointer_phi_fp
amrex::MultiFab * get_pointer_phi_fp(int lev) const
Definition: WarpX.H:652
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:1102
WarpX::stopTime
amrex::Real stopTime() const
Definition: WarpX.H:1058
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:219
WarpX::pml_rz
amrex::Vector< std::unique_ptr< PML_RZ > > pml_rz
Definition: WarpX.H:1725
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:147
WarpX::getphi_fp
const amrex::MultiFab & getphi_fp(int lev)
Definition: WarpX.H:700
WarpX::m_v_comoving
amrex::Vector< amrex::Real > m_v_comoving
Definition: WarpX.H:751
WarpX::InitData
void InitData()
WarpX::multifab_map
static std::map< std::string, amrex::MultiFab * > multifab_map
Definition: WarpX.H:563
WarpX::RestoreCurrent
void RestoreCurrent(const int lev)
Definition: WarpX.cpp:3346
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:749
WarpX::use_lumped_inductor
static int use_lumped_inductor
Definition: WarpX.H:322
WarpX::device_field_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_x
Definition: WarpX.H:1298
WarpX::get_pointer_current_fp
amrex::MultiFab * get_pointer_current_fp(int lev, int direction) const
Definition: WarpX.H:647
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:1136
WarpX::get_pointer_current_cp
amrex::MultiFab * get_pointer_current_cp(int lev, int direction) const
Definition: WarpX.H:662
WarpX::str_Bx_excitation_grid_function
static std::string str_Bx_excitation_grid_function
Definition: WarpX.H:168
WarpX::getdt
amrex::Vector< amrex::Real > getdt() const
Definition: WarpX.H:1049
WarpX::noz
static int noz
Order of the particle shape factors (splines) along z.
Definition: WarpX.H:389
WarpX::E_excitation_grid_s
static std::string E_excitation_grid_s
Definition: WarpX.H:137
WarpX::device_current_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_z
Definition: WarpX.H:1305
WarpX::gett_new
amrex::Vector< amrex::Real > gett_new() const
Definition: WarpX.H:1046
WarpX::getBfield_avg_cp
const amrex::MultiFab & getBfield_avg_cp(int lev, int direction)
Definition: WarpX.H:707
WarpX::mffile_nstreams
int mffile_nstreams
Definition: WarpX.H:1808
WarpX::num_mirrors
static int num_mirrors
Definition: WarpX.H:753
WarpX::getPMLdirections
std::vector< bool > getPMLdirections() const
Definition: WarpX.cpp:3115
WarpX::str_Ex_excitation_flag_function
static std::string str_Ex_excitation_flag_function
Definition: WarpX.H:186
WarpX::get_pointer_face_areas
amrex::MultiFab * get_pointer_face_areas(int lev, int direction) const
Definition: WarpX.H:668
WarpX::phi_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > phi_fp
Definition: WarpX.H:1605
WarpX::AddMagnetostaticFieldLabFrame
void AddMagnetostaticFieldLabFrame()
Definition: MagnetostaticSolver.cpp:71
WarpX::GetParticleBoundaryBuffer
ParticleBoundaryBuffer & GetParticleBoundaryBuffer()
Definition: WarpX.H:107
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:412
WarpX::getPEC_fp
const amrex::MultiFab & getPEC_fp(int lev, int direction)
Definition: WarpX.H:691
WarpX::do_pml_divb_cleaning
bool do_pml_divb_cleaning
Definition: WarpX.H:1720
WarpX::getistep
amrex::Vector< int > getistep() const
Definition: WarpX.H:1041
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:401
WarpX::str_By_excitation_grid_function
static std::string str_By_excitation_grid_function
Definition: WarpX.H:169
WarpX::ReadParameters
void ReadParameters()
Definition: WarpX.cpp:588
WarpX::ResetInstance
static void ResetInstance()
Definition: WarpX.cpp:318
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:572
WarpX::verbose
int verbose
Definition: WarpX.H:1790
WarpX::device_current_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_y
Definition: WarpX.H:1304
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:150
WarpX::get_pointer_Efield_aux
amrex::MultiFab * get_pointer_Efield_aux(int lev, int direction) const
Definition: WarpX.H:629
WarpX::InitDiagnostics
void InitDiagnostics()
WarpX::MoveWindow
int MoveWindow(const int step, bool move_j)
Move the moving window.
Definition: WarpXMovingWindow.cpp:82
WarpX::Efield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_cp
Definition: WarpX.H:1692
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:685
WarpX::load_balance_knapsack_factor
amrex::Real load_balance_knapsack_factor
Definition: WarpX.H:1764
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:1772
WarpX::self_fields_required_precision
static amrex::Real self_fields_required_precision
Definition: WarpX.H:1099
WarpX::sort_bin_size
static amrex::IntVect sort_bin_size
Definition: WarpX.H:466
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:155
WarpX::m_rho_nodal_flag
amrex::IntVect m_rho_nodal_flag
Definition: WarpX.H:494
WarpX::imultifab_map
static std::map< std::string, amrex::iMultiFab * > imultifab_map
Definition: WarpX.H:564
WarpX::load_balance_intervals
utils::parser::IntervalsParser load_balance_intervals
Definition: WarpX.H:1754
WarpX::m_flag_ext_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > > m_flag_ext_face
Definition: WarpX.H:1648
WarpX::current_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp
Definition: WarpX.H:1606
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:2946
WarpX::override_sync_intervals
utils::parser::IntervalsParser override_sync_intervals
Definition: WarpX.H:1787
WarpX::EvolveB
void EvolveB(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:833
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:217
WarpX::getLondon
London & getLondon()
Definition: WarpX.H:103
WarpX::isAnyBoundaryPML
bool isAnyBoundaryPML()
Definition: WarpX.cpp:3356
WarpX::get_load_balance_intervals
utils::parser::IntervalsParser get_load_balance_intervals() const
returns the load balance interval
Definition: WarpX.H:860
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:369
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:1633
WarpX::gett_old
amrex::Real gett_old(int lev) const
Definition: WarpX.H:1045
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:223
WarpX::Bfield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cax
Definition: WarpX.H:1697
WarpX::PEC_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > PEC_fp
Definition: WarpX.H:1609
WarpX::get_pointer_F_cp
amrex::MultiFab * get_pointer_F_cp(int lev) const
Definition: WarpX.H:664
WarpX::get_pointer_Bfield_sc_fp
amrex::MultiFab * get_pointer_Bfield_sc_fp(int lev, int direction) const
Definition: WarpX.H:639
WarpX::getF_fp
const amrex::MultiFab & getF_fp(int lev)
Definition: WarpX.H:701
WarpX::Exfield_flag_parser
std::unique_ptr< amrex::Parser > Exfield_flag_parser
Definition: WarpX.H:248
WarpX::StoreCurrent
void StoreCurrent(const int lev)
Definition: WarpX.cpp:3335
WarpX::do_moving_window
static int do_moving_window
Definition: WarpX.H:1104
WarpX::MakeNewLevelFromCoarse
virtual void MakeNewLevelFromCoarse(int, amrex::Real, const amrex::BoxArray &, const amrex::DistributionMapping &) final
Definition: WarpX.cpp:1984
WarpX::moving_window_x
amrex::Real moving_window_x
Definition: WarpX.H:1729
WarpX::get_pointer_Efield_cp
amrex::MultiFab * get_pointer_Efield_cp(int lev, int direction) const
Definition: WarpX.H:655
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:157
WarpX::maxStep
int maxStep() const
Definition: WarpX.H:1056
WarpX::nox
static int nox
Order of the particle shape factors (splines) along x.
Definition: WarpX.H:385
WarpX::getnsubsteps
int getnsubsteps(int lev) const
Definition: WarpX.H:1040
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 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:3366
WarpX::quantum_xi_c2
static amrex::Real quantum_xi_c2
Definition: WarpX.H:849
WarpX::getngF
const amrex::IntVect getngF() const
Definition: WarpX.H:1133
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:3208
WarpX::AllocLevelData
void AllocLevelData(int lev, const amrex::BoxArray &new_grids, const amrex::DistributionMapping &new_dmap)
Definition: WarpX.cpp:2073
WarpX::Bfield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_slice
Definition: WarpX.H:1832
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:1641
WarpX::current_fp_vay
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_vay
Definition: WarpX.H:1607
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:582
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 int lev, const int icomp, const int ncomp)
Definition: WarpXComm.cpp:1357
WarpX::updateMaxStep
void updateMaxStep(const int new_max_step)
Definition: WarpX.H:1057
WarpX::PSATDMoveJNewToJOld
void PSATDMoveJNewToJOld()
Copy J_new to J_old in spectral space (when J is linear in time)
Definition: WarpXPushFieldsEM.cpp:576
WarpX::Bfield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cp
Definition: WarpX.H:1686
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:439
WarpX::getGatherBufferMasks
const amrex::iMultiFab * getGatherBufferMasks(int lev) const
Definition: WarpX.H:1517
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:221
WarpX::doQEDEvents
void doQEDEvents()
Definition: WarpXEvolve.cpp:1036
WarpX::spectral_solver_fp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_fp
Definition: WarpX.H:2112
WarpX::use_PEC_mask
static int use_PEC_mask
Definition: WarpX.H:321
WarpX::ApplyInverseVolumeScalingToChargeDensity
void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab *Rho, int lev)
Definition: WarpXPushFieldsEM.cpp:1561
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:373
WarpX::CopyJPML
void CopyJPML()
Copy the current J from the regular grid to the PML.
Definition: WarpXEvolvePML.cpp:374
WarpX::grid_type
static short grid_type
Definition: WarpX.H:491
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:1624
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:1437
WarpX::Efield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_aux
Definition: WarpX.H:1591
WarpX::getEfield_cp
const amrex::MultiFab & getEfield_cp(int lev, int direction)
Definition: WarpX.H:678
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:399
WarpX::get_pointer_Bfield_aux
amrex::MultiFab * get_pointer_Bfield_aux(int lev, int direction) const
Definition: WarpX.H:630
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:436
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:1623
WarpX::m_borrowing
amrex::Vector< std::array< std::unique_ptr< amrex::LayoutData< FaceInfoBox > >, 3 > > m_borrowing
Definition: WarpX.H:1656
WarpX::PSATDPushSpectralFields
void PSATDPushSpectralFields()
Update all necessary fields in spectral space.
Definition: WarpXPushFieldsEM.cpp:546
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:152
WarpX::charge_deposition_algo
static short charge_deposition_algo
Integer that corresponds to the charge deposition algorithm (only standard deposition)
Definition: WarpX.H:282
WarpX::PushParticlesandDepose
void PushParticlesandDepose(int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false)
Definition: WarpXEvolve.cpp:1063
WarpX::cfl
amrex::Real cfl
Definition: WarpX.H:1799
WarpX::str_Ey_excitation_flag_function
static std::string str_Ey_excitation_flag_function
Definition: WarpX.H:187
WarpX::str_Ez_excitation_flag_function
static std::string str_Ez_excitation_flag_function
Definition: WarpX.H:188
WarpX::gett_new
amrex::Real gett_new(int lev) const
Definition: WarpX.H:1047
WarpX::dt
amrex::Vector< amrex::Real > dt
Definition: WarpX.H:1580
WarpX::rho_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_slice
Definition: WarpX.H:1829
WarpX::F_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_cp
Definition: WarpX.H:1681
WarpX::Bzfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Bzfield_xt_grid_parser
Definition: WarpX.H:233
WarpX::nox_fft
int nox_fft
Definition: WarpX.H:1835
WarpX::UpdateAuxilaryData
void UpdateAuxilaryData()
Definition: WarpXComm.cpp:53
WarpX::particle_io_nfiles
int particle_io_nfiles
Definition: WarpX.H:1810
WarpX::is_synchronized
bool is_synchronized
Definition: WarpX.H:1815
WarpX::current_injection_position
amrex::Real current_injection_position
Definition: WarpX.H:1730
WarpX::GetInstance
static WarpX & GetInstance()
Definition: WarpX.cpp:309
WarpX::getcurrent_injection_position
amrex::Real getcurrent_injection_position() const
Definition: WarpX.H:1053
WarpX::ApplyExternalFieldExcitationOnGrid
void ApplyExternalFieldExcitationOnGrid(int const externalfieldtype, DtType a_dt_type=DtType::Full)
Adds the contribution of user-defined external field-excitation to Efield, Bfield,...
Definition: WarpXExternalEMFields.cpp:22
WarpX::fine_tag_hi
amrex::RealVect fine_tag_hi
Definition: WarpX.H:1813
WarpX::getBfield_sc_fp
const amrex::MultiFab & getBfield_sc_fp(int lev, int direction)
Definition: WarpX.H:693
WarpX::start_moving_window_step
static int start_moving_window_step
Definition: WarpX.H:1105
WarpX::getInductor
Inductor & getInductor()
Definition: WarpX.H:104
WarpX::GetPML_RZ
PML_RZ * GetPML_RZ(int lev)
Definition: WarpX.cpp:3092
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:1712
WarpX::setPhiBC
void setPhiBC(amrex::Vector< std::unique_ptr< amrex::MultiFab > > &phi) const
Definition: ElectrostaticSolver.cpp:369
WarpX::istep
amrex::Vector< int > istep
Definition: WarpX.H:1575
WarpX::electrostatic_solver_id
static int electrostatic_solver_id
Definition: WarpX.H:1096
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::str_Ex_excitation_grid_function
static std::string str_Ex_excitation_grid_function
Definition: WarpX.H:172
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:1299
WarpX::get_accelerator_lattice
const AcceleratorLattice & get_accelerator_lattice(int lev)
Definition: WarpX.H:1312
WarpX::HandleSignals
void HandleSignals()
Complete the asynchronous broadcast of signal flags, and initiate a checkpoint if requested.
Definition: WarpXEvolve.cpp:1204
WarpX::G_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_slice
Definition: WarpX.H:1828
WarpX::n_current_deposition_buffer
static int n_current_deposition_buffer
Definition: WarpX.H:487
WarpX::AliasInitMultiFab
static void AliasInitMultiFab(std::unique_ptr< amrex::MultiFab > &mf, const amrex::MultiFab &mf_to_alias, const int scomp, const int ncomp, const std::string &name, std::optional< const amrex::Real > initial_value)
Create an alias of a MultiFab, adding the alias to the MultiFab map.
Definition: WarpX.cpp:3402
WarpX::Bxfield_flag_parser
std::unique_ptr< amrex::Parser > Bxfield_flag_parser
Definition: WarpX.H:251
WarpX::F_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_fp
Definition: WarpX.H:1602
WarpX::get_pointer_PEC_fp
amrex::MultiFab * get_pointer_PEC_fp(int lev, int direction) const
Definition: WarpX.H:637
WarpX::field_boundary_hi
static amrex::Vector< int > field_boundary_hi
Definition: WarpX.H:308
WarpX::UpdateAuxilaryDataStagToNodal
void UpdateAuxilaryDataStagToNodal()
Definition: WarpXComm.cpp:65
WarpX::Byfield_flag_parser
std::unique_ptr< amrex::Parser > Byfield_flag_parser
Definition: WarpX.H:252
WarpX::Verbose
int Verbose() const
Definition: WarpX.H:95
WarpX::Efield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cax
Definition: WarpX.H:1696
WarpX::Eyfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Eyfield_xt_grid_parser
Definition: WarpX.H:236
WarpX::charge_buf
amrex::Vector< std::unique_ptr< amrex::MultiFab > > charge_buf
Definition: WarpX.H:1708
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:587
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:1631
WarpX::getCurrentBufferMasks
const amrex::iMultiFab * getCurrentBufferMasks(int lev) const
Definition: WarpX.H:1514
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:528
WarpX::Efield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_avg_fp
Definition: WarpX.H:1616
WarpX::injected_plasma_species
amrex::Vector< int > injected_plasma_species
Definition: WarpX.H:1735
WarpX::do_device_synchronize
static bool do_device_synchronize
Definition: WarpX.H:477
WarpX::Evolve
void Evolve(int numsteps=-1)
Definition: WarpXEvolve.cpp:62
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:434
WarpX::get_pointer_F_fp
amrex::MultiFab * get_pointer_F_fp(int lev) const
Definition: WarpX.H:650
WarpX::InitNCICorrector
void InitNCICorrector()
WarpX::getistep
int getistep(int lev) const
Definition: WarpX.H:1042
WarpX::multi_diags
std::unique_ptr< MultiDiagnostics > multi_diags
Definition: WarpX.H:1584
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:227
WarpX::noy
static int noy
Order of the particle shape factors (splines) along y.
Definition: WarpX.H:387
WarpX::EvolveEM
void EvolveEM(int numsteps)
WarpX::nsubsteps
amrex::Vector< int > nsubsteps
Definition: WarpX.H:1576
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 int lev)
Definition: WarpXComm.cpp:1222
WarpX::ComputeMaxStep
void ComputeMaxStep()
Compute the last time step of the simulation Calls computeMaxStepBoostAccelerator() if required.
WarpX::SyncRho
void SyncRho()
Definition: WarpXComm.cpp:1076
WarpX::noz_fft
int noz_fft
Definition: WarpX.H:1837
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:1133
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:396
WarpX::EvolveBLondon
void EvolveBLondon(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:794
WarpX::sett_new
void sett_new(int lev, amrex::Real time)
Definition: WarpX.H:1048
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:677
WarpX::load_balance_efficiency_ratio_threshold
amrex::Real load_balance_efficiency_ratio_threshold
Definition: WarpX.H:1770
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:444
WarpX::FillBoundaryAux
void FillBoundaryAux(amrex::IntVect ng)
Definition: WarpXComm.cpp:1002
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:720
WarpX::Efield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp_external
Definition: WarpX.H:1627
WarpX::ComputeDivE
void ComputeDivE(amrex::MultiFab &divE, const int lev)
Definition: WarpX.cpp:3076
WarpX::get_pointer_G_cp
amrex::MultiFab * get_pointer_G_cp(int lev) const
Definition: WarpX.H:665
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:382
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:1461
WarpX::WarpX
WarpX()
Definition: WarpX.cpp:324
WarpX::get_ng_depos_J
const amrex::IntVect get_ng_depos_J() const
Definition: WarpX.H:1135
WarpX::load_balance_with_sfc
int load_balance_with_sfc
Definition: WarpX.H:1759
WarpX::getLoadBalanceEfficiency
amrex::Real getLoadBalanceEfficiency(const int lev)
Definition: WarpX.H:731
WarpX::mypc
std::unique_ptr< MultiParticleContainer > mypc
Definition: WarpX.H:1583
WarpX::current_buf
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_buf
Definition: WarpX.H:1707
WarpX::use_filter
static bool use_filter
If true, a bilinear filter is used to smooth charge and currents.
Definition: WarpX.H:432
WarpX::get_pointer_rho_fp
amrex::MultiFab * get_pointer_rho_fp(int lev) const
Definition: WarpX.H:649
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:376
WarpX::GetMacroscopicProperties
MacroscopicProperties & GetMacroscopicProperties()
Definition: WarpX.H:102
WarpX::m_vector_poisson_boundary_handler
MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler
Definition: WarpX.H:1173
WarpX::getG_cp
const amrex::MultiFab & getG_cp(int lev)
Definition: WarpX.H:687
WarpX::vector_potential_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > vector_potential_fp_nodal
Definition: WarpX.H:1622
WarpX::m_poisson_boundary_handler
ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler
Definition: WarpX.H:1148
WarpX::shared_tilesize
static amrex::IntVect shared_tilesize
tileSize to use for shared current deposition operations
Definition: WarpX.H:370
WarpX::do_similar_dm_pml
static int do_similar_dm_pml
Definition: WarpX.H:1718
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:163
WarpX::ReadExcitationParser
void ReadExcitationParser()
Definition: WarpXExternalEMFields.cpp:222
WarpX::m_fdtd_solver_fp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_fp
Definition: WarpX.H:2130
WarpX::ApplyInverseVolumeScalingToCurrentDensity
void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab *Jx, amrex::MultiFab *Jy, amrex::MultiFab *Jz, int lev)
Definition: WarpXPushFieldsEM.cpp:1388
WarpX::gett_old
amrex::Vector< amrex::Real > gett_old() const
Definition: WarpX.H:1044
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:403
WarpX::safe_guard_cells
static bool safe_guard_cells
Definition: WarpX.H:478
WarpX::str_Ey_excitation_grid_function
static std::string str_Ey_excitation_grid_function
Definition: WarpX.H:173
WarpX::PSATDScaleAverageFields
void PSATDScaleAverageFields(const amrex::Real scale_factor)
Scale averaged E,B fields to account for time integration.
Definition: WarpXPushFieldsEM.cpp:622
WarpX::Efield_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cp
Definition: WarpX.H:1685
WarpX::rho_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_fp
Definition: WarpX.H:1604
WarpX::slice_plot_int
int slice_plot_int
Definition: WarpX.H:1824
WarpX::get_pointer_rho_cp
amrex::MultiFab * get_pointer_rho_cp(int lev) const
Definition: WarpX.H:663
WarpX::InitEB
void InitEB()
Definition: WarpXInitEB.cpp:81
WarpX::BackwardCompatibility
void BackwardCompatibility()
Definition: WarpX.cpp:1733
WarpX::Bfield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp
Definition: WarpX.H:1610
WarpX::ECTRhofield
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > ECTRhofield
Definition: WarpX.H:1665
WarpX::ApplyEfieldBoundary
void ApplyEfieldBoundary(const int lev, PatchType patch_type)
Definition: WarpXFieldBoundaries.cpp:20
WarpX::num_injected_species
int num_injected_species
Definition: WarpX.H:1734
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:2834
WarpX::t_old
amrex::Vector< amrex::Real > t_old
Definition: WarpX.H:1579
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:471
WarpX::regrid_int
int regrid_int
Definition: WarpX.H:1797
WarpX::use_single_write
bool use_single_write
Definition: WarpX.H:1807
WarpX::refine_plasma
static bool refine_plasma
Definition: WarpX.H:463
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)
Apply filter and sum guard cells across MR levels. If current centering is used, center the current f...
Definition: WarpXComm.cpp:1028
WarpX::fieldFactory
amrex::FabFactory< amrex::FArrayBox > const & fieldFactory(int lev) const noexcept
Definition: WarpX.H:1855
WarpX::macroscopic_solver_algo
static int macroscopic_solver_algo
Definition: WarpX.H:298
WarpX::use_single_read
bool use_single_read
Definition: WarpX.H:1806
WarpX::Bfield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_aux
Definition: WarpX.H:1592
WarpX::numprocs
amrex::IntVect numprocs
Domain decomposition on Level 0.
Definition: WarpX.H:1840
WarpX::ncomps
static int ncomps
Definition: WarpX.H:411
WarpX::yee_coupled_solver_algo
static int yee_coupled_solver_algo
Definition: WarpX.H:319
WarpX::moving_window_active
static int moving_window_active(int const step)
Definition: WarpX.H:1112
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:1818
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:1134
WarpX::FillBoundaryJ
void FillBoundaryJ(amrex::IntVect ng)
Definition: WarpXComm.cpp:530
WarpX::warpx_do_continuous_injection
int warpx_do_continuous_injection
Definition: WarpX.H:1733
WarpX::galerkin_interpolation
static bool galerkin_interpolation
Definition: WarpX.H:425
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:165
WarpX::do_pml_in_domain
int do_pml_in_domain
Definition: WarpX.H:1717
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:745
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:1652
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:2153
WarpX::PrintDtDxDyDz
void PrintDtDxDyDz()
Definition: WarpXComputeDt.cpp:92
WarpX::MakeNewLevelFromScratch
virtual void MakeNewLevelFromScratch(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final
Definition: WarpX.cpp:1975
WarpX::filter_npass_each_dir
static amrex::IntVect filter_npass_each_dir
Definition: WarpX.H:742
WarpX::getBfield_fp
const amrex::MultiFab & getBfield_fp(int lev, int direction)
Definition: WarpX.H:692
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:1669
WarpX::setLoadBalanceEfficiency
void setLoadBalanceEfficiency(const int lev, const amrex::Real efficiency)
Definition: WarpX.H:720
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:288
WarpX::InitPML
void InitPML()
WarpX::GetPML
PML * GetPML(int lev)
Definition: WarpX.cpp:3104
WarpX::Bxfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Bxfield_xt_grid_parser
Definition: WarpX.H:231
WarpX::v_particle_pml
amrex::Real v_particle_pml
Definition: WarpX.H:1727
WarpX::OneStep_sub1
void OneStep_sub1(amrex::Real t)
Definition: WarpXEvolve.cpp:860
WarpX::m_london
std::unique_ptr< London > m_london
Definition: WarpX.H:1742
WarpX::bilinear_filter
BilinearFilter bilinear_filter
Definition: WarpX.H:743
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:648
WarpX::fft_periodic_single_box
bool fft_periodic_single_box
Definition: WarpX.H:1834
WarpX::getEfield_avg_fp
const amrex::MultiFab & getEfield_avg_fp(int lev, int direction)
Definition: WarpX.H:704
WarpX::Bfield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_fp
Definition: WarpX.H:1617
WarpX::getBfield_avg_fp
const amrex::MultiFab & getBfield_avg_fp(int lev, int direction)
Definition: WarpX.H:705
WarpX::getCosts
static amrex::LayoutData< amrex::Real > * getCosts(int lev)
Definition: WarpX.cpp:3133
WarpX::PushPSATD
void PushPSATD()
Definition: WarpXPushFieldsEM.cpp:649
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:394
WarpX::do_pml
int do_pml
Definition: WarpX.H:1711
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:159
WarpX::getdt
amrex::Real getdt(int lev) const
Definition: WarpX.H:1050
WarpX::Bfield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp_external
Definition: WarpX.H:1628
WarpX::RefRatio
static amrex::IntVect RefRatio(int lev)
Definition: WarpX.cpp:2996
WarpX::max_step
int max_step
Definition: WarpX.H:1794
WarpX::ApplyBfieldBoundary
void ApplyBfieldBoundary(const int lev, PatchType patch_type, DtType dt_type)
Definition: WarpXFieldBoundaries.cpp:45
WarpX::EvolveG
void EvolveG(amrex::Real dt, DtType dt_type)
Definition: WarpXPushFieldsEM.cpp:1015
WarpX::getEfield_avg_cp
const amrex::MultiFab & getEfield_avg_cp(int lev, int direction)
Definition: WarpX.H:706
WarpX::costs_heuristic_particles_wt
amrex::Real costs_heuristic_particles_wt
Definition: WarpX.H:1784
WarpX::pml_has_particles
int pml_has_particles
Definition: WarpX.H:1715
WarpX::nci_godfrey_filter_exeybz
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > > nci_godfrey_filter_exeybz
Definition: WarpX.H:744
WarpX::do_current_centering
static bool do_current_centering
Definition: WarpX.H:347
WarpX::Byfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Byfield_xt_grid_parser
Definition: WarpX.H:232
WarpX::mirror_z
amrex::Vector< amrex::Real > mirror_z
Definition: WarpX.H:754
WarpX::F_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_slice
Definition: WarpX.H:1827
WarpX::getdo_moving_window
int getdo_moving_window() const
Definition: WarpX.H:1051
WarpX::do_subcycling
static bool do_subcycling
Definition: WarpX.H:473
WarpX::pml_ncell
int pml_ncell
Definition: WarpX.H:1713
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:3002
WarpX::n_rz_azimuthal_modes
static int n_rz_azimuthal_modes
Number of modes for the RZ multi-mode version.
Definition: WarpX.H:406
WarpX::J_in_time
static short J_in_time
Definition: WarpX.H:331
WarpX::PSATDBackwardTransformF
void PSATDBackwardTransformF()
Backward FFT of F on all mesh refinement levels.
Definition: WarpXPushFieldsEM.cpp:196
WarpX::~WarpX
~WarpX()
Definition: WarpX.cpp:579
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:442
WarpX::field_gathering_algo
static short field_gathering_algo
Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving)
Definition: WarpX.H:284
WarpX::Bfield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_cp
Definition: WarpX.H:1693
WarpX::shared_mem_current_tpb
static int shared_mem_current_tpb
number of threads to use per block in shared deposition
Definition: WarpX.H:367
WarpX::load_balance_costs_update_algo
static short load_balance_costs_update_algo
Definition: WarpX.H:292
WarpX::get_pointer_Bfield_fp
amrex::MultiFab * get_pointer_Bfield_fp(int lev, int direction) const
Definition: WarpX.H:638
WarpX::m_fdtd_solver_cp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_cp
Definition: WarpX.H:2131
WarpX::ResetCosts
void ResetCosts()
resets costs to zero
Definition: WarpXRegrid.cpp:399
WarpX::InitBorrowing
void InitBorrowing()
Initialize the memory for the FaceInfoBoxes.
Definition: WarpXFaceExtensions.cpp:258
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:673
WarpX::mirror_z_width
amrex::Vector< amrex::Real > mirror_z_width
Definition: WarpX.H:755
WarpX::getcurrent_fp
const amrex::MultiFab & getcurrent_fp(int lev, int direction)
Definition: WarpX.H:689
WarpX::reduced_diags
std::unique_ptr< MultiReducedDiags > reduced_diags
object with all reduced diagnotics, similar to MultiParticleContainer for species.
Definition: WarpX.H:759
WarpX::getBfield
const amrex::MultiFab & getBfield(int lev, int direction)
Definition: WarpX.H:671
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:687
WarpX::getF_cp
const amrex::MultiFab & getF_cp(int lev)
Definition: WarpX.H:686
WarpX::current_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > current_buffer_masks
Definition: WarpX.H:1703
WarpX::get_numprocs
const amrex::IntVect get_numprocs() const
Definition: WarpX.H:1146
WarpX::ScrapeParticles
void ScrapeParticles()
WarpX::get_pointer_Bfield_cp
amrex::MultiFab * get_pointer_Bfield_cp(int lev, int direction) const
Definition: WarpX.H:656
WarpX::slice_max_grid_size
int slice_max_grid_size
Definition: WarpX.H:1823
WarpX::B_ext_grid_s
static std::string B_ext_grid_s
Initialization type for external magnetic field on the grid.
Definition: WarpX.H:131
WarpX::PSATDEraseAverageFields
void PSATDEraseAverageFields()
Set averaged E,B fields to zero before new iteration.
Definition: WarpXPushFieldsEM.cpp:596
WarpX::RemakeLevel
virtual void RemakeLevel(int lev, amrex::Real time, const amrex::BoxArray &ba, const amrex::DistributionMapping &dm) final
Definition: WarpXRegrid.cpp:161
WarpX::G_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_cp
Definition: WarpX.H:1682
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:670
WarpX::ComputeEightWaysExtensions
void ComputeEightWaysExtensions()
Do the eight-ways extension.
Definition: WarpXFaceExtensions.cpp:529
WarpX::ApplyFilterandSumBoundaryRho
void ApplyFilterandSumBoundaryRho(int lev, int glev, amrex::MultiFab &rho, int icomp, int ncomp)
Definition: WarpXComm.cpp:1326
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:225
WarpX::self_fields_absolute_tolerance
static amrex::Real self_fields_absolute_tolerance
Definition: WarpX.H:1100
WarpX::m_accelerator_lattice
amrex::Vector< std::unique_ptr< AcceleratorLattice > > m_accelerator_lattice
Definition: WarpX.H:1846
WarpX::EvolveE
void EvolveE(amrex::Real dt)
Definition: WarpXPushFieldsEM.cpp:882
WarpX::particle_boundary_hi
static amrex::Vector< ParticleBoundaryType > particle_boundary_hi
Definition: WarpX.H:318
WarpX::m_const_dt
std::optional< amrex::Real > m_const_dt
Definition: WarpX.H:1737
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:2971
WarpX::ComputeOneWayExtensions
void ComputeOneWayExtensions()
Do the one-way extension.
Definition: WarpXFaceExtensions.cpp:405
WarpX::Hybrid_QED_Push
void Hybrid_QED_Push(amrex::Vector< amrex::Real > dt)
Definition: WarpX_QED_Field_Pushers.cpp:46
WarpX::slice_realbox
amrex::RealBox slice_realbox
Definition: WarpX.H:1825
WarpX::do_pml_Lo
amrex::Vector< amrex::IntVect > do_pml_Lo
Definition: WarpX.H:1721
WarpX::applyMirrors
void applyMirrors(amrex::Real time)
Definition: WarpXEvolve.cpp:1128
WarpX::spectral_solver_cp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_cp
Definition: WarpX.H:2113
WarpX::getmoving_window_x
amrex::Real getmoving_window_x() const
Definition: WarpX.H:1052
WarpX::costs_heuristic_cells_wt
amrex::Real costs_heuristic_cells_wt
Definition: WarpX.H:1778
WarpX::E_external_grid
static amrex::Vector< amrex::Real > E_external_grid
Initial electric field on the grid.
Definition: WarpX.H:120
WarpX::do_pml_dive_cleaning
bool do_pml_dive_cleaning
Definition: WarpX.H:1719
WarpX::authors
static std::string authors
Author of an input file / simulation setup.
Definition: WarpX.H:117
WarpX::plotfile_headerversion
amrex::VisMF::Header::Version plotfile_headerversion
Definition: WarpX.H:1803
WarpX::AddBoundaryField
void AddBoundaryField()
Definition: ElectrostaticSolver.cpp:100
WarpX::str_Bz_excitation_flag_function
static std::string str_Bz_excitation_flag_function
Definition: WarpX.H:191
WarpX::getPMLRZ
const PML_RZ * getPMLRZ()
Definition: WarpX.H:712
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:80
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:460
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:450
WarpX::current_correction
bool current_correction
If true, a correction is applied to the current in Fourier space,.
Definition: WarpX.H:351
WarpX::CurrentBufferMasks
static const amrex::iMultiFab * CurrentBufferMasks(int lev)
Definition: WarpX.cpp:3323
WarpX::ComputePMLFactors
void ComputePMLFactors()
WarpX::end_moving_window_step
static int end_moving_window_step
Definition: WarpX.H:1106
WarpX::Ezfield_flag_parser
std::unique_ptr< amrex::Parser > Ezfield_flag_parser
Definition: WarpX.H:250
WarpX::sort_intervals
static utils::parser::IntervalsParser sort_intervals
Definition: WarpX.H:465
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::B_excitation_grid_s
static std::string B_excitation_grid_s
Definition: WarpX.H:136
WarpX::Efield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp
Definition: WarpX.H:1608
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:86
WarpX::update_with_rho
bool update_with_rho
Definition: WarpX.H:355
WarpX::LoadBalance
void LoadBalance()
perform load balance; compute and communicate new amrex::DistributionMapping
Definition: WarpXRegrid.cpp:51
WarpX::time_of_last_gal_shift
amrex::Real time_of_last_gal_shift
Definition: WarpX.H:747
WarpXParticleContainer
Definition: WarpXParticleContainer.H:104
amrex::AmrMesh::geom
Vector< Geometry > geom
amrex::FabArray::get
const FAB & 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
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:81
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
Generated by doxygen 1.9.1