1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/* Copyright 2019-2020 David Grote
*
* This file is part of WarpX.
*
* License: BSD-3-Clause-LBNL
*/
#include "SpectralKSpaceRZ.H"
#include "SpectralSolverRZ.H"
#include "SpectralAlgorithms/PsatdAlgorithmRZ.H"
#include "SpectralAlgorithms/GalileanPsatdAlgorithmRZ.H"
#include "WarpX.H"
#include "Utils/WarpXProfilerWrapper.H"
/* \brief Initialize the spectral Maxwell solver
*
* This function selects the spectral algorithm to be used, allocates the
* corresponding coefficients for the discretized field update equation,
* and prepares the structures that store the fields in spectral space.
*
* \param n_rz_azimuthal_modes Number of azimuthal modes
* \param norder_z Order of accuracy of the spatial derivatives along z
* \param nodal Whether the solver is applied to a nodal or staggered grid
* \param dx Cell size along each dimension
* \param dt Time step
* \param pml Whether the boxes in which the solver is applied are PML boxes
* PML is not supported.
*/
SpectralSolverRZ::SpectralSolverRZ (const int lev,
amrex::BoxArray const & realspace_ba,
amrex::DistributionMapping const & dm,
int const n_rz_azimuthal_modes,
int const norder_z, bool const nodal,
const amrex::Array<amrex::Real,3>& v_galilean,
amrex::RealVect const dx, amrex::Real const dt,
bool const update_with_rho)
: k_space(realspace_ba, dm, dx)
{
// Initialize all structures using the same distribution mapping dm
// - The k space object contains info about the size of
// the spectral space corresponding to each box in `realspace_ba`,
// as well as the value of the corresponding k coordinates.
// - Select the algorithm depending on the input parameters
// Initialize the corresponding coefficients over k space
// PML is not supported.
if (v_galilean[2] == 0) {
// v_galilean is 0: use standard PSATD algorithm
algorithm = std::make_unique<PsatdAlgorithmRZ>(
k_space, dm, n_rz_azimuthal_modes, norder_z, nodal, dt, update_with_rho);
} else {
// Otherwise: use the Galilean algorithm
algorithm = std::make_unique<GalileanPsatdAlgorithmRZ>(
k_space, dm, n_rz_azimuthal_modes, norder_z, nodal, v_galilean, dt, update_with_rho);
}
// - Initialize arrays for fields in spectral space + FFT plans
field_data = SpectralFieldDataRZ(lev, realspace_ba, k_space, dm,
algorithm->getRequiredNumberOfFields(),
n_rz_azimuthal_modes);
}
/* \brief Transform the component `i_comp` of MultiFab `field_mf`
* to spectral space, and store the corresponding result internally
* (in the spectral field specified by `field_index`) */
void
SpectralSolverRZ::ForwardTransform (const int lev,
amrex::MultiFab const & field_mf, int const field_index,
int const i_comp) {
WARPX_PROFILE("SpectralSolverRZ::ForwardTransform");
field_data.ForwardTransform(lev, field_mf, field_index, i_comp);
}
/* \brief Transform the two MultiFabs `field_mf1` and `field_mf2`
* to spectral space, and store the corresponding results internally
* (in the spectral field specified by `field_index1` and `field_index2`) */
void
SpectralSolverRZ::ForwardTransform (const int lev,
amrex::MultiFab const & field_mf1, int const field_index1,
amrex::MultiFab const & field_mf2, int const field_index2) {
WARPX_PROFILE("SpectralSolverRZ::ForwardTransform");
field_data.ForwardTransform(lev,
field_mf1, field_index1,
field_mf2, field_index2);
}
/* \brief Transform spectral field specified by `field_index` back to
* real space, and store it in the component `i_comp` of `field_mf` */
void
SpectralSolverRZ::BackwardTransform (const int lev,
amrex::MultiFab& field_mf, int const field_index,
int const i_comp) {
WARPX_PROFILE("SpectralSolverRZ::BackwardTransform");
field_data.BackwardTransform(lev, field_mf, field_index, i_comp);
}
/* \brief Transform spectral fields specified by `field_index1` and `field_index2`
* back to real space, and store it in `field_mf1` and `field_mf2`*/
void
SpectralSolverRZ::BackwardTransform (const int lev,
amrex::MultiFab& field_mf1, int const field_index1,
amrex::MultiFab& field_mf2, int const field_index2) {
WARPX_PROFILE("SpectralSolverRZ::BackwardTransform");
field_data.BackwardTransform(lev,
field_mf1, field_index1,
field_mf2, field_index2);
}
/* \brief Update the fields in spectral space, over one timestep */
void
SpectralSolverRZ::pushSpectralFields () {
WARPX_PROFILE("SpectralSolverRZ::pushSpectralFields");
// Virtual function: the actual function used here depends
// on the sub-class of `SpectralBaseAlgorithm` that was
// initialized in the constructor of `SpectralSolverRZ`
algorithm->pushSpectralFields(field_data);
}
/**
* \brief Public interface to call the member function ComputeSpectralDivE
* of the base class SpectralBaseAlgorithmRZ from objects of class SpectralSolverRZ
*/
void
SpectralSolverRZ::ComputeSpectralDivE (const int lev,
const std::array<std::unique_ptr<amrex::MultiFab>,3>& Efield,
amrex::MultiFab& divE) {
algorithm->ComputeSpectralDivE(lev, field_data, Efield, divE);
}
/**
* \brief Public interface to call the virtual function \c CurrentCorrection,
* defined in the base class SpectralBaseAlgorithmRZ and possibly overridden
* by its derived classes (e.g. PsatdAlgorithmRZ), from
* objects of class SpectralSolverRZ through the private unique pointer \c algorithm
*
* \param[in,out] current two-dimensional array of unique pointers to MultiFab
* storing the three components of the current density
* \param[in] rho unique pointer to MultiFab storing the charge density
*/
void
SpectralSolverRZ::CurrentCorrection (const int lev,
std::array<std::unique_ptr<amrex::MultiFab>,3>& current,
const std::unique_ptr<amrex::MultiFab>& rho) {
algorithm->CurrentCorrection(lev, field_data, current, rho);
}
void
SpectralSolverRZ::VayDeposition (const int lev, std::array<std::unique_ptr<amrex::MultiFab>,3>& current)
{
algorithm->VayDeposition(lev, field_data, current);
}
|
