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 
43 #include <AMReX.H>
44 #include <AMReX_AmrCore.H>
45 #include <AMReX_Array.H>
46 #include <AMReX_Config.H>
47 #ifdef AMREX_USE_EB
48 # include <AMReX_EBFabFactory.H>
49 #endif
50 #include <AMReX_GpuContainers.H>
51 #include <AMReX_IntVect.H>
52 #include <AMReX_LayoutData.H>
53 #include <AMReX_Parser.H>
54 #include <AMReX_REAL.H>
55 #include <AMReX_RealBox.H>
56 #include <AMReX_RealVect.H>
57 #include <AMReX_Vector.H>
58 #include <AMReX_VisMF.H>
59 
60 #include <AMReX_BaseFwd.H>
61 #include <AMReX_AmrCoreFwd.H>
62 
63 #include <array>
64 #include <iostream>
65 #include <limits>
66 #include <memory>
67 #include <optional>
68 #include <string>
69 #include <vector>
70 #include <map>
71 
72 enum struct PatchType : int
73 {
74  fine,
75  coarse
76 };
77 
78 class WarpX
79  : public amrex::AmrCore
80 {
81 public:
82 
83  friend class PML;
84 
85  static WarpX& GetInstance ();
86  static void ResetInstance ();
87 
88  WarpX ();
89  ~WarpX ();
90 
91  static std::string Version ();
92  static std::string PicsarVersion ();
93 
94  int Verbose () const { return verbose; }
95 
96  void InitData ();
97 
98  void Evolve (int numsteps = -1);
99 
100  MultiParticleContainer& GetPartContainer () { return *mypc; }
101  MacroscopicProperties& GetMacroscopicProperties () { return *m_macroscopic_properties; }
102  London& getLondon () { return *m_london; }
103  MultiDiagnostics& GetMultiDiags () {return *multi_diags;}
104 
105  ParticleBoundaryBuffer& GetParticleBoundaryBuffer () { return *m_particle_boundary_buffer; }
106 
107  static void shiftMF (amrex::MultiFab& mf, const amrex::Geometry& geom,
108  int num_shift, int dir, const int lev, bool update_cost_flag,
109  amrex::Real external_field=0.0, bool useparser = false,
110  amrex::ParserExecutor<3> const& field_parser={});
111 
112  static void GotoNextLine (std::istream& is);
113 
115  static std::string authors;
116 
118  static amrex::Vector<amrex::Real> E_external_grid;
120  static amrex::Vector<amrex::Real> B_external_grid;
121 
122 #ifdef WARPX_MAG_LLG
123  static amrex::Vector<amrex::Real> H_external_grid;
124  static amrex::Vector<amrex::Real> M_external_grid;
125  static amrex::Vector<amrex::Real> H_bias_external_grid;
126 #endif
127 
129  static std::string B_ext_grid_s;
131  static std::string E_ext_grid_s;
132 
133  // Initialization Type for External E and B excitation on grid
134  static std::string B_excitation_grid_s;
135  static std::string E_excitation_grid_s;
136 #ifdef WARPX_MAG_LLG
137  static std::string H_excitation_grid_s;
138  static std::string H_bias_excitation_grid_s;
139 #endif
140 
141 #ifdef WARPX_MAG_LLG
142  static std::string H_ext_grid_s; // added for H;
143  static std::string M_ext_grid_s; // added for M;
144  static std::string H_bias_ext_grid_s;
145 #endif
146  static int ApplyExcitationInPML;
148  static bool add_external_E_field;
150  static bool add_external_B_field;
151 
153  static std::string str_Bx_ext_grid_function;
155  static std::string str_By_ext_grid_function;
157  static std::string str_Bz_ext_grid_function;
159  static std::string str_Ex_ext_grid_function;
161  static std::string str_Ey_ext_grid_function;
163  static std::string str_Ez_ext_grid_function;
164 
165  // Function for B excitation (x,y,z,t) on the grid
166  static std::string str_Bx_excitation_grid_function;
167  static std::string str_By_excitation_grid_function;
168  static std::string str_Bz_excitation_grid_function;
169  // Function for E excitation (x,y,z,t) on the grid
170  static std::string str_Ex_excitation_grid_function;
171  static std::string str_Ey_excitation_grid_function;
172  static std::string str_Ez_excitation_grid_function;
173 #ifdef WARPX_MAG_LLG
174  // Function for H excitation (x,y,z,t) on the grid
175  static std::string str_Hx_excitation_grid_function;
176  static std::string str_Hy_excitation_grid_function;
177  static std::string str_Hz_excitation_grid_function;
178  // Function for H bias excitation (x,y,z,t) on the grid
179  static std::string str_Hx_bias_excitation_grid_function;
180  static std::string str_Hy_bias_excitation_grid_function;
181  static std::string str_Hz_bias_excitation_grid_function;
182 #endif
183  // Flag for type of excitation (hard/soft)
184  static std::string str_Ex_excitation_flag_function;
185  static std::string str_Ey_excitation_flag_function;
186  static std::string str_Ez_excitation_flag_function;
187  static std::string str_Bx_excitation_flag_function;
188  static std::string str_By_excitation_flag_function;
189  static std::string str_Bz_excitation_flag_function;
190 #ifdef WARPX_MAG_LLG
191  static std::string str_Hx_excitation_flag_function;
192  static std::string str_Hy_excitation_flag_function;
193  static std::string str_Hz_excitation_flag_function;
194  static std::string str_Hx_bias_excitation_flag_function;
195  static std::string str_Hy_bias_excitation_flag_function;
196  static std::string str_Hz_bias_excitation_flag_function;
197 #endif
198 
199 #ifdef WARPX_MAG_LLG
200  // Parser for H_external on the grid
201  static std::string str_Hx_ext_grid_function;
202  static std::string str_Hy_ext_grid_function;
203  static std::string str_Hz_ext_grid_function;
204  // Parser for M_external on the grid
205  static std::string str_Mx_ext_grid_function;
206  static std::string str_My_ext_grid_function;
207  static std::string str_Mz_ext_grid_function;
208  // Parser for H_bias_external on the grid
209  static std::string str_Hx_bias_ext_grid_function;
210  static std::string str_Hy_bias_ext_grid_function;
211  static std::string str_Hz_bias_ext_grid_function;
212 #endif
213 
215  std::unique_ptr<amrex::Parser> Bxfield_parser;
217  std::unique_ptr<amrex::Parser> Byfield_parser;
219  std::unique_ptr<amrex::Parser> Bzfield_parser;
221  std::unique_ptr<amrex::Parser> Exfield_parser;
223  std::unique_ptr<amrex::Parser> Eyfield_parser;
225  std::unique_ptr<amrex::Parser> Ezfield_parser;
226 
227 
228  // Parser for B_external excitation on the grid
229  std::unique_ptr<amrex::Parser> Bxfield_xt_grid_parser;
230  std::unique_ptr<amrex::Parser> Byfield_xt_grid_parser;
231  std::unique_ptr<amrex::Parser> Bzfield_xt_grid_parser;
232  // Parser for E_external excitation on the grid
233  std::unique_ptr<amrex::Parser> Exfield_xt_grid_parser;
234  std::unique_ptr<amrex::Parser> Eyfield_xt_grid_parser;
235  std::unique_ptr<amrex::Parser> Ezfield_xt_grid_parser;
236 #ifdef WARPX_MAG_LLG
237  // Parser for H_external excitation on the grid
238  std::unique_ptr<amrex::Parser> Hxfield_xt_grid_parser;
239  std::unique_ptr<amrex::Parser> Hyfield_xt_grid_parser;
240  std::unique_ptr<amrex::Parser> Hzfield_xt_grid_parser;
241  // Parser for H_bias external excitation on the grid
242  std::unique_ptr<amrex::Parser> Hx_biasfield_xt_grid_parser;
243  std::unique_ptr<amrex::Parser> Hy_biasfield_xt_grid_parser;
244  std::unique_ptr<amrex::Parser> Hz_biasfield_xt_grid_parser;
245 #endif
246  std::unique_ptr<amrex::Parser> Exfield_flag_parser;
247  std::unique_ptr<amrex::Parser> Eyfield_flag_parser;
248  std::unique_ptr<amrex::Parser> Ezfield_flag_parser;
249  std::unique_ptr<amrex::Parser> Bxfield_flag_parser;
250  std::unique_ptr<amrex::Parser> Byfield_flag_parser;
251  std::unique_ptr<amrex::Parser> Bzfield_flag_parser;
252 #ifdef WARPX_MAG_LLG
253  std::unique_ptr<amrex::Parser> Hxfield_flag_parser;
254  std::unique_ptr<amrex::Parser> Hyfield_flag_parser;
255  std::unique_ptr<amrex::Parser> Hzfield_flag_parser;
256  std::unique_ptr<amrex::Parser> Hx_biasfield_flag_parser;
257  std::unique_ptr<amrex::Parser> Hy_biasfield_flag_parser;
258  std::unique_ptr<amrex::Parser> Hz_biasfield_flag_parser;
259 #endif
260 
261 #ifdef WARPX_MAG_LLG
262  // Parser for H_external on the grid
263  std::unique_ptr<amrex::Parser> Hxfield_parser;
264  std::unique_ptr<amrex::Parser> Hyfield_parser;
265  std::unique_ptr<amrex::Parser> Hzfield_parser;
266  // Parser for M_external on the grid
267  std::unique_ptr<amrex::Parser> Mxfield_parser;
268  std::unique_ptr<amrex::Parser> Myfield_parser;
269  std::unique_ptr<amrex::Parser> Mzfield_parser;
270  // Parser for H_bias_external on the grid
271  std::unique_ptr<amrex::Parser> Hx_biasfield_parser;
272  std::unique_ptr<amrex::Parser> Hy_biasfield_parser;
273  std::unique_ptr<amrex::Parser> Hz_biasfield_parser;
274 #endif
275 
276  // Algorithms
278  static short current_deposition_algo;
280  static short charge_deposition_algo;
282  static short field_gathering_algo;
284  static short particle_pusher_algo;
286  static short electromagnetic_solver_id;
290  static short load_balance_costs_update_algo;
292  static int em_solver_medium;
296  static int macroscopic_solver_algo;
301  static amrex::Vector<int> field_boundary_lo;
306  static amrex::Vector<int> field_boundary_hi;
311  static amrex::Vector<ParticleBoundaryType> particle_boundary_lo;
316  static amrex::Vector<ParticleBoundaryType> particle_boundary_hi;
317  static int yee_coupled_solver_algo;
318 
322  static short psatd_solution_type;
323 
326  static short J_in_time;
327  static short rho_in_time;
328 
329 #ifdef WARPX_MAG_LLG
330  // second-order magnetization normalization strategy
331  int mag_M_normalization;
332  // turn on LLG + Maxwell coupling
333  int mag_LLG_coupling = 1;
334  // turn off the exchange coupling term H_exchange in H_eff for the LLG updates
335  int mag_LLG_exchange_coupling = 0;
336  // turn off the anisotropy coupling term H_anisotropy in H_eff for the LLG updates
337  int mag_LLG_anisotropy_coupling = 0;
338 #endif
342  static bool do_current_centering;
343 
345  // to satisfy the continuity equation and charge conservation
346  bool current_correction;
347 
350  bool update_with_rho = false;
351 
353  static bool do_single_precision_comms;
354 
356  static bool do_shared_mem_charge_deposition;
357 
359  static bool do_shared_mem_current_deposition;
360 
362  static int shared_mem_current_tpb;
363 
365  static amrex::IntVect shared_tilesize;
366 
368  static amrex::IntVect m_fill_guards_fields;
369 
371  static amrex::IntVect m_fill_guards_current;
372 
375  static bool do_dive_cleaning;
377  static bool do_divb_cleaning;
378 
380  static int nox;
382  static int noy;
384  static int noz;
385 
387  static int field_centering_nox;
389  static int field_centering_noy;
391  static int field_centering_noz;
392 
394  static int current_centering_nox;
396  static int current_centering_noy;
398  static int current_centering_noz;
399 
401  static int n_rz_azimuthal_modes;
406  static int ncomps;
407 
410  static bool use_fdtd_nci_corr;
420  static bool galerkin_interpolation;
421 
424  static bool verboncoeur_axis_correction;
425 
427  static bool use_filter;
429  static bool use_kspace_filter;
431  static bool use_filter_compensation;
432 
434  static bool serialize_initial_conditions;
435 
437  static amrex::Real gamma_boost;
439  static amrex::Real beta_boost;
441  static amrex::Vector<int> boost_direction;
445  static amrex::Real zmax_plasma_to_compute_max_step;
449  static bool do_compute_max_step_from_zmax;
452  static amrex::Real zmin_domain_boost_step_0;
453 
455  static bool compute_max_step_from_btd;
456 
457  static bool do_dynamic_scheduling;
458  static bool refine_plasma;
459 
460  static utils::parser::IntervalsParser sort_intervals;
461  static amrex::IntVect sort_bin_size;
462 
464  static bool sort_particles_for_deposition;
466  static amrex::IntVect sort_idx_type;
467 
468  static bool do_subcycling;
469  static bool do_multi_J;
470  static int do_multi_J_n_depositions;
471 
472  static bool do_device_synchronize;
473  static bool safe_guard_cells;
474 
478  static int n_field_gather_buffer;
482  static int n_current_deposition_buffer;
483 
486  static short grid_type;
487 
488  // Global rho nodal flag to know about rho index type when rho MultiFab is not allocated
489  amrex::IntVect m_rho_nodal_flag;
490 
505  static void AllocInitMultiFab (
506  std::unique_ptr<amrex::MultiFab>& mf,
507  const amrex::BoxArray& ba,
508  const amrex::DistributionMapping& dm,
509  const int ncomp,
510  const amrex::IntVect& ngrow,
511  const std::string& name,
512  std::optional<const amrex::Real> initial_value = {});
513 
528  static void AllocInitMultiFab (
529  std::unique_ptr<amrex::iMultiFab>& mf,
530  const amrex::BoxArray& ba,
531  const amrex::DistributionMapping& dm,
532  const int ncomp,
533  const amrex::IntVect& ngrow,
534  const std::string& name,
535  std::optional<const int> initial_value = {});
536 
547  static void AliasInitMultiFab (
548  std::unique_ptr<amrex::MultiFab>& mf,
549  const amrex::MultiFab& mf_to_alias,
550  const int scomp,
551  const int ncomp,
552  const std::string& name,
553  std::optional<const amrex::Real> initial_value);
554 
555  // Maps of all of the MultiFabs and iMultiFabs used (this can include MFs from other classes)
556  // This is a convenience for the Python interface, allowing all MultiFabs
557  // to be easily referenced from Python.
558  static std::map<std::string, amrex::MultiFab *> multifab_map;
559  static std::map<std::string, amrex::iMultiFab *> imultifab_map;
560 
567  static void AddToMultiFabMap(const std::string& name, const std::unique_ptr<amrex::MultiFab>& mf) {
568  multifab_map[name] = mf.get();
569  }
570 
577  static void AddToMultiFabMap(const std::string& name, const std::unique_ptr<amrex::iMultiFab>& mf) {
578  imultifab_map[name] = mf.get();
579  }
580 
581  std::array<const amrex::MultiFab* const, 3>
582  get_array_Bfield_aux (const int lev) const {
583  return {
584  Bfield_aux[lev][0].get(),
585  Bfield_aux[lev][1].get(),
586  Bfield_aux[lev][2].get()
587  };
588  }
589  std::array<const amrex::MultiFab* const, 3>
590  get_array_Efield_aux (const int lev) const {
591  return {
592  Efield_aux[lev][0].get(),
593  Efield_aux[lev][1].get(),
594  Efield_aux[lev][2].get()
595  };
596  }
597 
598 #ifdef WARPX_MAG_LLG
599  std::array<const amrex::MultiFab* const, 3>
600  get_array_Hfield_aux (const int lev) const {
601  return {
602  Hfield_aux[lev][0].get(),
603  Hfield_aux[lev][1].get(),
604  Hfield_aux[lev][2].get()
605  };
606  }
607  std::array<const amrex::MultiFab* const, 3>
608  get_array_Mfield_aux (const int lev) const {
609  return {
610  Mfield_aux[lev][0].get(),
611  Mfield_aux[lev][1].get(),
612  Mfield_aux[lev][2].get()
613  };
614  }
615  std::array<const amrex::MultiFab* const, 3>
616  get_array_H_biasfield_aux (const int lev) const {
617  return {
618  H_biasfield_aux[lev][0].get(),
619  H_biasfield_aux[lev][1].get(),
620  H_biasfield_aux[lev][2].get()
621  };
622  }
623 #endif
624  amrex::MultiFab * get_pointer_Efield_aux (int lev, int direction) const { return Efield_aux[lev][direction].get(); }
625  amrex::MultiFab * get_pointer_Bfield_aux (int lev, int direction) const { return Bfield_aux[lev][direction].get(); }
626 #ifdef WARPX_MAG_LLG
627  amrex::MultiFab * get_pointer_Hfield_aux (int lev, int direction) const { return Hfield_aux[lev][direction].get(); }
628  amrex::MultiFab * get_pointer_Mfield_aux (int lev, int direction) const { return Mfield_aux[lev][direction].get(); }
629  amrex::MultiFab * get_pointer_H_biasfield_aux (int lev, int direction) const { return H_biasfield_aux[lev][direction].get(); }
630 #endif
631  amrex::MultiFab * get_pointer_Efield_fp (int lev, int direction) const { return Efield_fp[lev][direction].get(); }
632  amrex::MultiFab * get_pointer_Bfield_fp (int lev, int direction) const { return Bfield_fp[lev][direction].get(); }
633  amrex::MultiFab * get_pointer_Bfield_sc_fp (int lev, int direction) const { return Bfield_sc_fp[lev][direction].get(); }
634 
635 #ifdef WARPX_MAG_LLG
636  amrex::MultiFab * get_pointer_Hfield_fp (int lev, int direction) const { return Hfield_fp[lev][direction].get();}
637  // note "direction" of M means face. For M, each face stores all 3 vector components of M
638  amrex::MultiFab * get_pointer_Mfield_fp (int lev, int direction) const { return Mfield_fp[lev][direction].get();}
639  amrex::MultiFab * get_pointer_H_biasfield_fp (int lev, int direction) const { return H_biasfield_fp[lev][direction].get();}
640 #endif
641  amrex::MultiFab * get_pointer_current_fp (int lev, int direction) const { return current_fp[lev][direction].get(); }
642  amrex::MultiFab * get_pointer_current_fp_nodal (int lev, int direction) const { return current_fp_nodal[lev][direction].get(); }
643  amrex::MultiFab * get_pointer_rho_fp (int lev) const { return rho_fp[lev].get(); }
644  amrex::MultiFab * get_pointer_F_fp (int lev) const { return F_fp[lev].get(); }
645  amrex::MultiFab * get_pointer_G_fp (int lev) const { return G_fp[lev].get(); }
646  amrex::MultiFab * get_pointer_phi_fp (int lev) const { return phi_fp[lev].get(); }
647  amrex::MultiFab * get_pointer_vector_potential_fp (int lev, int direction) const { return vector_potential_fp_nodal[lev][direction].get(); }
648 
649  amrex::MultiFab * get_pointer_Efield_cp (int lev, int direction) const { return Efield_cp[lev][direction].get(); }
650  amrex::MultiFab * get_pointer_Bfield_cp (int lev, int direction) const { return Bfield_cp[lev][direction].get(); }
651 #ifdef WARPX_MAG_LLG
652  amrex::MultiFab * get_pointer_Hfield_cp (int lev, int direction) const { return Hfield_cp[lev][direction].get(); }
653  amrex::MultiFab * get_pointer_Mfield_cp (int lev, int direction) const { return Mfield_cp[lev][direction].get(); }
654  amrex::MultiFab * get_pointer_H_biasfield_cp (int lev, int direction) const { return H_biasfield_cp[lev][direction].get(); }
655 #endif
656  amrex::MultiFab * get_pointer_current_cp (int lev, int direction) const { return current_cp[lev][direction].get(); }
657  amrex::MultiFab * get_pointer_rho_cp (int lev) const { return rho_cp[lev].get(); }
658  amrex::MultiFab * get_pointer_F_cp (int lev) const { return F_cp[lev].get(); }
659  amrex::MultiFab * get_pointer_G_cp (int lev) const { return G_cp[lev].get(); }
660 
661  amrex::MultiFab * get_pointer_edge_lengths (int lev, int direction) const { return m_edge_lengths[lev][direction].get(); }
662  amrex::MultiFab * get_pointer_face_areas (int lev, int direction) const { return m_face_areas[lev][direction].get(); }
663 
664  const amrex::MultiFab& getEfield (int lev, int direction) {return *Efield_aux[lev][direction];}
665  const amrex::MultiFab& getBfield (int lev, int direction) {return *Bfield_aux[lev][direction];}
666 #ifdef WARPX_MAG_LLG
667  const amrex::MultiFab& getHfield (int lev, int direction) {return *Hfield_aux[lev][direction];}
668  const amrex::MultiFab& getMfield (int lev, int direction) {return *Mfield_aux[lev][direction];}
669  const amrex::MultiFab& getH_biasfield (int lev, int direction) {return *H_biasfield_aux[lev][direction];}
670 #endif
671  const amrex::MultiFab& getcurrent_cp (int lev, int direction) {return *current_cp[lev][direction];}
672  const amrex::MultiFab& getEfield_cp (int lev, int direction) {return *Efield_cp[lev][direction];}
673  const amrex::MultiFab& getBfield_cp (int lev, int direction) {return *Bfield_cp[lev][direction];}
674 #ifdef WARPX_MAG_LLG
675  const amrex::MultiFab& getHfield_cp (int lev, int direction) {return *Hfield_cp[lev][direction];}
676  const amrex::MultiFab& getMfield_cp (int lev, int direction) {return *Mfield_cp[lev][direction];}
677  const amrex::MultiFab& getH_biasfield_cp (int lev, int direction) {return *H_biasfield_cp[lev][direction];}
678 #endif
679  const amrex::MultiFab& getrho_cp (int lev) {return *rho_cp[lev];}
680  const amrex::MultiFab& getF_cp (int lev) {return *F_cp[lev];}
681  const amrex::MultiFab& getG_cp (int lev) {return *G_cp[lev];}
682 
683  const amrex::MultiFab& getcurrent_fp (int lev, int direction) {return *current_fp[lev][direction];}
684  const amrex::MultiFab& getEfield_fp (int lev, int direction) {return *Efield_fp[lev][direction];}
685  const amrex::MultiFab& getBfield_fp (int lev, int direction) {return *Bfield_fp[lev][direction];}
686  const amrex::MultiFab& getBfield_sc_fp (int lev, int direction) {return *Bfield_sc_fp[lev][direction];}
687 #ifdef WARPX_MAG_LLG
688  const amrex::MultiFab& getHfield_fp (int lev, int direction) {return *Hfield_fp[lev][direction];}
689  const amrex::MultiFab& getMfield_fp (int lev, int direction) {return *Mfield_fp[lev][direction];}
690  const amrex::MultiFab& getH_biasfield_fp (int lev, int direction) {return *H_biasfield_fp[lev][direction];}
691 #endif
692  const amrex::MultiFab& getrho_fp (int lev) {return *rho_fp[lev];}
693  const amrex::MultiFab& getphi_fp (int lev) {return *phi_fp[lev];}
694  const amrex::MultiFab& getF_fp (int lev) {return *F_fp[lev];}
695  const amrex::MultiFab& getG_fp (int lev) {return *G_fp[lev];}
696 
697  const amrex::MultiFab& getEfield_avg_fp (int lev, int direction) {return *Efield_avg_fp[lev][direction];}
698  const amrex::MultiFab& getBfield_avg_fp (int lev, int direction) {return *Bfield_avg_fp[lev][direction];}
699  const amrex::MultiFab& getEfield_avg_cp (int lev, int direction) {return *Efield_avg_cp[lev][direction];}
700  const amrex::MultiFab& getBfield_avg_cp (int lev, int direction) {return *Bfield_avg_cp[lev][direction];}
701 
702  bool DoPML () const {return do_pml;}
703 
704 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
705  const PML_RZ* getPMLRZ() {return pml_rz[0].get();}
706 #endif
707 
709  std::vector<bool> getPMLdirections() const;
710 
711  static amrex::LayoutData<amrex::Real>* getCosts (int lev);
712 
713  void setLoadBalanceEfficiency (const int lev, const amrex::Real efficiency)
714  {
715  if (m_instance)
716  {
717  m_instance->load_balance_efficiency[lev] = efficiency;
718  } else
719  {
720  return;
721  }
722  }
723 
724  amrex::Real getLoadBalanceEfficiency (const int lev)
725  {
726  if (m_instance)
727  {
728  return m_instance->load_balance_efficiency[lev];
729  } else
730  {
731  return -1;
732  }
733  }
734 
735  static amrex::IntVect filter_npass_each_dir;
736  BilinearFilter bilinear_filter;
737  amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > nci_godfrey_filter_exeybz;
738  amrex::Vector< std::unique_ptr<NCIGodfreyFilter> > nci_godfrey_filter_bxbyez;
739 
740  amrex::Real time_of_last_gal_shift = 0;
741  amrex::Vector<amrex::Real> m_v_galilean = amrex::Vector<amrex::Real>(3, amrex::Real(0.));
742  amrex::Array<amrex::Real,3> m_galilean_shift = {{0}};
743 
744  amrex::Vector<amrex::Real> m_v_comoving = amrex::Vector<amrex::Real>(3, amrex::Real(0.));
745 
746  static int num_mirrors;
747  amrex::Vector<amrex::Real> mirror_z;
748  amrex::Vector<amrex::Real> mirror_z_width;
749  amrex::Vector<int> mirror_z_npoints;
750 
752  std::unique_ptr<MultiReducedDiags> reduced_diags;
753 
754  void applyMirrors(amrex::Real time);
755 
757  void ComputeDt ();
758 
760  void PrintMainPICparameters ();
761 
763  void WriteUsedInputsFile () const;
764 
766  void PrintDtDxDyDz ();
767 
773  void ComputeMaxStep ();
774  // Compute max_step automatically for simulations in a boosted frame.
775  void computeMaxStepBoostAccelerator();
776 
781  int MoveWindow (const int step, bool move_j);
782 
788  void ShiftGalileanBoundary ();
789  void UpdatePlasmaInjectionPosition (amrex::Real dt);
790  void ResetProbDomain (const amrex::RealBox& rb);
791  void EvolveE ( amrex::Real dt); // declare this function, defined somewhere else
792  void EvolveE (int lev, amrex::Real dt);
793  void EvolveB ( amrex::Real dt, DtType dt_type);
794  void EvolveB (int lev, amrex::Real dt, DtType dt_type);
795  void EvolveF ( amrex::Real dt, DtType dt_type);
796  void EvolveF (int lev, amrex::Real dt, DtType dt_type);
797  void EvolveG ( amrex::Real dt, DtType dt_type);
798  void EvolveG (int lev, amrex::Real dt, DtType dt_type);
799  void EvolveB (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
800  void EvolveE (int lev, PatchType patch_type, amrex::Real dt);
801  void EvolveF (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
802  void EvolveG (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
803  void EvolveBLondon ( amrex::Real dt, DtType dt_type);
804  void EvolveBLondon (int lev, amrex::Real dt, DtType dt_type);
805  void EvolveBLondon (int lev, PatchType patch_type, amrex::Real dt, DtType dt_type);
806 
807  void MacroscopicEvolveE ( amrex::Real dt);
808  void MacroscopicEvolveE (int lev, amrex::Real dt);
809  void MacroscopicEvolveE (int lev, PatchType patch_type, amrex::Real dt);
810 
811 #ifdef WARPX_MAG_LLG
812  void MacroscopicEvolveHM ( amrex::Real dt);
813  void MacroscopicEvolveHM (int lev, amrex::Real dt);
814  void MacroscopicEvolveHM (int lev, PatchType patch_type, amrex::Real dt);
815 
816  void MacroscopicEvolveHM_2nd ( amrex::Real dt);
817  void MacroscopicEvolveHM_2nd (int lev, amrex::Real dt);
818  void MacroscopicEvolveHM_2nd (int lev, PatchType patch_type, amrex::Real dt);
819 #endif
820 
825  void Hybrid_QED_Push ( amrex::Vector<amrex::Real> dt);
826 
832  void Hybrid_QED_Push (int lev, amrex::Real dt);
833 
840  void Hybrid_QED_Push (int lev, PatchType patch_type, amrex::Real dt);
841 
842  static amrex::Real quantum_xi_c2;
843 
846  void LoadBalance ();
849  void ResetCosts ();
850 
853  utils::parser::IntervalsParser get_load_balance_intervals () const
854  {
855  return load_balance_intervals;
856  }
857 
865  void DampFieldsInGuards (const int lev,
866  const std::array<std::unique_ptr<amrex::MultiFab>,3>& Efield,
867  const std::array<std::unique_ptr<amrex::MultiFab>,3>& Bfield);
868 
876  void DampFieldsInGuards (const int lev, std::unique_ptr<amrex::MultiFab>& mf);
877 
878 #ifdef WARPX_DIM_RZ
879  void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab* Jx,
880  amrex::MultiFab* Jy,
881  amrex::MultiFab* Jz,
882  int lev);
883 
884  void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab* Rho,
885  int lev);
886 #endif
887 
893  void ApplyRhofieldBoundary (const int lev, amrex::MultiFab* Rho,
894  PatchType patch_type);
895 
901  void ApplyJfieldBoundary (const int lev, amrex::MultiFab* Jx,
902  amrex::MultiFab* Jy, amrex::MultiFab* Jz,
903  PatchType patch_type);
904 
905  void ApplyEfieldBoundary (const int lev, PatchType patch_type);
906  void ApplyBfieldBoundary (const int lev, PatchType patch_type, DtType dt_type);
907 
908  void DampPML ();
909  void DampPML (const int lev);
910  void DampPML (const int lev, PatchType patch_type);
911  void DampPML_Cartesian (const int lev, PatchType patch_type);
912 
913  void DampJPML ();
914  void DampJPML (int lev);
915  void DampJPML (int lev, PatchType patch_type);
916 
917  void CopyJPML ();
918  bool isAnyBoundaryPML();
919 
923  void NodalSyncPML ();
924 
928  void NodalSyncPML (int lev);
929 
933  void NodalSyncPML (int lev, PatchType patch_type);
934 
935  PML* GetPML (int lev);
936 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
937  PML_RZ* GetPML_RZ (int lev);
938 #endif
939 
941  void doFieldIonization ();
945  void doFieldIonization (int lev);
946 
947 #ifdef WARPX_QED
949  void doQEDEvents ();
953  void doQEDEvents (int lev);
954 #endif
955 
956  void PushParticlesandDepose (int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false);
957  void PushParticlesandDepose ( amrex::Real cur_time, bool skip_current=false);
958 
959  // This function does aux(lev) = fp(lev) + I(aux(lev-1)-cp(lev)).
960  // Caller must make sure fp and cp have ghost cells filled.
961  void UpdateAuxilaryData ();
962  void UpdateAuxilaryDataStagToNodal ();
963  void UpdateAuxilaryDataSameType ();
964 
973  void UpdateCurrentNodalToStag (amrex::MultiFab& dst, amrex::MultiFab const& src);
974 
975  // Fill boundary cells including coarse/fine boundaries
976  void FillBoundaryB (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
977  void FillBoundaryE (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
978  void FillBoundaryB_avg (amrex::IntVect ng);
979  void FillBoundaryE_avg (amrex::IntVect ng);
980 #ifdef WARPX_MAG_LLG
981  void FillBoundaryM (amrex::IntVect ng);
982  void FillBoundaryH (amrex::IntVect ng);
983 #endif
984 
985  void FillBoundaryF (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
986  void FillBoundaryG (amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
987  void FillBoundaryAux (amrex::IntVect ng);
988  void FillBoundaryE (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
989  void FillBoundaryB (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
990  void FillBoundaryE_avg (int lev, amrex::IntVect ng);
991  void FillBoundaryB_avg (int lev, amrex::IntVect ng);
992 #ifdef WARPX_MAG_LLG
993  void FillBoundaryM (int lev, amrex::IntVect ng);
994  void FillBoundaryH (int lev, amrex::IntVect ng);
995 #endif
996 
997  void FillBoundaryF (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
998  void FillBoundaryG (int lev, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
999  void FillBoundaryAux (int lev, amrex::IntVect ng);
1000 
1001  void FillBoundaryJ (amrex::IntVect ng);
1002  void FillBoundaryJ (const int lev, amrex::IntVect ng);
1003 
1009  void SyncCurrentAndRho ();
1010 
1022  void SyncCurrent (
1023  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1024  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp);
1025 
1026  void SyncRho ();
1027 
1028  void SyncRho (
1029  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1030  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp);
1031 
1032  amrex::Vector<int> getnsubsteps () const {return nsubsteps;}
1033  int getnsubsteps (int lev) const {return nsubsteps[lev];}
1034  amrex::Vector<int> getistep () const {return istep;}
1035  int getistep (int lev) const {return istep[lev];}
1036  void setistep (int lev, int ii) {istep[lev] = ii;}
1037  amrex::Vector<amrex::Real> gett_old () const {return t_old;}
1038  amrex::Real gett_old (int lev) const {return t_old[lev];}
1039  amrex::Vector<amrex::Real> gett_new () const {return t_new;}
1040  amrex::Real gett_new (int lev) const {return t_new[lev];}
1041  void sett_new (int lev, amrex::Real time) {t_new[lev] = time;}
1042  amrex::Vector<amrex::Real> getdt () const {return dt;}
1043  amrex::Real getdt (int lev) const {return dt[lev];}
1044  int getdo_moving_window() const {return do_moving_window;}
1045  amrex::Real getmoving_window_x() const {return moving_window_x;}
1046  amrex::Real getcurrent_injection_position () const {return current_injection_position;}
1047  bool getis_synchronized() const {return is_synchronized;}
1048 
1049  int maxStep () const {return max_step;}
1050  void updateMaxStep (const int new_max_step) {max_step = new_max_step;}
1051  amrex::Real stopTime () const {return stop_time;}
1052  void updateStopTime (const amrex::Real new_stop_time) {stop_time = new_stop_time;}
1053 
1054  void AverageAndPackFields( amrex::Vector<std::string>& varnames,
1055  amrex::Vector<amrex::MultiFab>& mf_avg, const amrex::IntVect ngrow) const;
1056 
1057  void prepareFields( int const step, amrex::Vector<std::string>& varnames,
1058  amrex::Vector<amrex::MultiFab>& mf_avg,
1059  amrex::Vector<const amrex::MultiFab*>& output_mf,
1060  amrex::Vector<amrex::Geometry>& output_geom ) const;
1061 
1062  static std::array<amrex::Real,3> CellSize (int lev);
1063  static amrex::RealBox getRealBox(const amrex::Box& bx, int lev);
1064 
1073  static std::array<amrex::Real,3> LowerCorner (const amrex::Box& bx, const int lev, const amrex::Real time_shift_delta);
1082  static std::array<amrex::Real,3> UpperCorner (const amrex::Box& bx, const int lev, const amrex::Real time_shift_delta);
1083 
1084  static amrex::IntVect RefRatio (int lev);
1085 
1086  static const amrex::iMultiFab* CurrentBufferMasks (int lev);
1087  static const amrex::iMultiFab* GatherBufferMasks (int lev);
1088 
1089  static int electrostatic_solver_id;
1090 
1091  // Parameters for lab frame electrostatic
1092  static amrex::Real self_fields_required_precision;
1093  static amrex::Real self_fields_absolute_tolerance;
1094  static int self_fields_max_iters;
1095  static int self_fields_verbosity;
1096 
1097  static int do_moving_window; // boolean
1098  static int start_moving_window_step; // the first step to move window
1099  static int end_moving_window_step; // the last step to move window
1105  static int moving_window_active (int const step) {
1106  bool const step_before_end = (step < end_moving_window_step) || (end_moving_window_step < 0);
1107  bool const step_after_start = (step >= start_moving_window_step);
1108  return do_moving_window && step_before_end && step_after_start;
1109  }
1110  static int moving_window_dir;
1111  static amrex::Real moving_window_v;
1112  static bool fft_do_time_averaging;
1113 
1114  // these should be private, but can't due to Cuda limitations
1115  static void ComputeDivB (amrex::MultiFab& divB, int const dcomp,
1116  const std::array<const amrex::MultiFab* const, 3>& B,
1117  const std::array<amrex::Real,3>& dx);
1118 
1119  static void ComputeDivB (amrex::MultiFab& divB, int const dcomp,
1120  const std::array<const amrex::MultiFab* const, 3>& B,
1121  const std::array<amrex::Real,3>& dx, amrex::IntVect const ngrow);
1122 
1123  void ComputeDivE(amrex::MultiFab& divE, const int lev);
1124 
1125  const amrex::IntVect getngEB() const { return guard_cells.ng_alloc_EB; }
1126  const amrex::IntVect getngF() const { return guard_cells.ng_alloc_F; }
1127  const amrex::IntVect getngUpdateAux() const { return guard_cells.ng_UpdateAux; }
1128  const amrex::IntVect get_ng_depos_J() const {return guard_cells.ng_depos_J;}
1129  const amrex::IntVect get_ng_depos_rho() const {return guard_cells.ng_depos_rho;}
1130  const amrex::IntVect get_ng_fieldgather () const {return guard_cells.ng_FieldGather;}
1131 
1139  const amrex::IntVect get_numprocs() const {return numprocs;}
1140 
1141  ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler;
1142  void ComputeSpaceChargeField (bool const reset_fields);
1143  void AddBoundaryField ();
1144  void AddSpaceChargeField (WarpXParticleContainer& pc);
1145  void AddSpaceChargeFieldLabFrame ();
1146  void computePhi (const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& rho,
1147  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
1148  std::array<amrex::Real, 3> const beta = {{0,0,0}},
1149  amrex::Real const required_precision=amrex::Real(1.e-11),
1150  amrex::Real absolute_tolerance=amrex::Real(0.0),
1151  const int max_iters=200,
1152  const int verbosity=2) const;
1153 
1154  void setPhiBC (amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi ) const;
1155 
1156  void computeE (amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3> >& E,
1157  const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
1158  std::array<amrex::Real, 3> const beta = {{0,0,0}} ) const;
1159  void computeB (amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3> >& B,
1160  const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi,
1161  std::array<amrex::Real, 3> const beta = {{0,0,0}} ) const;
1162  void computePhiTriDiagonal (const amrex::Vector<std::unique_ptr<amrex::MultiFab> >& rho,
1163  amrex::Vector<std::unique_ptr<amrex::MultiFab> >& phi) const;
1164 
1165  // Magnetostatic Solver Interface
1166  MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler;
1167  void ComputeMagnetostaticField ();
1168  void AddMagnetostaticFieldLabFrame ();
1169  void computeVectorPotential (const amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& curr,
1170  amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& A,
1171  amrex::Real const required_precision=amrex::Real(1.e-11),
1172  amrex::Real absolute_tolerance=amrex::Real(0.0),
1173  const int max_iters=200,
1174  const int verbosity=2) const;
1175 
1176  void setVectorPotentialBC (amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, 3> >& A) const;
1177 
1199  void InitializeExternalFieldsOnGridUsingParser (
1200  amrex::MultiFab *mfx, amrex::MultiFab *mfy, amrex::MultiFab *mfz,
1201  amrex::ParserExecutor<3> const& xfield_parser,
1202  amrex::ParserExecutor<3> const& yfield_parser,
1203  amrex::ParserExecutor<3> const& zfield_parser,
1204  std::array< std::unique_ptr<amrex::MultiFab>, 3 > const& edge_lengths,
1205  std::array< std::unique_ptr<amrex::MultiFab>, 3 > const& face_areas,
1206  const char field,
1207  const int lev, PatchType patch_type);
1208 
1209  void ReadExternalFieldFromFile (
1210  std::string read_fields_from_path, amrex::MultiFab* mf,
1211  std::string F_name, std::string F_component);
1212 
1221  void InitializeEBGridData(int lev);
1222 
1228  void ComputeCostsHeuristic (amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > >& costs);
1229 
1230  void ApplyFilterandSumBoundaryRho (int lev, int glev, amrex::MultiFab& rho, int icomp, int ncomp);
1231 
1258  void ApplyExternalFieldExcitationOnGrid (int const externalfieldtype, DtType a_dt_type = DtType::Full);
1259  void ApplyExternalFieldExcitationOnGrid ( amrex::MultiFab *mfx,
1260  amrex::MultiFab *mfy, amrex::MultiFab *mfz,
1261  amrex::ParserExecutor<4> const& xfield_parser,
1262  amrex::ParserExecutor<4> const& yfield_parser,
1263  amrex::ParserExecutor<4> const& zfield_parser,
1264  amrex::ParserExecutor<3> const& xflag_parser,
1265  amrex::ParserExecutor<3> const& yflag_parser,
1266  amrex::ParserExecutor<3> const& zflag_parser, const int lev,
1267  DtType a_dt_type );
1269  void ReadExcitationParser ();
1270 
1271 #ifdef WARPX_MAG_LLG
1272  void AverageParsedMtoFaces(amrex::MultiFab& Mx_cc,
1273  amrex::MultiFab& My_cc,
1274  amrex::MultiFab& Mz_cc,
1275  amrex::MultiFab& Mx_face,
1276  amrex::MultiFab& My_face,
1277  amrex::MultiFab& Mz_face);
1278 #endif
1279 
1288  static amrex::Vector<amrex::Real> getFornbergStencilCoefficients(const int n_order, const short a_grid_type);
1289 
1290  // Device vectors of stencil coefficients used for finite-order centering of fields
1291  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_x;
1292  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_y;
1293  amrex::Gpu::DeviceVector<amrex::Real> device_field_centering_stencil_coeffs_z;
1294 
1295  // Device vectors of stencil coefficients used for finite-order centering of currents
1296  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_x;
1297  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_y;
1298  amrex::Gpu::DeviceVector<amrex::Real> device_current_centering_stencil_coeffs_z;
1299 
1300  // This needs to be public for CUDA.
1302  virtual void ErrorEst (int lev, amrex::TagBoxArray& tags, amrex::Real time, int /*ngrow*/) final;
1303 
1304  // Return the accelerator lattice instance defined at the given refinement level
1305  const AcceleratorLattice& get_accelerator_lattice (int lev) {return *(m_accelerator_lattice[lev]);}
1306 
1307 protected:
1308 
1334  void InitLevelData (int lev, amrex::Real time);
1335 
1338  virtual void PostProcessBaseGrids (amrex::BoxArray& ba0) const final;
1339 
1343  virtual void MakeNewLevelFromScratch (int lev, amrex::Real time, const amrex::BoxArray& ba,
1344  const amrex::DistributionMapping& dm) final;
1345 
1349  virtual void MakeNewLevelFromCoarse (int /*lev*/, amrex::Real /*time*/, const amrex::BoxArray& /*ba*/,
1350  const amrex::DistributionMapping& /*dm*/) final;
1351 
1355  virtual void RemakeLevel (int lev, amrex::Real time, const amrex::BoxArray& ba,
1356  const amrex::DistributionMapping& dm) final;
1357 
1359  virtual void ClearLevel (int lev) final;
1360 
1361 private:
1362 
1363  // Singleton is used when the code is run from python
1364  static WarpX* m_instance;
1365 
1367  static void CheckSignals ();
1369  void HandleSignals ();
1370 
1374  void EvolveEM(int numsteps);
1375 
1376 #ifdef WARPX_MAG_LLG
1377  void FillBoundaryM (const int lev, const PatchType patch_type, const amrex::IntVect ng);
1378  void FillBoundaryH (const int lev, const PatchType patch_type, const amrex::IntVect ng);
1379 #endif
1380  void FillBoundaryB (const int lev, const PatchType patch_type, const amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1381  void FillBoundaryE (const int lev, const PatchType patch_type, const amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1382  void FillBoundaryF (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1383  void FillBoundaryG (int lev, PatchType patch_type, amrex::IntVect ng, std::optional<bool> nodal_sync = std::nullopt);
1384 
1385  void FillBoundaryB_avg (int lev, PatchType patch_type, amrex::IntVect ng);
1386  void FillBoundaryE_avg (int lev, PatchType patch_type, amrex::IntVect ng);
1387  void FillBoundaryJ (const int lev, const PatchType patch_type, const amrex::IntVect ng);
1388 
1389  void AddExternalFields ();
1390 
1391  void OneStep_nosub (amrex::Real t);
1392  void OneStep_sub1 (amrex::Real t);
1393 
1397  void OneStep_multiJ (const amrex::Real t);
1398 
1399  void RestrictCurrentFromFineToCoarsePatch (
1400  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1401  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1402  const int lev);
1403  void AddCurrentFromFineLevelandSumBoundary (
1404  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1405  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1406  const int lev);
1407  void StoreCurrent (const int lev);
1408  void RestoreCurrent (const int lev);
1409  void ApplyFilterJ (
1410  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1411  const int lev,
1412  const int idim);
1413  void ApplyFilterJ (
1414  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1415  const int lev);
1416  void SumBoundaryJ (
1417  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1418  const int lev,
1419  const int idim,
1420  const amrex::Periodicity& period);
1421  void SumBoundaryJ (
1422  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& current,
1423  const int lev,
1424  const amrex::Periodicity& period);
1425  void NodalSyncJ (
1426  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
1427  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
1428  const int lev,
1429  PatchType patch_type);
1430 
1431  void RestrictRhoFromFineToCoarsePatch (
1432  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1433  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1434  const int lev);
1435  void ApplyFilterandSumBoundaryRho (
1436  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1437  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1438  const int lev,
1439  PatchType patch_type,
1440  const int icomp,
1441  const int ncomp);
1442  void AddRhoFromFineLevelandSumBoundary (
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  const int icomp,
1447  const int ncomp);
1448  void NodalSyncRho (
1449  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
1450  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
1451  const int lev,
1452  PatchType patch_type,
1453  const int icomp,
1454  const int ncomp);
1455 
1456  void ReadParameters ();
1457 
1460  void BackwardCompatibility ();
1461 
1462  void InitFromScratch ();
1463 
1464  void AllocLevelData (int lev, const amrex::BoxArray& new_grids,
1465  const amrex::DistributionMapping& new_dmap);
1466 
1467  amrex::DistributionMapping
1468  GetRestartDMap (const std::string& chkfile, const amrex::BoxArray& ba, int lev) const;
1469 
1470  void InitFromCheckpoint ();
1471  void PostRestart ();
1472 
1473  void InitPML ();
1474  void ComputePMLFactors ();
1475 
1476  void InitFilter ();
1477 
1478  void InitDiagnostics ();
1479 
1480  void InitNCICorrector ();
1481 
1486  void CheckGuardCells();
1487 
1492  void CheckGuardCells(amrex::MultiFab const& mf);
1493 
1497  void CheckKnownIssues();
1498 
1500  void PerformanceHints ();
1501 
1502  void BuildBufferMasks ();
1503 public: // for cuda
1504  void BuildBufferMasksInBox ( const amrex::Box tbx, amrex::IArrayBox &buffer_mask,
1505  const amrex::IArrayBox &guard_mask, const int ng );
1506 private:
1507  const amrex::iMultiFab* getCurrentBufferMasks (int lev) const {
1508  return current_buffer_masks[lev].get();
1509  }
1510  const amrex::iMultiFab* getGatherBufferMasks (int lev) const {
1511  return gather_buffer_masks[lev].get();
1512  }
1513 
1523  void ReorderFornbergCoefficients (amrex::Vector<amrex::Real>& ordered_coeffs,
1524  amrex::Vector<amrex::Real>& unordered_coeffs,
1525  const int order);
1538  void AllocateCenteringCoefficients (amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_x,
1539  amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_y,
1540  amrex::Gpu::DeviceVector<amrex::Real>& device_centering_stencil_coeffs_z,
1541  const int centering_nox,
1542  const int centering_noy,
1543  const int centering_noz,
1544  const short a_grid_type);
1545 
1546  void AllocLevelMFs (int lev, const amrex::BoxArray& ba, const amrex::DistributionMapping& dm,
1547  const amrex::IntVect& ngEB, amrex::IntVect& ngJ,
1548  const amrex::IntVect& ngRho, const amrex::IntVect& ngF,
1549  const amrex::IntVect& ngG, const bool aux_is_nodal);
1550 
1551 #ifdef WARPX_USE_PSATD
1552 # ifdef WARPX_DIM_RZ
1553  void AllocLevelSpectralSolverRZ (amrex::Vector<std::unique_ptr<SpectralSolverRZ>>& spectral_solver,
1554  const int lev,
1555  const amrex::BoxArray& realspace_ba,
1556  const amrex::DistributionMapping& dm,
1557  const std::array<amrex::Real,3>& dx);
1558 # else
1559  void AllocLevelSpectralSolver (amrex::Vector<std::unique_ptr<SpectralSolver>>& spectral_solver,
1560  const int lev,
1561  const amrex::BoxArray& realspace_ba,
1562  const amrex::DistributionMapping& dm,
1563  const std::array<amrex::Real,3>& dx,
1564  const bool pml_flag=false);
1565 # endif
1566 #endif
1567 
1568  amrex::Vector<int> istep; // which step?
1569  amrex::Vector<int> nsubsteps; // how many substeps on each level?
1570 
1571  amrex::Vector<amrex::Real> t_new;
1572  amrex::Vector<amrex::Real> t_old;
1573  amrex::Vector<amrex::Real> dt;
1574 
1575  // Particle container
1576  std::unique_ptr<MultiParticleContainer> mypc;
1577  std::unique_ptr<MultiDiagnostics> multi_diags;
1578 
1579  //
1580  // Fields: First array for level, second for direction
1581  //
1582 
1583  // Full solution
1584  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_aux;
1585  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_aux;
1586 #ifdef WARPX_MAG_LLG
1587  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_aux;
1588  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_aux;
1589  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_aux;
1590 #endif
1591  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_aux;
1592  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_aux;
1593 
1594  // Fine patch
1595  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_fp;
1596  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_fp;
1597  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_fp;
1598  amrex::Vector< std::unique_ptr<amrex::MultiFab> > phi_fp;
1599  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_fp;
1600  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_fp_vay;
1601  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_fp;
1602  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_fp;
1603 #ifdef WARPX_MAG_LLG
1604  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_fp;
1605  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_fp;
1606  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_fp;
1607 #endif
1608  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_fp;
1609  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_fp;
1610 
1611  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_sc_fp;
1612  // Memory buffers for computing magnetostatic fields
1613  // Vector Potential A and previous step. Time buffer needed for computing dA/dt to first order
1614  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_fp_nodal;
1615  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_grad_buf_e_stag;
1616  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > vector_potential_grad_buf_b_stag;
1617 
1618  // Same as Bfield_fp/Efield_fp for reading external field data
1619  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_fp_external;
1620  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_fp_external;
1621 
1623  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_edge_lengths;
1625  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_face_areas;
1626 
1633  amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > m_flag_info_face;
1640  amrex::Vector<std::array< std::unique_ptr<amrex::iMultiFab>, 3 > > m_flag_ext_face;
1644  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > m_area_mod;
1648  amrex::Vector<std::array< std::unique_ptr<amrex::LayoutData<FaceInfoBox> >, 3 > > m_borrowing;
1649 
1657  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > ECTRhofield;
1661  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Venl;
1662 
1663  //EB level set
1664  amrex::Vector<std::unique_ptr<amrex::MultiFab> > m_distance_to_eb;
1665 
1666  // store fine patch
1667  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_store;
1668 
1669  // Nodal MultiFab for nodal current deposition if warpx.do_current_centering = 1
1670  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>> current_fp_nodal;
1671 
1672  // Coarse patch
1673  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_cp;
1674  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_cp;
1675  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_cp;
1676  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_cp;
1677  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_cp;
1678  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_cp;
1679 #ifdef WARPX_MAG_LLG
1680  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_cp;
1681  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_cp;
1682  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_cp;
1683 #endif
1684  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_avg_cp;
1685  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_avg_cp;
1686 
1687  // Copy of the coarse aux
1688  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Efield_cax;
1689  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_cax;
1690 #ifdef WARPX_MAG_LLG
1691  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Mfield_cax;
1692  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > Hfield_cax;
1693  amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>, 3 > > H_biasfield_cax;
1694 #endif
1695  amrex::Vector<std::unique_ptr<amrex::iMultiFab> > current_buffer_masks;
1696  amrex::Vector<std::unique_ptr<amrex::iMultiFab> > gather_buffer_masks;
1697 
1698  // If charge/current deposition buffers are used
1699  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_buf;
1700  amrex::Vector<std::unique_ptr<amrex::MultiFab> > charge_buf;
1701 
1702  // PML
1703  int do_pml = 0;
1704  int do_silver_mueller = 0;
1705  int pml_ncell = 10;
1706  int pml_delta = 10;
1707  int pml_has_particles = 0;
1708  int do_pml_j_damping = 0;
1709  int do_pml_in_domain = 0;
1710  static int do_similar_dm_pml;
1711  bool do_pml_dive_cleaning; // default set in WarpX.cpp
1712  bool do_pml_divb_cleaning; // default set in WarpX.cpp
1713  amrex::Vector<amrex::IntVect> do_pml_Lo;
1714  amrex::Vector<amrex::IntVect> do_pml_Hi;
1715  amrex::Vector<std::unique_ptr<PML> > pml;
1716 #if (defined WARPX_DIM_RZ) && (defined WARPX_USE_PSATD)
1717  amrex::Vector<std::unique_ptr<PML_RZ> > pml_rz;
1718 #endif
1719  amrex::Real v_particle_pml;
1720 
1721  amrex::Real moving_window_x = std::numeric_limits<amrex::Real>::max();
1722  amrex::Real current_injection_position = 0;
1723 
1724  // Plasma injection parameters
1725  int warpx_do_continuous_injection = 0;
1726  int num_injected_species = -1;
1727  amrex::Vector<int> injected_plasma_species;
1728 
1729  std::optional<amrex::Real> m_const_dt;
1730 
1731  // Macroscopic properties
1732  std::unique_ptr<MacroscopicProperties> m_macroscopic_properties;
1733  // London solver
1734  std::unique_ptr<London> m_london;
1735 
1736 
1737 #ifdef WARPX_MAG_LLG
1738  // time advancement scheme of M field
1739  int mag_time_scheme_order = 1;
1740 #endif
1741 
1742  // Load balancing
1745  utils::parser::IntervalsParser load_balance_intervals;
1748  amrex::Vector<std::unique_ptr<amrex::LayoutData<amrex::Real> > > costs;
1750  int load_balance_with_sfc = 0;
1755  amrex::Real load_balance_knapsack_factor = amrex::Real(1.24);
1761  amrex::Real load_balance_efficiency_ratio_threshold = amrex::Real(1.1);
1763  amrex::Vector<amrex::Real> load_balance_efficiency;
1769  amrex::Real costs_heuristic_cells_wt = amrex::Real(0);
1775  amrex::Real costs_heuristic_particles_wt = amrex::Real(0);
1776 
1777  // Determines timesteps for override sync
1778  utils::parser::IntervalsParser override_sync_intervals;
1779 
1780  // Other runtime parameters
1781  int verbose = 1;
1782 
1783  bool use_hybrid_QED = 0;
1784 
1785  int max_step = std::numeric_limits<int>::max();
1786  amrex::Real stop_time = std::numeric_limits<amrex::Real>::max();
1787 
1788  int regrid_int = -1;
1789 
1790  amrex::Real cfl = amrex::Real(0.999);
1791 
1792  std::string restart_chkfile;
1793 
1794  amrex::VisMF::Header::Version plotfile_headerversion = amrex::VisMF::Header::Version_v1;
1795  amrex::VisMF::Header::Version slice_plotfile_headerversion = amrex::VisMF::Header::Version_v1;
1796 
1797  bool use_single_read = true;
1798  bool use_single_write = true;
1799  int mffile_nstreams = 4;
1800  int field_io_nfiles = 1024;
1801  int particle_io_nfiles = 1024;
1802 
1803  amrex::RealVect fine_tag_lo;
1804  amrex::RealVect fine_tag_hi;
1805 
1806  bool is_synchronized = true;
1807 
1808  // Synchronization of nodal points
1809  const bool sync_nodal_points = true;
1810 
1811  guardCellManager guard_cells;
1812 
1813  //Slice Parameters
1814  int slice_max_grid_size;
1815  int slice_plot_int = -1;
1816  amrex::RealBox slice_realbox;
1817  amrex::IntVect slice_cr_ratio;
1818  amrex::Vector< std::unique_ptr<amrex::MultiFab> > F_slice;
1819  amrex::Vector< std::unique_ptr<amrex::MultiFab> > G_slice;
1820  amrex::Vector< std::unique_ptr<amrex::MultiFab> > rho_slice;
1821  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > current_slice;
1822  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Efield_slice;
1823  amrex::Vector<std::array< std::unique_ptr<amrex::MultiFab>, 3 > > Bfield_slice;
1824 
1825  bool fft_periodic_single_box = false;
1826  int nox_fft = 16;
1827  int noy_fft = 16;
1828  int noz_fft = 16;
1829 
1831  amrex::IntVect numprocs{0};
1832 
1834  std::unique_ptr<ParticleBoundaryBuffer> m_particle_boundary_buffer;
1835 
1836  // Accelerator lattice elements
1837  amrex::Vector< std::unique_ptr<AcceleratorLattice> > m_accelerator_lattice;
1838 
1839  //
1840  // Embedded Boundary
1841  //
1842 
1843  // Factory for field data
1844  amrex::Vector<std::unique_ptr<amrex::FabFactory<amrex::FArrayBox> > > m_field_factory;
1845 
1846  amrex::FabFactory<amrex::FArrayBox> const& fieldFactory (int lev) const noexcept {
1847  return *m_field_factory[lev];
1848  }
1849 #ifdef AMREX_USE_EB
1850 public:
1851  amrex::EBFArrayBoxFactory const& fieldEBFactory (int lev) const noexcept {
1852  return static_cast<amrex::EBFArrayBoxFactory const&>(*m_field_factory[lev]);
1853  }
1854 #endif
1855 
1856 public:
1857  void InitEB ();
1863 public:
1864 #ifdef AMREX_USE_EB
1865  static void ComputeEdgeLengths (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,
1866  const amrex::EBFArrayBoxFactory& eb_fact);
1871  static void ComputeFaceAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,
1872  const amrex::EBFArrayBoxFactory& eb_fact);
1873 
1877  static void ScaleEdges (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& edge_lengths,
1878  const std::array<amrex::Real,3>& cell_size);
1882  static void ScaleAreas (std::array< std::unique_ptr<amrex::MultiFab>, 3 >& face_areas,
1883  const std::array<amrex::Real,3>& cell_size);
1892  void MarkCells();
1896 #endif
1897  void ComputeDistanceToEB ();
1901  amrex::Array1D<int, 0, 2> CountExtFaces();
1906  void ComputeFaceExtensions();
1910  void InitBorrowing();
1914  void ShrinkBorrowing();
1918  void ComputeOneWayExtensions();
1922  void ComputeEightWaysExtensions();
1931  void ApplyBCKCorrection(const int idim);
1932 
1937  void PSATDSubtractCurrentPartialSumsAvg ();
1938 
1939 private:
1940  void ScrapeParticles ();
1941 
1942  void PushPSATD ();
1943 
1944 #ifdef WARPX_USE_PSATD
1945 
1958  void PSATDForwardTransformEB (
1959  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_fp,
1960  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_fp,
1961  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_cp,
1962  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_cp);
1963 
1977  void PSATDBackwardTransformEB (
1978  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_fp,
1979  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_fp,
1980  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_cp,
1981  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_cp);
1982 
1995  void PSATDBackwardTransformEBavg (
1996  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_avg_fp,
1997  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_avg_fp,
1998  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& E_avg_cp,
1999  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& B_avg_cp);
2000 
2012  void PSATDForwardTransformJ (
2013  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
2014  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp,
2015  const bool apply_kspace_filter=true);
2016 
2025  void PSATDBackwardTransformJ (
2026  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_fp,
2027  const amrex::Vector<std::array<std::unique_ptr<amrex::MultiFab>,3>>& J_cp);
2028 
2040  void PSATDForwardTransformRho (
2041  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_fp,
2042  const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& charge_cp,
2043  const int icomp, const int dcomp, const bool apply_kspace_filter=true);
2044 
2048  void PSATDMoveRhoNewToRhoOld ();
2049 
2053  void PSATDMoveJNewToJOld ();
2054 
2058  void PSATDForwardTransformF ();
2059 
2063  void PSATDBackwardTransformF ();
2064 
2068  void PSATDForwardTransformG ();
2069 
2073  void PSATDBackwardTransformG ();
2074 
2078  void PSATDCurrentCorrection ();
2079 
2083  void PSATDVayDeposition ();
2084 
2088  void PSATDPushSpectralFields ();
2089 
2095  void PSATDScaleAverageFields (const amrex::Real scale_factor);
2096 
2100  void PSATDEraseAverageFields ();
2101 
2102 # ifdef WARPX_DIM_RZ
2103  amrex::Vector<std::unique_ptr<SpectralSolverRZ>> spectral_solver_fp;
2104  amrex::Vector<std::unique_ptr<SpectralSolverRZ>> spectral_solver_cp;
2105 # else
2106  amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_fp;
2107  amrex::Vector<std::unique_ptr<SpectralSolver>> spectral_solver_cp;
2108 # endif
2109 
2110 public:
2111 
2112 # ifdef WARPX_DIM_RZ
2113  SpectralSolverRZ&
2114 # else
2115  SpectralSolver&
2116 # endif
2117  get_spectral_solver_fp (int lev) {return *spectral_solver_fp[lev];}
2118 #endif
2119 
2120 private:
2121  amrex::Vector<std::unique_ptr<FiniteDifferenceSolver>> m_fdtd_solver_fp;
2122  amrex::Vector<std::unique_ptr<FiniteDifferenceSolver>> m_fdtd_solver_cp;
2123 
2124 };
2125 
2126 #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:73
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
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:80
WarpX::Bfield_avg_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_aux
Definition: WarpX.H:1592
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:1225
WarpX::m_particle_boundary_buffer
std::unique_ptr< ParticleBoundaryBuffer > m_particle_boundary_buffer
particle buffer for scraped particles on the boundaries
Definition: WarpX.H:1834
WarpX::self_fields_max_iters
static int self_fields_max_iters
Definition: WarpX.H:1094
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:692
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:387
WarpX::costs
amrex::Vector< std::unique_ptr< amrex::LayoutData< amrex::Real > > > costs
Definition: WarpX.H:1748
WarpX::current_deposition_algo
static short current_deposition_algo
Integer that corresponds to the current deposition algorithm (Esirkepov, direct, Vay)
Definition: WarpX.H:278
WarpX::Bzfield_flag_parser
std::unique_ptr< amrex::Parser > Bzfield_flag_parser
Definition: WarpX.H:251
WarpX::G_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_fp
Definition: WarpX.H:1596
WarpX::device_field_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_y
Definition: WarpX.H:1292
WarpX::moving_window_dir
static int moving_window_dir
Definition: WarpX.H:1110
WarpX::device_current_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_x
Definition: WarpX.H:1296
WarpX::Eyfield_flag_parser
std::unique_ptr< amrex::Parser > Eyfield_flag_parser
Definition: WarpX.H:247
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:3129
WarpX::str_Bx_excitation_flag_function
static std::string str_Bx_excitation_flag_function
Definition: WarpX.H:187
WarpX::use_hybrid_QED
bool use_hybrid_QED
Definition: WarpX.H:1783
WarpX::do_dive_cleaning
static bool do_dive_cleaning
Definition: WarpX.H:375
WarpX::zmax_plasma_to_compute_max_step
static amrex::Real zmax_plasma_to_compute_max_step
Definition: WarpX.H:445
WarpX::doFieldIonization
void doFieldIonization()
Definition: WarpXEvolve.cpp:1017
WarpX::get_pointer_edge_lengths
amrex::MultiFab * get_pointer_edge_lengths(int lev, int direction) const
Definition: WarpX.H:661
WarpX::str_Bz_excitation_grid_function
static std::string str_Bz_excitation_grid_function
Definition: WarpX.H:168
WarpX::get_ng_fieldgather
const amrex::IntVect get_ng_fieldgather() const
Definition: WarpX.H:1130
WarpX::str_By_excitation_flag_function
static std::string str_By_excitation_flag_function
Definition: WarpX.H:188
WarpX::get_pointer_Efield_fp
amrex::MultiFab * get_pointer_Efield_fp(int lev, int direction) const
Definition: WarpX.H:631
WarpX::getEfield_fp
const amrex::MultiFab & getEfield_fp(int lev, int direction)
Definition: WarpX.H:684
WarpX::getngEB
const amrex::IntVect getngEB() const
Definition: WarpX.H:1125
WarpX::Version
static std::string Version()
Version of WarpX executable.
Definition: WarpXVersion.cpp:14
WarpX::getnsubsteps
amrex::Vector< int > getnsubsteps() const
Definition: WarpX.H:1032
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:469
WarpX::m_macroscopic_properties
std::unique_ptr< MacroscopicProperties > m_macroscopic_properties
Definition: WarpX.H:1732
WarpX::GetMultiDiags
MultiDiagnostics & GetMultiDiags()
Definition: WarpX.H:103
WarpX::DoPML
bool DoPML() const
Definition: WarpX.H:702
WarpX::getcurrent_cp
const amrex::MultiFab & getcurrent_cp(int lev, int direction)
Definition: WarpX.H:671
WarpX::rho_in_time
static short rho_in_time
Definition: WarpX.H:327
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:1706
WarpX::m_field_factory
amrex::Vector< std::unique_ptr< amrex::FabFactory< amrex::FArrayBox > > > m_field_factory
Definition: WarpX.H:1844
WarpX::getis_synchronized
bool getis_synchronized() const
Definition: WarpX.H:1047
WarpX::do_pml_j_damping
int do_pml_j_damping
Definition: WarpX.H:1708
WarpX::noy_fft
int noy_fft
Definition: WarpX.H:1827
WarpX::current_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_cp
Definition: WarpX.H:1676
WarpX::m_distance_to_eb
amrex::Vector< std::unique_ptr< amrex::MultiFab > > m_distance_to_eb
Definition: WarpX.H:1664
WarpX::Efield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_slice
Definition: WarpX.H:1822
WarpX::Bfield_sc_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_sc_fp
Definition: WarpX.H:1611
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:1591
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:159
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:1196
WarpX::m_v_galilean
amrex::Vector< amrex::Real > m_v_galilean
Definition: WarpX.H:741
WarpX::DampJPML
void DampJPML()
Definition: WarpXEvolvePML.cpp:254
WarpX::psatd_solution_type
static short psatd_solution_type
Definition: WarpX.H:322
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:1696
WarpX::updateStopTime
void updateStopTime(const amrex::Real new_stop_time)
Definition: WarpX.H:1052
WarpX::get_array_Efield_aux
std::array< const amrex::MultiFab *const, 3 > get_array_Efield_aux(const int lev) const
Definition: WarpX.H:590
WarpX::mirror_z_npoints
amrex::Vector< int > mirror_z_npoints
Definition: WarpX.H:749
WarpX::zmin_domain_boost_step_0
static amrex::Real zmin_domain_boost_step_0
Definition: WarpX.H:452
WarpX::current_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_slice
Definition: WarpX.H:1821
WarpX::GatherBufferMasks
static const amrex::iMultiFab * GatherBufferMasks(int lev)
Definition: WarpX.cpp:3313
WarpX::do_compute_max_step_from_zmax
static bool do_compute_max_step_from_zmax
Definition: WarpX.H:449
WarpX::field_boundary_lo
static amrex::Vector< int > field_boundary_lo
Definition: WarpX.H:301
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:464
WarpX::get_spectral_solver_fp
SpectralSolverRZ & get_spectral_solver_fp(int lev)
Definition: WarpX.H:2117
WarpX::Ezfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Ezfield_xt_grid_parser
Definition: WarpX.H:235
WarpX::n_field_gather_buffer
static int n_field_gather_buffer
Definition: WarpX.H:478
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:470
WarpX::current_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_nodal
Definition: WarpX.H:1670
WarpX::MacroscopicEvolveE
void MacroscopicEvolveE(amrex::Real dt)
Definition: WarpXPushFieldsEM.cpp:1059
WarpX::t_new
amrex::Vector< amrex::Real > t_new
Definition: WarpX.H:1571
WarpX::do_single_precision_comms
static bool do_single_precision_comms
perform field communications in single precision
Definition: WarpX.H:353
WarpX::slice_cr_ratio
amrex::IntVect slice_cr_ratio
Definition: WarpX.H:1817
WarpX::SyncCurrentAndRho
void SyncCurrentAndRho()
Synchronize J and rho: filter (if used), exchange guard cells, interpolate across MR levels....
Definition: WarpXEvolve.cpp:602
WarpX::field_io_nfiles
int field_io_nfiles
Definition: WarpX.H:1800
WarpX::particle_boundary_lo
static amrex::Vector< ParticleBoundaryType > particle_boundary_lo
Definition: WarpX.H:311
WarpX::AddSpaceChargeFieldLabFrame
void AddSpaceChargeFieldLabFrame()
Definition: ElectrostaticSolver.cpp:194
WarpX::B_external_grid
static amrex::Vector< amrex::Real > B_external_grid
Initial magnetic field on the grid.
Definition: WarpX.H:120
WarpX::Exfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Exfield_xt_grid_parser
Definition: WarpX.H:233
WarpX::current_store
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_store
Definition: WarpX.H:1667
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:1811
WarpX::do_shared_mem_charge_deposition
static bool do_shared_mem_charge_deposition
used shared memory algorithm for charge deposition
Definition: WarpX.H:356
WarpX::slice_plotfile_headerversion
amrex::VisMF::Header::Version slice_plotfile_headerversion
Definition: WarpX.H:1795
WarpX::em_solver_medium
static int em_solver_medium
Integer that corresponds to electromagnetic Maxwell solver (vacuum - 0, macroscopic - 1)
Definition: WarpX.H:292
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:1786
WarpX::GetPartContainer
MultiParticleContainer & GetPartContainer()
Definition: WarpX.H:100
WarpX::boost_direction
static amrex::Vector< int > boost_direction
Direction of the Lorentz transform that defines the boosted frame of the simulation.
Definition: WarpX.H:441
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:410
WarpX::verboncoeur_axis_correction
static bool verboncoeur_axis_correction
Definition: WarpX.H:424
WarpX::moving_window_v
static amrex::Real moving_window_v
Definition: WarpX.H:1111
WarpX::do_shared_mem_current_deposition
static bool do_shared_mem_current_deposition
use shared memory algorithm for current deposition
Definition: WarpX.H:359
WarpX::do_pml_Hi
amrex::Vector< amrex::IntVect > do_pml_Hi
Definition: WarpX.H:1714
WarpX::setistep
void setistep(int lev, int ii)
Definition: WarpX.H:1036
WarpX::get_pointer_vector_potential_fp
amrex::MultiFab * get_pointer_vector_potential_fp(int lev, int direction) const
Definition: WarpX.H:647
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:3170
WarpX::fft_do_time_averaging
static bool fft_do_time_averaging
Definition: WarpX.H:1112
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:284
WarpX::ClearLevel
virtual void ClearLevel(int lev) final
Delete level data. Called by AmrCore::regrid.
Definition: WarpX.cpp:1980
WarpX::pml
amrex::Vector< std::unique_ptr< PML > > pml
Definition: WarpX.H:1715
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:1803
WarpX::restart_chkfile
std::string restart_chkfile
Definition: WarpX.H:1792
WarpX::m_instance
static WarpX * m_instance
Definition: WarpX.H:1364
WarpX::getG_fp
const amrex::MultiFab & getG_fp(int lev)
Definition: WarpX.H:695
WarpX::rho_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_cp
Definition: WarpX.H:1675
WarpX::get_pointer_G_fp
amrex::MultiFab * get_pointer_G_fp(int lev) const
Definition: WarpX.H:645
WarpX::getRealBox
static amrex::RealBox getRealBox(const amrex::Box &bx, int lev)
Definition: WarpX.cpp:2922
WarpX::do_dynamic_scheduling
static bool do_dynamic_scheduling
Definition: WarpX.H:457
WarpX::PostRestart
void PostRestart()
WarpX::ApplyExcitationInPML
static int ApplyExcitationInPML
Definition: WarpX.H:146
WarpX::getBfield_cp
const amrex::MultiFab & getBfield_cp(int lev, int direction)
Definition: WarpX.H:673
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:3235
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:172
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:2908
WarpX::E_ext_grid_s
static std::string E_ext_grid_s
Initialization type for external electric field on the grid.
Definition: WarpX.H:131
WarpX::device_field_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_z
Definition: WarpX.H:1293
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:3248
WarpX::get_pointer_phi_fp
amrex::MultiFab * get_pointer_phi_fp(int lev) const
Definition: WarpX.H:646
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:1095
WarpX::stopTime
amrex::Real stopTime() const
Definition: WarpX.H:1051
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:217
WarpX::pml_rz
amrex::Vector< std::unique_ptr< PML_RZ > > pml_rz
Definition: WarpX.H:1717
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:693
WarpX::m_v_comoving
amrex::Vector< amrex::Real > m_v_comoving
Definition: WarpX.H:744
WarpX::InitData
void InitData()
WarpX::multifab_map
static std::map< std::string, amrex::MultiFab * > multifab_map
Definition: WarpX.H:558
WarpX::RestoreCurrent
void RestoreCurrent(const int lev)
Definition: WarpX.cpp:3330
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:742
WarpX::device_field_centering_stencil_coeffs_x
amrex::Gpu::DeviceVector< amrex::Real > device_field_centering_stencil_coeffs_x
Definition: WarpX.H:1291
WarpX::get_pointer_current_fp
amrex::MultiFab * get_pointer_current_fp(int lev, int direction) const
Definition: WarpX.H:641
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:1129
WarpX::get_pointer_current_cp
amrex::MultiFab * get_pointer_current_cp(int lev, int direction) const
Definition: WarpX.H:656
WarpX::str_Bx_excitation_grid_function
static std::string str_Bx_excitation_grid_function
Definition: WarpX.H:166
WarpX::getdt
amrex::Vector< amrex::Real > getdt() const
Definition: WarpX.H:1042
WarpX::noz
static int noz
Order of the particle shape factors (splines) along z.
Definition: WarpX.H:384
WarpX::E_excitation_grid_s
static std::string E_excitation_grid_s
Definition: WarpX.H:135
WarpX::device_current_centering_stencil_coeffs_z
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_z
Definition: WarpX.H:1298
WarpX::gett_new
amrex::Vector< amrex::Real > gett_new() const
Definition: WarpX.H:1039
WarpX::getBfield_avg_cp
const amrex::MultiFab & getBfield_avg_cp(int lev, int direction)
Definition: WarpX.H:700
WarpX::mffile_nstreams
int mffile_nstreams
Definition: WarpX.H:1799
WarpX::num_mirrors
static int num_mirrors
Definition: WarpX.H:746
WarpX::getPMLdirections
std::vector< bool > getPMLdirections() const
Definition: WarpX.cpp:3099
WarpX::str_Ex_excitation_flag_function
static std::string str_Ex_excitation_flag_function
Definition: WarpX.H:184
WarpX::get_pointer_face_areas
amrex::MultiFab * get_pointer_face_areas(int lev, int direction) const
Definition: WarpX.H:662
WarpX::phi_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > phi_fp
Definition: WarpX.H:1598
WarpX::AddMagnetostaticFieldLabFrame
void AddMagnetostaticFieldLabFrame()
Definition: MagnetostaticSolver.cpp:71
WarpX::GetParticleBoundaryBuffer
ParticleBoundaryBuffer & GetParticleBoundaryBuffer()
Definition: WarpX.H:105
WarpX::WriteUsedInputsFile
void WriteUsedInputsFile() const
WarpX::AddSpaceChargeField
void AddSpaceChargeField(WarpXParticleContainer &pc)
Definition: ElectrostaticSolver.cpp:140
WarpX::OneStep_nosub
void OneStep_nosub(amrex::Real t)
Definition: WarpXEvolve.cpp:418
WarpX::do_pml_divb_cleaning
bool do_pml_divb_cleaning
Definition: WarpX.H:1712
WarpX::getistep
amrex::Vector< int > getistep() const
Definition: WarpX.H:1034
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:396
WarpX::str_By_excitation_grid_function
static std::string str_By_excitation_grid_function
Definition: WarpX.H:167
WarpX::ReadParameters
void ReadParameters()
Definition: WarpX.cpp:580
WarpX::ResetInstance
static void ResetInstance()
Definition: WarpX.cpp:316
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:567
WarpX::verbose
int verbose
Definition: WarpX.H:1781
WarpX::device_current_centering_stencil_coeffs_y
amrex::Gpu::DeviceVector< amrex::Real > device_current_centering_stencil_coeffs_y
Definition: WarpX.H:1297
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:148
WarpX::get_pointer_Efield_aux
amrex::MultiFab * get_pointer_Efield_aux(int lev, int direction) const
Definition: WarpX.H:624
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:1684
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:679
WarpX::load_balance_knapsack_factor
amrex::Real load_balance_knapsack_factor
Definition: WarpX.H:1755
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:1763
WarpX::self_fields_required_precision
static amrex::Real self_fields_required_precision
Definition: WarpX.H:1092
WarpX::sort_bin_size
static amrex::IntVect sort_bin_size
Definition: WarpX.H:461
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:153
WarpX::m_rho_nodal_flag
amrex::IntVect m_rho_nodal_flag
Definition: WarpX.H:489
WarpX::imultifab_map
static std::map< std::string, amrex::iMultiFab * > imultifab_map
Definition: WarpX.H:559
WarpX::load_balance_intervals
utils::parser::IntervalsParser load_balance_intervals
Definition: WarpX.H:1745
WarpX::m_flag_ext_face
amrex::Vector< std::array< std::unique_ptr< amrex::iMultiFab >, 3 > > m_flag_ext_face
Definition: WarpX.H:1640
WarpX::current_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp
Definition: WarpX.H:1599
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:2930
WarpX::override_sync_intervals
utils::parser::IntervalsParser override_sync_intervals
Definition: WarpX.H:1778
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:215
WarpX::getLondon
London & getLondon()
Definition: WarpX.H:102
WarpX::isAnyBoundaryPML
bool isAnyBoundaryPML()
Definition: WarpX.cpp:3340
WarpX::get_load_balance_intervals
utils::parser::IntervalsParser get_load_balance_intervals() const
returns the load balance interval
Definition: WarpX.H:853
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:1625
WarpX::gett_old
amrex::Real gett_old(int lev) const
Definition: WarpX.H:1038
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:221
WarpX::Bfield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_cax
Definition: WarpX.H:1689
WarpX::get_pointer_F_cp
amrex::MultiFab * get_pointer_F_cp(int lev) const
Definition: WarpX.H:658
WarpX::get_pointer_Bfield_sc_fp
amrex::MultiFab * get_pointer_Bfield_sc_fp(int lev, int direction) const
Definition: WarpX.H:633
WarpX::getF_fp
const amrex::MultiFab & getF_fp(int lev)
Definition: WarpX.H:694
WarpX::Exfield_flag_parser
std::unique_ptr< amrex::Parser > Exfield_flag_parser
Definition: WarpX.H:246
WarpX::StoreCurrent
void StoreCurrent(const int lev)
Definition: WarpX.cpp:3319
WarpX::do_moving_window
static int do_moving_window
Definition: WarpX.H:1097
WarpX::MakeNewLevelFromCoarse
virtual void MakeNewLevelFromCoarse(int, amrex::Real, const amrex::BoxArray &, const amrex::DistributionMapping &) final
Definition: WarpX.cpp:1973
WarpX::moving_window_x
amrex::Real moving_window_x
Definition: WarpX.H:1721
WarpX::get_pointer_Efield_cp
amrex::MultiFab * get_pointer_Efield_cp(int lev, int direction) const
Definition: WarpX.H:649
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:155
WarpX::maxStep
int maxStep() const
Definition: WarpX.H:1049
WarpX::nox
static int nox
Order of the particle shape factors (splines) along x.
Definition: WarpX.H:380
WarpX::getnsubsteps
int getnsubsteps(int lev) const
Definition: WarpX.H:1033
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:3350
WarpX::quantum_xi_c2
static amrex::Real quantum_xi_c2
Definition: WarpX.H:842
WarpX::getngF
const amrex::IntVect getngF() const
Definition: WarpX.H:1126
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:3192
WarpX::AllocLevelData
void AllocLevelData(int lev, const amrex::BoxArray &new_grids, const amrex::DistributionMapping &new_dmap)
Definition: WarpX.cpp:2061
WarpX::Bfield_slice
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_slice
Definition: WarpX.H:1823
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:1633
WarpX::current_fp_vay
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_fp_vay
Definition: WarpX.H:1600
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:577
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:1050
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:1678
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:434
WarpX::getGatherBufferMasks
const amrex::iMultiFab * getGatherBufferMasks(int lev) const
Definition: WarpX.H:1510
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:219
WarpX::doQEDEvents
void doQEDEvents()
Definition: WarpXEvolve.cpp:1034
WarpX::spectral_solver_fp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_fp
Definition: WarpX.H:2103
WarpX::ApplyInverseVolumeScalingToChargeDensity
void ApplyInverseVolumeScalingToChargeDensity(amrex::MultiFab *Rho, int lev)
Definition: WarpXPushFieldsEM.cpp:1546
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:368
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:486
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:1616
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:1584
WarpX::getEfield_cp
const amrex::MultiFab & getEfield_cp(int lev, int direction)
Definition: WarpX.H:672
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:394
WarpX::get_pointer_Bfield_aux
amrex::MultiFab * get_pointer_Bfield_aux(int lev, int direction) const
Definition: WarpX.H:625
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:431
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:1615
WarpX::m_borrowing
amrex::Vector< std::array< std::unique_ptr< amrex::LayoutData< FaceInfoBox > >, 3 > > m_borrowing
Definition: WarpX.H:1648
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:150
WarpX::charge_deposition_algo
static short charge_deposition_algo
Integer that corresponds to the charge deposition algorithm (only standard deposition)
Definition: WarpX.H:280
WarpX::PushParticlesandDepose
void PushParticlesandDepose(int lev, amrex::Real cur_time, DtType a_dt_type=DtType::Full, bool skip_current=false)
Definition: WarpXEvolve.cpp:1061
WarpX::cfl
amrex::Real cfl
Definition: WarpX.H:1790
WarpX::str_Ey_excitation_flag_function
static std::string str_Ey_excitation_flag_function
Definition: WarpX.H:185
WarpX::str_Ez_excitation_flag_function
static std::string str_Ez_excitation_flag_function
Definition: WarpX.H:186
WarpX::gett_new
amrex::Real gett_new(int lev) const
Definition: WarpX.H:1040
WarpX::dt
amrex::Vector< amrex::Real > dt
Definition: WarpX.H:1573
WarpX::rho_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_slice
Definition: WarpX.H:1820
WarpX::F_cp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_cp
Definition: WarpX.H:1673
WarpX::Bzfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Bzfield_xt_grid_parser
Definition: WarpX.H:231
WarpX::nox_fft
int nox_fft
Definition: WarpX.H:1826
WarpX::UpdateAuxilaryData
void UpdateAuxilaryData()
Definition: WarpXComm.cpp:53
WarpX::particle_io_nfiles
int particle_io_nfiles
Definition: WarpX.H:1801
WarpX::is_synchronized
bool is_synchronized
Definition: WarpX.H:1806
WarpX::current_injection_position
amrex::Real current_injection_position
Definition: WarpX.H:1722
WarpX::GetInstance
static WarpX & GetInstance()
Definition: WarpX.cpp:307
WarpX::getcurrent_injection_position
amrex::Real getcurrent_injection_position() const
Definition: WarpX.H:1046
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:1804
WarpX::getBfield_sc_fp
const amrex::MultiFab & getBfield_sc_fp(int lev, int direction)
Definition: WarpX.H:686
WarpX::start_moving_window_step
static int start_moving_window_step
Definition: WarpX.H:1098
WarpX::GetPML_RZ
PML_RZ * GetPML_RZ(int lev)
Definition: WarpX.cpp:3076
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:1704
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:1568
WarpX::electrostatic_solver_id
static int electrostatic_solver_id
Definition: WarpX.H:1089
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:170
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:1305
WarpX::HandleSignals
void HandleSignals()
Complete the asynchronous broadcast of signal flags, and initiate a checkpoint if requested.
Definition: WarpXEvolve.cpp:1202
WarpX::G_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > G_slice
Definition: WarpX.H:1819
WarpX::n_current_deposition_buffer
static int n_current_deposition_buffer
Definition: WarpX.H:482
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:3386
WarpX::Bxfield_flag_parser
std::unique_ptr< amrex::Parser > Bxfield_flag_parser
Definition: WarpX.H:249
WarpX::F_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_fp
Definition: WarpX.H:1595
WarpX::field_boundary_hi
static amrex::Vector< int > field_boundary_hi
Definition: WarpX.H:306
WarpX::UpdateAuxilaryDataStagToNodal
void UpdateAuxilaryDataStagToNodal()
Definition: WarpXComm.cpp:65
WarpX::Byfield_flag_parser
std::unique_ptr< amrex::Parser > Byfield_flag_parser
Definition: WarpX.H:250
WarpX::Verbose
int Verbose() const
Definition: WarpX.H:94
WarpX::Efield_cax
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_cax
Definition: WarpX.H:1688
WarpX::Eyfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Eyfield_xt_grid_parser
Definition: WarpX.H:234
WarpX::charge_buf
amrex::Vector< std::unique_ptr< amrex::MultiFab > > charge_buf
Definition: WarpX.H:1700
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:582
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:1623
WarpX::getCurrentBufferMasks
const amrex::iMultiFab * getCurrentBufferMasks(int lev) const
Definition: WarpX.H:1507
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:1608
WarpX::injected_plasma_species
amrex::Vector< int > injected_plasma_species
Definition: WarpX.H:1727
WarpX::do_device_synchronize
static bool do_device_synchronize
Definition: WarpX.H:472
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:429
WarpX::get_pointer_F_fp
amrex::MultiFab * get_pointer_F_fp(int lev) const
Definition: WarpX.H:644
WarpX::InitNCICorrector
void InitNCICorrector()
WarpX::getistep
int getistep(int lev) const
Definition: WarpX.H:1035
WarpX::multi_diags
std::unique_ptr< MultiDiagnostics > multi_diags
Definition: WarpX.H:1577
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:225
WarpX::noy
static int noy
Order of the particle shape factors (splines) along y.
Definition: WarpX.H:382
WarpX::EvolveEM
void EvolveEM(int numsteps)
WarpX::nsubsteps
amrex::Vector< int > nsubsteps
Definition: WarpX.H:1569
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:1828
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:391
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:1041
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:1761
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:439
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:1619
WarpX::ComputeDivE
void ComputeDivE(amrex::MultiFab &divE, const int lev)
Definition: WarpX.cpp:3060
WarpX::get_pointer_G_cp
amrex::MultiFab * get_pointer_G_cp(int lev) const
Definition: WarpX.H:659
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:377
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::ApplyExternalFieldExcitationOnGrid
void ApplyExternalFieldExcitationOnGrid(amrex::MultiFab *mfx, amrex::MultiFab *mfy, amrex::MultiFab *mfz, amrex::ParserExecutor< 4 > const &xfield_parser, amrex::ParserExecutor< 4 > const &yfield_parser, amrex::ParserExecutor< 4 > const &zfield_parser, amrex::ParserExecutor< 3 > const &xflag_parser, amrex::ParserExecutor< 3 > const &yflag_parser, amrex::ParserExecutor< 3 > const &zflag_parser, const int lev, DtType a_dt_type)
WarpX::WarpX
WarpX()
Definition: WarpX.cpp:322
WarpX::get_ng_depos_J
const amrex::IntVect get_ng_depos_J() const
Definition: WarpX.H:1128
WarpX::load_balance_with_sfc
int load_balance_with_sfc
Definition: WarpX.H:1750
WarpX::getLoadBalanceEfficiency
amrex::Real getLoadBalanceEfficiency(const int lev)
Definition: WarpX.H:724
WarpX::mypc
std::unique_ptr< MultiParticleContainer > mypc
Definition: WarpX.H:1576
WarpX::current_buf
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > current_buf
Definition: WarpX.H:1699
WarpX::use_filter
static bool use_filter
If true, a bilinear filter is used to smooth charge and currents.
Definition: WarpX.H:427
WarpX::get_pointer_rho_fp
amrex::MultiFab * get_pointer_rho_fp(int lev) const
Definition: WarpX.H:643
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:371
WarpX::GetMacroscopicProperties
MacroscopicProperties & GetMacroscopicProperties()
Definition: WarpX.H:101
WarpX::m_vector_poisson_boundary_handler
MagnetostaticSolver::VectorPoissonBoundaryHandler m_vector_poisson_boundary_handler
Definition: WarpX.H:1166
WarpX::getG_cp
const amrex::MultiFab & getG_cp(int lev)
Definition: WarpX.H:681
WarpX::vector_potential_fp_nodal
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > vector_potential_fp_nodal
Definition: WarpX.H:1614
WarpX::m_poisson_boundary_handler
ElectrostaticSolver::PoissonBoundaryHandler m_poisson_boundary_handler
Definition: WarpX.H:1141
WarpX::shared_tilesize
static amrex::IntVect shared_tilesize
tileSize to use for shared current deposition operations
Definition: WarpX.H:365
WarpX::do_similar_dm_pml
static int do_similar_dm_pml
Definition: WarpX.H:1710
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:161
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:2121
WarpX::ApplyInverseVolumeScalingToCurrentDensity
void ApplyInverseVolumeScalingToCurrentDensity(amrex::MultiFab *Jx, amrex::MultiFab *Jy, amrex::MultiFab *Jz, int lev)
Definition: WarpXPushFieldsEM.cpp:1373
WarpX::gett_old
amrex::Vector< amrex::Real > gett_old() const
Definition: WarpX.H:1037
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:398
WarpX::safe_guard_cells
static bool safe_guard_cells
Definition: WarpX.H:473
WarpX::str_Ey_excitation_grid_function
static std::string str_Ey_excitation_grid_function
Definition: WarpX.H:171
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:1677
WarpX::rho_fp
amrex::Vector< std::unique_ptr< amrex::MultiFab > > rho_fp
Definition: WarpX.H:1597
WarpX::slice_plot_int
int slice_plot_int
Definition: WarpX.H:1815
WarpX::get_pointer_rho_cp
amrex::MultiFab * get_pointer_rho_cp(int lev) const
Definition: WarpX.H:657
WarpX::InitEB
void InitEB()
Definition: WarpXInitEB.cpp:81
WarpX::BackwardCompatibility
void BackwardCompatibility()
Definition: WarpX.cpp:1722
WarpX::Bfield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp
Definition: WarpX.H:1602
WarpX::ECTRhofield
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > ECTRhofield
Definition: WarpX.H:1657
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:1726
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:2818
WarpX::t_old
amrex::Vector< amrex::Real > t_old
Definition: WarpX.H:1572
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:466
WarpX::regrid_int
int regrid_int
Definition: WarpX.H:1788
WarpX::use_single_write
bool use_single_write
Definition: WarpX.H:1798
WarpX::refine_plasma
static bool refine_plasma
Definition: WarpX.H:458
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:1846
WarpX::macroscopic_solver_algo
static int macroscopic_solver_algo
Definition: WarpX.H:296
WarpX::use_single_read
bool use_single_read
Definition: WarpX.H:1797
WarpX::Bfield_aux
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_aux
Definition: WarpX.H:1585
WarpX::numprocs
amrex::IntVect numprocs
Domain decomposition on Level 0.
Definition: WarpX.H:1831
WarpX::ncomps
static int ncomps
Definition: WarpX.H:406
WarpX::yee_coupled_solver_algo
static int yee_coupled_solver_algo
Definition: WarpX.H:317
WarpX::moving_window_active
static int moving_window_active(int const step)
Definition: WarpX.H:1105
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:1809
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:1127
WarpX::FillBoundaryJ
void FillBoundaryJ(amrex::IntVect ng)
Definition: WarpXComm.cpp:530
WarpX::warpx_do_continuous_injection
int warpx_do_continuous_injection
Definition: WarpX.H:1725
WarpX::galerkin_interpolation
static bool galerkin_interpolation
Definition: WarpX.H:420
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:163
WarpX::do_pml_in_domain
int do_pml_in_domain
Definition: WarpX.H:1709
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:738
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:1644
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:2141
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:1964
WarpX::filter_npass_each_dir
static amrex::IntVect filter_npass_each_dir
Definition: WarpX.H:735
WarpX::getBfield_fp
const amrex::MultiFab & getBfield_fp(int lev, int direction)
Definition: WarpX.H:685
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:1661
WarpX::setLoadBalanceEfficiency
void setLoadBalanceEfficiency(const int lev, const amrex::Real efficiency)
Definition: WarpX.H:713
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:286
WarpX::InitPML
void InitPML()
WarpX::GetPML
PML * GetPML(int lev)
Definition: WarpX.cpp:3088
WarpX::Bxfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Bxfield_xt_grid_parser
Definition: WarpX.H:229
WarpX::v_particle_pml
amrex::Real v_particle_pml
Definition: WarpX.H:1719
WarpX::OneStep_sub1
void OneStep_sub1(amrex::Real t)
Definition: WarpXEvolve.cpp:858
WarpX::m_london
std::unique_ptr< London > m_london
Definition: WarpX.H:1734
WarpX::bilinear_filter
BilinearFilter bilinear_filter
Definition: WarpX.H:736
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:642
WarpX::fft_periodic_single_box
bool fft_periodic_single_box
Definition: WarpX.H:1825
WarpX::getEfield_avg_fp
const amrex::MultiFab & getEfield_avg_fp(int lev, int direction)
Definition: WarpX.H:697
WarpX::Bfield_avg_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_fp
Definition: WarpX.H:1609
WarpX::getBfield_avg_fp
const amrex::MultiFab & getBfield_avg_fp(int lev, int direction)
Definition: WarpX.H:698
WarpX::getCosts
static amrex::LayoutData< amrex::Real > * getCosts(int lev)
Definition: WarpX.cpp:3117
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:389
WarpX::do_pml
int do_pml
Definition: WarpX.H:1703
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:157
WarpX::getdt
amrex::Real getdt(int lev) const
Definition: WarpX.H:1043
WarpX::Bfield_fp_external
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_fp_external
Definition: WarpX.H:1620
WarpX::RefRatio
static amrex::IntVect RefRatio(int lev)
Definition: WarpX.cpp:2980
WarpX::max_step
int max_step
Definition: WarpX.H:1785
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:699
WarpX::costs_heuristic_particles_wt
amrex::Real costs_heuristic_particles_wt
Definition: WarpX.H:1775
WarpX::pml_has_particles
int pml_has_particles
Definition: WarpX.H:1707
WarpX::nci_godfrey_filter_exeybz
amrex::Vector< std::unique_ptr< NCIGodfreyFilter > > nci_godfrey_filter_exeybz
Definition: WarpX.H:737
WarpX::do_current_centering
static bool do_current_centering
Definition: WarpX.H:342
WarpX::Byfield_xt_grid_parser
std::unique_ptr< amrex::Parser > Byfield_xt_grid_parser
Definition: WarpX.H:230
WarpX::mirror_z
amrex::Vector< amrex::Real > mirror_z
Definition: WarpX.H:747
WarpX::F_slice
amrex::Vector< std::unique_ptr< amrex::MultiFab > > F_slice
Definition: WarpX.H:1818
WarpX::getdo_moving_window
int getdo_moving_window() const
Definition: WarpX.H:1044
WarpX::do_subcycling
static bool do_subcycling
Definition: WarpX.H:468
WarpX::pml_ncell
int pml_ncell
Definition: WarpX.H:1705
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:2986
WarpX::n_rz_azimuthal_modes
static int n_rz_azimuthal_modes
Number of modes for the RZ multi-mode version.
Definition: WarpX.H:401
WarpX::J_in_time
static short J_in_time
Definition: WarpX.H:326
WarpX::PSATDBackwardTransformF
void PSATDBackwardTransformF()
Backward FFT of F on all mesh refinement levels.
Definition: WarpXPushFieldsEM.cpp:196
WarpX::~WarpX
~WarpX()
Definition: WarpX.cpp:571
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:437
WarpX::field_gathering_algo
static short field_gathering_algo
Integer that corresponds to the field gathering algorithm (energy-conserving, momentum-conserving)
Definition: WarpX.H:282
WarpX::Bfield_avg_cp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Bfield_avg_cp
Definition: WarpX.H:1685
WarpX::shared_mem_current_tpb
static int shared_mem_current_tpb
number of threads to use per block in shared deposition
Definition: WarpX.H:362
WarpX::load_balance_costs_update_algo
static short load_balance_costs_update_algo
Definition: WarpX.H:290
WarpX::get_pointer_Bfield_fp
amrex::MultiFab * get_pointer_Bfield_fp(int lev, int direction) const
Definition: WarpX.H:632
WarpX::m_fdtd_solver_cp
amrex::Vector< std::unique_ptr< FiniteDifferenceSolver > > m_fdtd_solver_cp
Definition: WarpX.H:2122
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:671
WarpX::mirror_z_width
amrex::Vector< amrex::Real > mirror_z_width
Definition: WarpX.H:748
WarpX::getcurrent_fp
const amrex::MultiFab & getcurrent_fp(int lev, int direction)
Definition: WarpX.H:683
WarpX::reduced_diags
std::unique_ptr< MultiReducedDiags > reduced_diags
object with all reduced diagnotics, similar to MultiParticleContainer for species.
Definition: WarpX.H:752
WarpX::getBfield
const amrex::MultiFab & getBfield(int lev, int direction)
Definition: WarpX.H:665
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:680
WarpX::current_buffer_masks
amrex::Vector< std::unique_ptr< amrex::iMultiFab > > current_buffer_masks
Definition: WarpX.H:1695
WarpX::get_numprocs
const amrex::IntVect get_numprocs() const
Definition: WarpX.H:1139
WarpX::ScrapeParticles
void ScrapeParticles()
WarpX::get_pointer_Bfield_cp
amrex::MultiFab * get_pointer_Bfield_cp(int lev, int direction) const
Definition: WarpX.H:650
WarpX::slice_max_grid_size
int slice_max_grid_size
Definition: WarpX.H:1814
WarpX::B_ext_grid_s
static std::string B_ext_grid_s
Initialization type for external magnetic field on the grid.
Definition: WarpX.H:129
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:1674
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:664
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:223
WarpX::self_fields_absolute_tolerance
static amrex::Real self_fields_absolute_tolerance
Definition: WarpX.H:1093
WarpX::m_accelerator_lattice
amrex::Vector< std::unique_ptr< AcceleratorLattice > > m_accelerator_lattice
Definition: WarpX.H:1837
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:316
WarpX::m_const_dt
std::optional< amrex::Real > m_const_dt
Definition: WarpX.H:1729
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:2955
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:1816
WarpX::do_pml_Lo
amrex::Vector< amrex::IntVect > do_pml_Lo
Definition: WarpX.H:1713
WarpX::applyMirrors
void applyMirrors(amrex::Real time)
Definition: WarpXEvolve.cpp:1126
WarpX::spectral_solver_cp
amrex::Vector< std::unique_ptr< SpectralSolverRZ > > spectral_solver_cp
Definition: WarpX.H:2104
WarpX::getmoving_window_x
amrex::Real getmoving_window_x() const
Definition: WarpX.H:1045
WarpX::costs_heuristic_cells_wt
amrex::Real costs_heuristic_cells_wt
Definition: WarpX.H:1769
WarpX::E_external_grid
static amrex::Vector< amrex::Real > E_external_grid
Initial electric field on the grid.
Definition: WarpX.H:118
WarpX::do_pml_dive_cleaning
bool do_pml_dive_cleaning
Definition: WarpX.H:1711
WarpX::authors
static std::string authors
Author of an input file / simulation setup.
Definition: WarpX.H:115
WarpX::plotfile_headerversion
amrex::VisMF::Header::Version plotfile_headerversion
Definition: WarpX.H:1794
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:189
WarpX::getPMLRZ
const PML_RZ * getPMLRZ()
Definition: WarpX.H:705
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:455
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:346
WarpX::CurrentBufferMasks
static const amrex::iMultiFab * CurrentBufferMasks(int lev)
Definition: WarpX.cpp:3307
WarpX::ComputePMLFactors
void ComputePMLFactors()
WarpX::end_moving_window_step
static int end_moving_window_step
Definition: WarpX.H:1099
WarpX::Ezfield_flag_parser
std::unique_ptr< amrex::Parser > Ezfield_flag_parser
Definition: WarpX.H:248
WarpX::sort_intervals
static utils::parser::IntervalsParser sort_intervals
Definition: WarpX.H:460
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:134
WarpX::Efield_fp
amrex::Vector< std::array< std::unique_ptr< amrex::MultiFab >, 3 > > Efield_fp
Definition: WarpX.H:1601
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:350
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:740
WarpXParticleContainer
Definition: WarpXParticleContainer.H:104
amrex::AmrMesh::geom
Vector< Geometry > geom
FabArray< FArrayBox >::get
const FArrayBox & 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:74
int
const int[]
amrex::Array
std::array< T, N > Array
check_interp_points_and_weights.ii
ii
Definition: check_interp_points_and_weights.py:148
compute_domain.cell_size
cell_size
Definition: compute_domain.py:37
stencil.dx
int dx
Definition: stencil.py:436
stencil.name
string name
Definition: stencil.py:452
video_yt.field
string field
Definition: video_yt.py:31
verbosity
int verbosity()
Generated by doxygen 1.9.1