XGCa

#include "petsc_version_defs.h"
#include <petsc/finclude/petsc.h>
Data Types  
module  f90moduleinterfaces 
Explicit interfaces to somve PETSc function used by the FSA solver. More...  
interface  f90moduleinterfaces::pcsetapplicationcontext 
interface  f90moduleinterfaces::pcgetapplicationcontext 
interface  f90moduleinterfaces::matcreateshell 
interface  f90moduleinterfaces::matshellsetcontext 
interface  f90moduleinterfaces::matshellgetcontext 
Functions/Subroutines  
subroutine  init_poisson (grid, psn, iflag_dummy) 
subroutine  pcshermanmorrisonapply (pc, xin, yout, ierr) 
Applies a ShermanMorrison preconditioner. More...  
subroutine  create_2field_solver (grid, bd, solver, solver_data) 
Sets up a 2x2 block solver for the Poisson equation. The first row is the Poisson equation, the second row is a constraint equation for the fluxsurface averaged potential. More...  
subroutine  make_12mat (grid, Bmat, BIdentMat, FSAMass_Te, solver, bd, scale, xgc_petsc) 
subroutine  make_21mat (grid, Cmat, Cio, Bmat, CConstBCVec, bd, xgc_petsc, petsc_xgc_bd) 
subroutine  solve_axisymmetric_poisson (grid, psn, iflag) 
High level Poisson solver routine for n=0, offers choice of outer iterative solver, twostep solver, and FSA solver. More...  
subroutine  solve_turb_poisson (grid, psn, iflag, ipc) 
High level Poisson solver routine for n>0 Currently, only one implementation is available. More...  
subroutine  set_rhs_poisson (grid, psn, solver, iflag, is_turb, is_two_step) 
Routine to set and process the rhs arrays for both axisymmetric and turbulent poisson solvers. Also sets boundary data for XGCA. More...  
subroutine  save_rhs_poisson (grid, psn, solver, iflag, ipc, do_solve_poisson) 
Save the charge density for time averaging of the Poisson equation. More...  
subroutine  spectral_solver_decompose (grid, field_inout, field_ntor) 
Decompose field into spectral components treated by the spectral solver and the rest treated by the regular solver. More...  
integer function  get_ntor_num_from_ntor_real (ntor_real, nphi, wedge_n) 
Calculates the numerical toroidal mode number for a given real toroidal mode number. More...  
subroutine  spectral_solver_reassemble (grid, field_inout, field_ntor) 
Reassemble the full field from the spectral components treated by the spectral solver, and the rest treated by the regular solver. More...  
subroutine  set_petsc_rhs_vec_axisymmetric_poisson (grid, psn, solver) 
Places rhs and (optionally) boundary condition data into a PETSc vector. More...  
subroutine  set_initial_guess_axisymmetric_poisson (grid, psn) 
Sets initial guess for the iterative axisymmetric poisson solver using the simple00 solver. The initial guess is stored in psnpot0m. More...  
subroutine  solve_axisymmetric_poisson_iter (grid, psn) 
Poisson solver that uses an iterative method to solve for the axisymmetric electrostatic potential: The Poisson equation for the axisymmetric mode is
\[ \nabla_\perp \cdot \xi \nabla_\perp \overline{\phi}_{k+1} + \frac{e n_0/T_{e,0}} \overline{\phi}_{k+1} = e \left( \langle \overline{\delta n_i} \rangle_g  \overline{\delta n_{e,NA}} \right) + \frac{e n_0/T_{e,0}} \langle \phi_{k} \rangle_{fs} \] where \(k\) is the iteration index, \(xi\) is the electric susceptibility, \(e\) is the elementary charge, \(n_0\) and \(T_0\) are the background density and temperature, \(\langle \overline{\delta n_i} \rangle_g\) is the gyroaveraged ion (gyrocenter) charge density, \(\overline{\delta n_{e,NA}}\) is the nonadiabatic electron charge density, and \(\langle\dots\rangle_{fs}\) is the the fluxsurface average. \(\overline{\dots}\) is the toroidal average. More...  
subroutine  axisym_mat_mult (A, X, Y, ierr) 
Subroutine used to apply the shell matrix representing the left hand side of the axisymmetric Poisson equation. More...  
subroutine  axisym_pc_apply (pc, X, Y, ierr) 
Subroutine used to apply the shell preconditioner used in the iterative solution of the axisymmetric Poisson equation. More...  
subroutine  solve_axisymmetric_poisson_two_step_fsa (grid, psn) 
Simple twostep 2D solver driver for the axisymmetric potential and onestep solver ("FSAsolver") with constraint equation for the fluxsurface averaged potential. For the twostep solver, the RHS is the fluxsurface averaged charge density, the LHS consists only of the polarization operator. The result of the 2D solve is fluxsurface averaged; i.e., the result is \(\langle\phi\rangle\) The Poisson equation for the fluxsurface averaged mode is
\[ \nabla_\perp \cdot \xi \nabla_\perp \overline{\phi} = e \left\langle \left( \langle \overline{\delta n_i} \rangle_g  \overline{\delta n_{e,NA}} \right) \right\rangle_{fs} \] where \(xi\) is the electric susceptibility, \(e\) is the elementary charge, \(n_0\) is the background density, \(\langle \overline{\delta n_i} \rangle_g\) is the gyroaveraged ion (gyrocenter) charge density, \(\overline{\delta n_{e,NA}}\) is the nonadiabatic electron charge density, and \(\langle\dots\rangle_{fs}\) is the the fluxsurface average. \(\overline{\dots}\) is the toroidal average. More...  
subroutine  post_process_axisymmetric_poisson (grid, psn) 
Routine to post process the solution from the axisymmetric poisson solver. More...  
subroutine  solve_turb_poisson_default (grid, psn) 
Routine to solve the nonaxisymmetric Poisson equation:
\[ \nabla_\perp \cdot \xi \nabla_\perp \delta\phi + \frac{e n_0/T_{e,0}} \delta\phi = e \left( \langle \delta n_i \rangle_g  \overline{\delta n_{e,NA}} \right) \] . More...  
subroutine  post_process_turb_poisson (grid, psn) 
Routine to post process the solution from the nonaxisymmetric Poisson equation. More...  
subroutine axisym_mat_mult  (  A,  
X,  
Y,  
ierr  
) 
Subroutine used to apply the shell matrix representing the left hand side of the axisymmetric Poisson equation.
[in]  A  Shell matrix which multiplies X, Petsc Mat 
[in]  X  Vector to be multiplied, Petsc Vec 
[out]  Y  Vector to store product A*X, Petsc Vec 
[out]  ierr  PETSc Error code 
subroutine axisym_pc_apply  (  pc,  
X,  
Y,  
ierr  
) 
Subroutine used to apply the shell preconditioner used in the iterative solution of the axisymmetric Poisson equation.
[in]  pc  Shell preconditioner which is applied to residual X, Petsc PC 
[in]  X  Residual vector, Petsc Vec 
[out]  Y  Preconditioner residual vector, Petsc Vec 
[out]  ierr  PETSc Error code 
subroutine create_2field_solver  (  type(grid_type)  grid, 
type(boundary2_type)  bd,  
type(xgc_solver)  solver,  
type(solver_init_data), intent(in)  solver_data  
) 
Sets up a 2x2 block solver for the Poisson equation. The first row is the Poisson equation, the second row is a constraint equation for the fluxsurface averaged potential.
[in]  grid  XGC grid object, type(grid_type) 
[in]  bd  Object containing the indices of the solver boundary vertices in the XGC mesh. 
[in,out]  solver  XGC solver object into which to put the new solver, type(xgc_solver) 
[in]  solver_data  Data needed for settug up the ssolver, type(solver_init_data) 
integer function get_ntor_num_from_ntor_real  (  integer, intent(in)  ntor_real, 
integer, intent(in)  nphi,  
integer, intent(in)  wedge_n  
) 
Calculates the numerical toroidal mode number for a given real toroidal mode number.
[in]  ntor_real  Real toroidal mode number, integer 
[in]  nphi  Number of toroidal planes per wedge, integer 
[in]  wedge_n  Number of wedges per toroidal circuit, integer 
subroutine init_poisson  (  type(grid_type)  grid, 
type(psn_type)  psn,  
integer  iflag_dummy  
) 
subroutine make_12mat  (  type(grid_type)  grid, 
intent(inout)  Bmat,  
BIdentMat,  
intent(in)  FSAMass_Te,  
type(xgc_solver)  solver,  
type(boundary2_type), intent(in)  bd,  
real (8), intent(in)  scale,  
dimension(grid%nnode), intent(in)  xgc_petsc  
) 
subroutine make_21mat  (  type(grid_type)  grid, 
Cmat,  
Cio,  
intent(in)  Bmat,  
CConstBCVec,  
type(boundary2_type), intent(in)  bd,  
dimension(grid%nnode), intent(in)  xgc_petsc,  
dimension(grid%nnode), intent(in)  petsc_xgc_bd  
) 
subroutine pcshermanmorrisonapply  (  pc,  
xin,  
yout,  
ierr  
) 
Applies a ShermanMorrison preconditioner.
[in,out]  pc  PETCs PC object (manages preconditioners) 
xin  ???, Vec  
yout  ???, Vec  
[out]  ierr  PETc error code 
subroutine post_process_axisymmetric_poisson  (  type(grid_type)  grid, 
type(psn_type)  psn  
) 
Routine to post process the solution from the axisymmetric poisson solver.
[in]  grid  XGC grid data object 
[in,out]  psn  XGC field data object 
subroutine post_process_turb_poisson  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn  
) 
Routine to post process the solution from the nonaxisymmetric Poisson equation.
[in]  grid  XGC grid data object 
[in,out]  psn  XGC field data object 
subroutine save_rhs_poisson  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn,  
type(xgc_solver), intent(inout)  solver,  
integer, intent(in)  iflag,  
integer, intent(in)  ipc,  
logical, intent(out)  do_solve_poisson  
) 
Save the charge density for time averaging of the Poisson equation.
[in]  grid  XGC grid data structure, type(grid_type) 
[in,out]  psn  XGC field data structure, type(psn_type) 
[in,out]  solver  XGC solver object, type(xgc_solver) 
[in]  iflag  Adiabatic solve indicator, integer 
[in]  ipc  RK2 stage index, integer 
[out]  do_solve_poisson  Whether to solve Ampere's law after saving RHS, logical 
subroutine set_initial_guess_axisymmetric_poisson  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn  
) 
Sets initial guess for the iterative axisymmetric poisson solver using the simple00 solver. The initial guess is stored in psnpot0m.
[in]  grid  Solver grid data, type(grid_type) 
[in,out]  psn  Field data; the pot0m is stored there, type(psn_type) 
subroutine set_petsc_rhs_vec_axisymmetric_poisson  (  type(grid_type)  grid, 
type(psn_type)  psn,  
type(xgc_solver)  solver  
) 
Places rhs and (optionally) boundary condition data into a PETSc vector.
[in]  grid  Solver grid data, type(grid_type) 
[in,out]  psn  Field data; the rhs XGC data is stored there, type(psn_type) 
[in,out]  solver  XGC solver object; the rhs PETSc vector is stored there, type(xgc_solver) 
subroutine set_rhs_poisson  (  type(grid_type)  grid, 
type(psn_type)  psn,  
type(xgc_solver)  solver,  
integer, intent(in)  iflag,  
logical, intent(in)  is_turb,  
logical, intent(in)  is_two_step  
) 
Routine to set and process the rhs arrays for both axisymmetric and turbulent poisson solvers. Also sets boundary data for XGCA.
[in]  grid  XGC grid data object 
[in,out]  psn  XGC field data object 
[in,out]  solver  XGC solver object, type(xgc_solver) 
[in]  iflag  Flag to indicate whether adiabatic elec or full eq. is solved, integer 
[in]  is_turb  If .true. set RHS for turbulence solve, otherwise for axisymmetric solve 
[in]  is_two_step  Whether this is for setting the RHS for the (n=0,m>0) step of the twostep solver 
subroutine solve_axisymmetric_poisson  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn,  
integer, intent(in)  iflag  
) 
High level Poisson solver routine for n=0, offers choice of outer iterative solver, twostep solver, and FSA solver.
[in]  grid  XGC grid data object 
[in,out]  psn  XGC field data object 
[in]  iflag  Flag to indicate whether adiabatic elec or full eq. is solved, integer 
subroutine solve_axisymmetric_poisson_iter  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn  
) 
Poisson solver that uses an iterative method to solve for the axisymmetric electrostatic potential: The Poisson equation for the axisymmetric mode is
\[ \nabla_\perp \cdot \xi \nabla_\perp \overline{\phi}_{k+1} + \frac{e n_0/T_{e,0}} \overline{\phi}_{k+1} = e \left( \langle \overline{\delta n_i} \rangle_g  \overline{\delta n_{e,NA}} \right) + \frac{e n_0/T_{e,0}} \langle \phi_{k} \rangle_{fs} \]
where \(k\) is the iteration index, \(xi\) is the electric susceptibility, \(e\) is the elementary charge, \(n_0\) and \(T_0\) are the background density and temperature, \(\langle \overline{\delta n_i} \rangle_g\) is the gyroaveraged ion (gyrocenter) charge density, \(\overline{\delta n_{e,NA}}\) is the nonadiabatic electron charge density, and \(\langle\dots\rangle_{fs}\) is the the fluxsurface average. \(\overline{\dots}\) is the toroidal average.
The RHS and LHS of the axisymmetric equation can be Fourierfiltered (poloidal modes). The LHS of the nonaxisymmetric equation can be Fourierfiltered in the toroidal and poloidal direction. The solver in both cases is a linear finiteelement solver on an unstructured triangular grid.
[in]  grid  Solver grid data, type(grid_type) 
[in,out]  psn  Field data; the potential is stored there, type(psn_type) 
subroutine solve_axisymmetric_poisson_two_step_fsa  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn  
) 
Simple twostep 2D solver driver for the axisymmetric potential and onestep solver ("FSAsolver") with constraint equation for the fluxsurface averaged potential. For the twostep solver, the RHS is the fluxsurface averaged charge density, the LHS consists only of the polarization operator. The result of the 2D solve is fluxsurface averaged; i.e., the result is \(\langle\phi\rangle\) The Poisson equation for the fluxsurface averaged mode is
\[ \nabla_\perp \cdot \xi \nabla_\perp \overline{\phi} = e \left\langle \left( \langle \overline{\delta n_i} \rangle_g  \overline{\delta n_{e,NA}} \right) \right\rangle_{fs} \]
where \(xi\) is the electric susceptibility, \(e\) is the elementary charge, \(n_0\) is the background density, \(\langle \overline{\delta n_i} \rangle_g\) is the gyroaveraged ion (gyrocenter) charge density, \(\overline{\delta n_{e,NA}}\) is the nonadiabatic electron charge density, and \(\langle\dots\rangle_{fs}\) is the the fluxsurface average. \(\overline{\dots}\) is the toroidal average.
NOTE: The twostep solver does not support nonzero Dirichlet boundary conditions!
The FSA solver solves the same equation as the outeriterative solver (solve_axisymmetric_poisson_iter), but with a twist. The fluxsurface averaged potential is treated as an independent field \(\lambda\) in the Poisson equation. In order to make the equation consistent, a second (constraint) equation is added that enforces \(\lambda=\langle\phi\rangle_{fs}\). So the FSA solver solves a 2x2 block system.
[in]  grid  Solver grid data, type(grid_type) 
[in,out]  psn  Field data; the potential is stored there, type(psn_type) 
subroutine solve_turb_poisson  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn,  
integer, intent(in)  iflag,  
integer, intent(in)  ipc  
) 
High level Poisson solver routine for n>0 Currently, only one implementation is available.
[in]  grid  XGC grid data object 
[in,out]  psn  XGC field data object 
[in]  iflag  Flag to indicate whether adiabatic elec or full eq. is solved, integer 
[in]  ipc  RK2 stage index, integer 
subroutine solve_turb_poisson_default  (  type(grid_type), intent(in)  grid, 
type(psn_type), intent(inout)  psn  
) 
Routine to solve the nonaxisymmetric Poisson equation:
\[ \nabla_\perp \cdot \xi \nabla_\perp \delta\phi + \frac{e n_0/T_{e,0}} \delta\phi = e \left( \langle \delta n_i \rangle_g  \overline{\delta n_{e,NA}} \right) \]
.
[in]  grid  XGC grid data object 
[in,out]  psn  XGC field data object 
subroutine spectral_solver_decompose  (  type(grid_type), intent(in)  grid, 
real(kind=8), dimension(grid%nnode), intent(inout)  field_inout,  
real(kind=8), dimension(grid%nnode,2), intent(out)  field_ntor  
) 
Decompose field into spectral components treated by the spectral solver and the rest treated by the regular solver.
[in]  grid  XGC grid object, type(grid_type) 
[in,out]  field_inout  Input data, real(8) 
[out]  field_ntor  Output 
subroutine spectral_solver_reassemble  (  type(grid_type), intent(in)  grid, 
real(kind=8), dimension(grid%nnode), intent(inout)  field_inout,  
real(kind=8), dimension(grid%nnode,2), intent(inout)  field_ntor  
) 
Reassemble the full field from the spectral components treated by the spectral solver, and the rest treated by the regular solver.
[in]  grid  XGC grid object, type(grid_type) 
[in,out]  field_inout  Input data, real(8) 
[in,out]  field_ntor  Output 