CT_MultiLevel

Eloisa Bentivegna <eloisa.bentivegna@ct.infn.it>

May 27 2013

Abstract

This thorn implements a multigrid solver for systems of elliptic partial differential equations. It uses Carpet’s interface to handle loops over the grid hierarchy and pass information between different components. The system of equations is passed to the solver via parameters pointing to the external grid functions that hold the equation coefficients.

1 Introduction

CT_MultiLevel is a Cactus thorn that implements a multigrid solver for elliptic partial differential equations (PDEs). The implementation is rather standard, and it also allows for local AMR grids (in which case it uses a rudimentary multilevel algorithm).

This thorn requires Carpet, which it uses to manage the access to the grid structure (via the BEGIN_*_LOOP and END_*_LOOP macros) and to pass information between the different levels (via the restriction and prolongation operators).

Structurally, the solver can tackle any type of equation or system of equations, their coefficients being passed to CT_MultiLevel via string parameters holding the names of the corresponding grid function. The thorn comes with a number of test cases which should be easy to customize and extend.

2 Principle of multigrid

Multigrid schemes are designed to solve elliptic equations on a hierarchy of grids, with the goal of speeding up the convergence rate of relaxation algorithms (such as Gauss-Seidel) by eliminating different frequency modes of the solution error on different grids. It is known that relaxation techniques are very effective at eliminating the high-frequency part of the error; when solving an elliptic PDE on a grid, it is then advantageous to relax it on a coarser grid beforehand and interpolate the result back onto the original grid. Complex schemes involving several grid levels, each with a different PDE, can be designed to maximize the speed up. Please refer to [1] for the details.

3 Using This Thorn

CT_MultiLevel, along with the rest of the Cosmology arrangement, is released under the General Public License, version 2 and higher. The copyright of this thorn remains with myself.

3.1 Obtaining This Thorn

CT_MultiLevel is publicly available in COSMOTOOLKIT’s git repository: 

   git clone https://eloisa@bitbucket.org/eloisa/cosmology.git

A helper thorn CT_Analytic is available under the same repository.

3.2 Basic Usage

In order to solve an elliptic PDE with CT_MultiLevel, CT_MultiLevel can be simply compiled in, with the requirement that Carpet is compiled as well. The thorn also inherits from boundary and grid for boundary APIs and coordinate labels.

Currently, the equation is solved in a single schedule call at CCTK_INITIAL, in GLOBAL_LATE mode (to ensure that necessary objects such as the grid arrays have been populated).

As the equation coefficients will be set by grid functions, a thorn allocating and setting these grid functions to the desired values has to be included. Another thorn in the Cosmology arrangement, CT_Analytic, serves this purpose. Grid functions of other origin are naturally just as good.

Each equation in the system to solve is parametrized as follows:

\begin {eqnarray} c_{xx} \partial _{xx} \psi + c_{xy} \partial _{xy} \psi + c_{xz} \partial _{xz} \psi + c_{yy} \partial _{yy} \psi + c_{yz} \partial _{yz} \psi + c_{zz} \partial _{zz} \psi &+& \\ c_{x} \partial _{x} \psi + c_{y} \partial _{y} \psi + c_{z} \partial _{z} \psi + c_{0} \psi ^{n_0} + c_{1} \psi ^{n_1} + c_{2} \psi ^{n_2} + c_{3} \psi ^{n_3} + c_4 \psi ^{n_4} &=& 0 \end {eqnarray}

All the coefficients \(c_*\) and the powers \(n_*\) can be specified by setting the parameters *_gfname[*] to the desired grid function name. These parameters are arrays to allow for the solution of systems of equations.

The only other parameter which must be set to ensure correct operation is CT_MultiLevel::topMGlevel, which tells the solver which is the finest refinement level that covers the entire domain in which the equation is to be solved. All levels below and including this will be used in the classical multigrid sense (e.g., in a V- or FMG-cycle). The ones above will be treated as local AMR boxes, and be solved via a multilevel prescription; presently, this involves simply interpolating the solution from the topMGlevel refinement level at the end of the multigrid part and relaxing it progressively, from coarser to finer, on all the local grids.

Other parameters control the stopping criteria (numbers of relaxation sweeps and residual tolerance), the finite-differencing order used to discretized the equation, the number of equations in the system, and whether the solution error should be calculated (this obviously requires the exact solution to be known and stored in a grid function, its name passed to CT_MultiLevel via the usual parameter mechanism).

Concrete examples on how to set these parameters are provided below.

3.3 Special Behaviour

When the equation coefficients cannot be passed in via external grid functions (as is the case, for instance, when solving a coupled system of PDEs), then one can resort to auxiliary functions, which are recalculated after each relaxation sweep. The actual algorithm used to populate these coefficient has to be provided by the user; some examples are provided under src/auxiliaries. These values are stored in CT_MultiLevel’s auxiliaries variable group.

All coefficients, auxiliaries, and other useful grid functions are stored in the pointer structure coeffptr, to which the user can further append pointers to extra external grid functions, which are not used as PDE coefficients (and thus do not need additional storage space and shouldn’t be introduced as auxiliaries), but are still needed by the solver. Examples can be found under src/extra.

Finally, if variable resetting is necessary after each relaxation step (for instance, when solving linear problems in periodic domains), a suitable calculation needs to be provided by the user, similar to the examples in src/integral.

3.4 Interaction With Other Thorns

CT_MultiLevel uses some of Carpet’s macros to access different components of a grid hierarchy, and its prolongation and restriction operators to pass information between them.

Furthermore, CT_MultiLevel needs at least one external thorn to set the PDE coefficients. The helper thorn CT_Analytic can be used to this purpose, but any set of external grid functions will serve the purpose.

3.5 Examples

The solver is described in [2], along with a number of examples. I rediscuss some of those below from the technical standpoint, highlighting which parameters need to be set in each case and whether other information is required from the user.

3.6 Poisson’s equation

Poisson’s equation reads: \begin {equation} \Delta \psi + \rho = 0 \end {equation} where \(\rho \) is a known source function and \(\psi \) is an unknown to solve for. Its Laplacian, \(\Delta \psi \), simply represents the sum of its diagonal second-order derivatives: \begin {equation} \Delta \psi = \partial _{xx} \psi + \partial _{yy} \psi + \partial _{zz} \psi \end {equation} so that cxx_gfname[0], cyy_gfname[0] and czz_gfname[0] all have to be set to one. The source term can be specified freely. CT_Analytic can be used to set all coefficients, e.g. setting the CT_Analytic::free_data parameter to exact, where the coefficients of the diagonal second-order derivatives are all one, the source term can be set to a linear combination of a gaussian, a sine, and a \(1/r\) term, and all the other coefficients default to zero. To choose a gaussian source term, for instance, one can set: 

CT_Analytic::free_data             = "exact"
CT_Analytic::ampG                  = 1
CT_Analytic::sigma                 = 0.5

and then pass the relevant grid functions to CT_MultiLevel: 

CT_MultiLevel::cxx_gfname[0]       = "CT_Analytic::testcxx"
CT_MultiLevel::cyy_gfname[0]       = "CT_Analytic::testcyy"
CT_MultiLevel::czz_gfname[0]       = "CT_Analytic::testczz"
CT_MultiLevel::c0_gfname[0]        = "CT_Analytic::testc0"
CT_MultiLevel::n0[0]               = 0

CT_Analytic can also be used to set the initial guess for the solver: 

CT_MultiLevel::inipsi_gfname[0]    = "CT_Analytic::testinipsi"

Any coefficient that is not specified explicitly via a parameter will be initialized to zero.

Other parameters can be used to tune the solver’s behavior, including the cycling mode through the different levels and the stopping criterion. The parameter file par/poisson.par provides a concrete example.

3.7 The Einstein constraint system for a spherical distribution of matter

Let’s consider Einstein’s constraints in the Lichnerowicz-York form and in a conformally-flat space, i.e. a coupled system of four PDEs for the four functions \(\psi \) and \(X_i\):

\begin {eqnarray} \label {eq:CTT} \Delta \psi - \frac {K^2}{12}\,\psi ^5 + \frac {1}{8} {A}_{ij} {A}^{ij} \psi ^{-7} = - 2 \pi \rho \psi ^5 \\ \Delta X_i + \partial _i \partial _j X^j - \frac {2}{3} \psi ^6 \delta ^{ij} \partial _i K = 8 \pi j^i \psi ^{10} \end {eqnarray}

where \begin {equation} A_{ij}=\partial _i X_j + \partial _j X_i + \frac {2}{3} \; \delta _{ij} \partial _k X^k \end {equation} and \(K\), \(\rho \) and \(j^i\) are freely specifiable functions.

Due to conformal flatness, again \(\Delta = \partial _{xx} + \partial _{yy} + \partial _{zz}\). However, in this case we have the additional complication that the coefficient of the \(\psi ^{-7}\) term in the first equation depends on \(X^i\), and therefore has to be updated during the solution process. This is accomplished by storing this coefficient in an auxiliary function, filled by the function CT_SetAuxiliaries initially and after each Gauss-Seidel iteration. The recipe to fill this grid function is contained in src/auxiliaries/Lump.cc.

The parameter specification for this case is then: 

CT_Analytic::free_data             = "Lump"
CT_Analytic::Kc                    = -0.1
CT_Analytic::ampG                  = 1
CT_Analytic::ampC                  = 1
CT_Analytic::ampV                  = 0.1
CT_Analytic::sigma                 = 0.2
CT_Analytic::vecA                  = 0.6

which specifies the equation coefficients and the free data \(K\), \(\rho \) and \(X^i\), and: 

CT_MultiLevel::inipsi_gfname[0]    = "CT_Analytic::testinipsi"
CT_MultiLevel::cxx_gfname[0]       = "CT_Analytic::testcxx"
CT_MultiLevel::cyy_gfname[0]       = "CT_Analytic::testcyy"
CT_MultiLevel::czz_gfname[0]       = "CT_Analytic::testczz"
CT_MultiLevel::n0[0]               = 5
CT_MultiLevel::c0_gfname[0]        = "CT_Analytic::testc0"
CT_MultiLevel::n1[0]               = 0
CT_MultiLevel::c1_gfname[0]        = "CT_Analytic::testc1"
CT_MultiLevel::n2[0]               = -7
CT_MultiLevel::c2_gfname[0]        = "CT_MultiLevel::ct_auxiliary[0]"

CT_MultiLevel::inipsi_gfname[1]    = "CT_Analytic::testinixx"
CT_MultiLevel::cxx_gfname[1]       = "CT_Analytic::testcxx"
CT_MultiLevel::cyy_gfname[1]       = "CT_Analytic::testcyy"
CT_MultiLevel::czz_gfname[1]       = "CT_Analytic::testczz"
CT_MultiLevel::n0[1]               = 0
CT_MultiLevel::c0_gfname[1]        = "CT_Analytic::testc2"
CT_MultiLevel::n1[1]               = 0
CT_MultiLevel::c1_gfname[1]        = "CT_MultiLevel::ct_auxiliary[1]"

CT_MultiLevel::inipsi_gfname[2]    = "CT_Analytic::testinixy"
CT_MultiLevel::cxx_gfname[2]       = "CT_Analytic::testcxx"
CT_MultiLevel::cyy_gfname[2]       = "CT_Analytic::testcyy"
CT_MultiLevel::czz_gfname[2]       = "CT_Analytic::testczz"
CT_MultiLevel::n0[2]               = 0
CT_MultiLevel::c0_gfname[2]        = "CT_Analytic::testc3"
CT_MultiLevel::n1[2]               = 0
CT_MultiLevel::c1_gfname[2]        = "CT_MultiLevel::ct_auxiliary[2]"

CT_MultiLevel::inipsi_gfname[3]    = "CT_Analytic::testinixz"
CT_MultiLevel::cxx_gfname[3]       = "CT_Analytic::testcxx"
CT_MultiLevel::cyy_gfname[3]       = "CT_Analytic::testcyy"
CT_MultiLevel::czz_gfname[3]       = "CT_Analytic::testczz"
CT_MultiLevel::n0[3]               = 0
CT_MultiLevel::c0_gfname[3]        = "CT_Analytic::testc4"
CT_MultiLevel::n1[3]               = 0
CT_MultiLevel::c1_gfname[3]        = "CT_MultiLevel::ct_auxiliary[3]"

which informs CT_MultiLevel on the grid functions holding the coefficients and on the existence of auxiliary functions.

Further parameters control other aspects of the solution, and can be found in par/constraints_spherical.par. In particular, the parameter CT_MultiLevel::number_of_equations has to be set explicitly to four to accomodate the full system of equations.

4 History

The development of this solver has been financed by the European Commission’s \(7^{\rm th}\) Framework through a Marie Curie IR Grant (PIRG05-GA-2009-249290, COSMOTOOLKIT). Please direct any feedback, as well as requests for support, to eloisa.bentivegna@aei.mpg.de.

Lars Andersson, Mikołaj Korzyński, Ian Hinder, Bruno Mundim, Oliver Rinne and Erik Schnetter have also contributed insight and suggestions that have partly offset my bad judgement on many issues. All remaining errors and bugs are naturally my own responsibility.

References

[1]   Briggs W, Henson V and McCormick S 2000 A Multigrid Tutorial Miscellaneous Bks (Society for Industrial and Applied Mathematics) ISBN 9780898714623

[2]   Bentivegna E 2013 Solving the Einstein constraints in periodic spaces with a multigrid approach (Preprint gr-qc/1305.5576)

5 Parameters

a0_gfname
Scope: private  STRING
Description: Use this grid function to set the a0 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

a1_gfname
Scope: private  STRING
Description: Use this grid function to set the a1 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

a2_gfname
Scope: private  STRING
Description: Use this grid function to set the a2 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

a3_gfname
Scope: private  STRING
Description: Use this grid function to set the a3 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

a4_gfname
Scope: private  STRING
Description: Use this grid function to set the a4 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

boundary_conditions
Scope: private  KEYWORD
Description: Which boundary conditions to apply to psi
Range   Default: none
Robin
Robin
TwoPunctures
Dirichlet BCs from TwoPunctures
none
This thorn will apply no boundary conditions

c0_gfname
Scope: private  STRING
Description: Use this grid function to set the c0 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

c1_gfname
Scope: private  STRING
Description: Use this grid function to set the c1 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

c2_gfname
Scope: private  STRING
Description: Use this grid function to set the c2 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

c3_gfname
Scope: private  STRING
Description: Use this grid function to set the c3 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

c4_gfname
Scope: private  STRING
Description: Use this grid function to set the c4 coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

compare_to_exact
Scope: private  KEYWORD
Description: Output a file with the difference between the solution at each iteration and the exact solution, if known
Range   Default: no
no
no
yes
yes

cx_gfname
Scope: private  STRING
Description: Use this grid function to set the cx coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cxx_gfname
Scope: private  STRING
Description: Use this grid function to set the cxx coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cxy_gfname
Scope: private  STRING
Description: Use this grid function to set the cxy coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cxz_gfname
Scope: private  STRING
Description: Use this grid function to set the cxz coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cy_gfname
Scope: private  STRING
Description: Use this grid function to set the cy coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cycle_type
Scope: private  KEYWORD
Description: How should be cycle over the refinement levels?
Range   Default: V cycle
V cycle
A V cycle
FMG cycle
A FMG cycle

cyy_gfname
Scope: private  STRING
Description: Use this grid function to set the cyy coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cyz_gfname
Scope: private  STRING
Description: Use this grid function to set the cyz coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

cz_gfname
Scope: private  STRING
Description: Use this grid function to set the cz coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

czz_gfname
Scope: private  STRING
Description: Use this grid function to set the czz coefficient
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

disable
Scope: private  KEYWORD
Description: Should this equation actually be solved?
Range   Default: no
no
no
yes
yes

enforce_int
Scope: private  INT
Description: Enforce the integral compatibility condition?
Range   Default: (none)
0:1:1
True or false

eps
Scope: private  REAL
Description: Regularization factor at the punctures
Range   Default: 1e-06
0:*
Any non-negative real

exact_laplacian_gfname
Scope: private  STRING
Description: Grid function holding the exact laplacian
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

exact_offset
Scope: private  REAL
Description: Offset between exact solution and grid function pointed by exact_solution_gfname
Range   Default: 0.0
*:*
Any real number

exact_solution_gfname
Scope: private  STRING
Description: Grid function holding the exact solution
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

fd_order
Scope: private  INT
Description: Order of FD
Range   Default: 2
2:4:2
Order of differencing

fill_adm
Scope: private  KEYWORD
Description: Should the equation solution be used to fill the ADM variables?
Range   Default: no
no
no
yes
yes

fill_aij
Scope: private  KEYWORD
Description: Where does the final Aij come from?
Range   Default: Analytic Aij
Solver
Aij is solved for as well
Analytic Xi
Aij comes from differentiating an analytic Xi
Analytic Aij
Aij comes from an exact solution

fmg_niter
Scope: private  INT
Description: How many times should we execute the FMG cycle?
Range   Default: 1
1:
Any non-negative integer

gs_update
Scope: private  KEYWORD
Description: Update solution immediately?
Range   Default: yes
yes
yes
no
no

inipsi_gfname
Scope: private  STRING
Description: Use this grid function to set the initial guess for psi
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

integral_refinement
Scope: private  INT
Description: How much to refine the grid via interpolation before calculating integrals
Range   Default: 1
1:*
Any integer greater than zero

mode
Scope: private  KEYWORD
Description: Which equation should we solve?
Range   Default: generic
generic
Generic elliptic operator, to be defined via the coefficients
constraints
The GR constraints

model
Scope: private  KEYWORD
Description: Model used to populate the auxiliary functions
Range   Default: None
Bowen-York
Bowen-York extrinsic curvature for multiple punctures
Expanding BH lattice
An expanding black-hole lattice
Lump
Generic compact source in Tmunu
see [1] below
Inhomogeneous Helmholtz equation
None
No auxiliaries needed

[1] 

Inhomogeneous Helmholtz

n0
Scope: private  INT
Description: Exponent of a power-law term
Range   Default: (none)
:
Any integer

n1
Scope: private  INT
Description: Exponent of a power-law term
Range   Default: (none)
:
Any integer

n2
Scope: private  INT
Description: Exponent of a power-law term
Range   Default: (none)
:
Any integer

n3
Scope: private  INT
Description: Exponent of a power-law term
Range   Default: (none)
:
Any integer

n4
Scope: private  INT
Description: Exponent of a power-law term
Range   Default: (none)
:
Any integer

nrelsteps_bottom
Scope: private  INT
Description: How many times should we relax each level at the bottom of a cycle?
Range   Default: 2
0:
Any non-negative integer

nrelsteps_down
Scope: private  INT
Description: How many times should we relax each level inside the downward leg of a cycle?
Range   Default: 2
0:
Any non-negative integer

nrelsteps_top
Scope: private  INT
Description: How many times should we relax each level at the top of a cycle?
Range   Default: 2
0:
Any non-negative integer

nrelsteps_up
Scope: private  INT
Description: How many times should we relax each level inside the upward leg of a cycle?
Range   Default: 2
0:
Any non-negative integer

number_of_auxiliaries
Scope: private  INT
Description: How many auxiliary functions do we need?
Range   Default: (none)
0:
A non-negative integer

number_of_equations
Scope: private  INT
Description: How many equations are to be solved concurrently?
Range   Default: 1
1:10
A positive integer smaller than or equal to 10

omega
Scope: private  REAL
Description: Overrelaxation factor
Range   Default: 1
0:2
Real larger than zero and smaller than 2

other_gfname
Scope: private  STRING
Description: Other gf names needed by solver
Range   Default: CT_MultiLevel::ct_zero
.*
Any valid grid function

output_norms
Scope: private  KEYWORD
Description: Output the norms of psi and residual, and those of their errors?
Range   Default: no
no
no
yes
yes

output_walk
Scope: private  KEYWORD
Description: Output a file with the parameter-space walk followed by the algorithm?
Range   Default: no
no
no
yes
yes

reset_every
Scope: private  INT
Description: How often should we reset psi?
Range   Default: 1
1:*
Any positive integer

reset_psi
Scope: private  KEYWORD
Description: Reset psi after each relaxation step? How?
Range   Default: no
no
Do not reset
to value
Reset to the value specified by reset_value
see [1] below
Reset so that the integrability condition is satisfied

[1] 

through integrability

reset_value
Scope: private  REAL
Description: Value to reset psi to
Range   Default: (none)
*:*
Any real number

reset_x
Scope: private  REAL
Description: x-coordinate of point of reference for variable resetting
Range   Default: (none)
:
Any real number (contained in the domain!)

reset_y
Scope: private  REAL
Description: y-coordinate of point of reference for variable resetting
Range   Default: (none)
:
Any real number (contained in the domain!)

reset_z
Scope: private  REAL
Description: z-coordinate of point of reference for variable resetting
Range   Default: (none)
:
Any real number (contained in the domain!)

single_srj_scheme
Scope: private  KEYWORD
Description: Use a single SRJ scheme for all the levels?
Range   Default: yes
no
no
yes
yes

srj_scheme
Scope: private  KEYWORD
Description: Which SRJ scheme should be used?
Range   Default: 6-32
6-32
6 levels, 32ˆ3 -point grid
6-64
6 levels, 64ˆ3 -point grid
6-128
6 levels, 128ˆ3 -point grid
6-256
6 levels, 256ˆ3 -point grid
6-512
6 levels, 512ˆ3 -point grid
6-1024
6 levels, 1024ˆ3 -point grid
6-150
6 levels, 150ˆ3 -point grid

tol
Scope: private  REAL
Description: Maximum residual tolerated
Range   Default: 1e-06
0:*
Any non-negative real

topmglevel
Scope: private  INT
Description: Finest level that covers the entire domain
Range   Default: (none)
0:
Any non-negative integer (< Carpet::reflevels!)

use_srj
Scope: private  KEYWORD
Description: Use SRJ relaxation factor?
Range   Default: no
no
no
yes
yes

use_srj_err
Scope: private  KEYWORD
Description: Use SRJ relaxation factor in the error equation?
Range   Default: no
no
no
yes
yes

verbose
Scope: private  KEYWORD
Description: Output debugging information?
Range   Default: no
no
no
yes
yes

veryverbose
Scope: private  KEYWORD
Description: Output more debugging information?
Range   Default: no
no
no
yes
yes

initial_data
Scope: shared from ADMBASE  KEYWORD
Extends ranges:
CT_MultiLevel
Initial data from this solver

6 Interfaces

General

Implements:

ct_multilevel

Inherits:

boundary

grid

Grid Variables

6.0.1 PRIVATE GROUPS
  Group Names     Variable Names     Details   
psi   compact0
ct_psi   descriptionConformal factor in the metric
  dimensions3
  distributionDEFAULT
  group typeGF
  tagstensortypealias=”Scalar”
  timelevels3
 vararray_sizenumber_of_equations
 variable typeREAL
err   compact0
ct_err   descriptionSolution error
ct_terr   dimensions3
ct_trunc   distributionDEFAULT
  group typeGF
  tagstensortypealias=”Scalar”
  timelevels3
 vararray_sizenumber_of_equations
 variable typeREAL
residual   compact0
ct_residual   descriptionResidual
ct_residual_above   dimensions3
  distributionDEFAULT
  group typeGF
  tagstensortypealias=”Scalar”
  timelevels3
 vararray_sizenumber_of_equations
 variable typeREAL
coeffs   compact0
ct_cxx   descriptionEquation’s coefficients
ct_cxy   dimensions3
ct_cxz   distributionDEFAULT
ct_cyy   group typeGF
ct_cyz   tagstensortypealias=”Scalar”
ct_czz   timelevels3
ct_cx  vararray_sizenumber_of_equations
ct_cy  variable typeREAL
copies   compact0
ct_psi_copy   descriptionCopies of grid functions
ct_residual_copy   dimensions3
ct_residual_above_copy  distributionDEFAULT
ct_err_copy   group typeGF
ct_trunc_copy   tagstensortypealias=”Scalar” prolongation=”None”
ct_psi_jacobi   timelevels1
ct_err_jacobi  vararray_sizenumber_of_equations
 variable typeREAL
cell_integral   compact0
ct_integrand1   descriptionIntegrand of the equation integral over a cell
ct_integrand2   dimensions3
ct_integrand3   distributionDEFAULT
ct_integrand4   group typeGF
  tagstensortypealias=”Scalar” prolongation=”None”
  timelevels1
 vararray_sizenumber_of_equations
 variable typeREAL
  Group Names    Variable Names    Details   
auxiliaries   compact0
ct_auxiliary   descriptionAuxiliary functions needed to set the equation coefficients in coupled systems
  dimensions3
  distributionDEFAULT
  group typeGF
  tagstensortypealias=”Scalar” prolongation=”None”
  timelevels1
 vararray_sizenumber_of_auxiliaries
 variable typeREAL
rhs   compact0
ct_rhs   descriptionrhs
  dimensions3
  distributionDEFAULT
  group typeGF
  tagstensortypealias=”Scalar” prolongation=”None”
  timelevels1
 vararray_sizenumber_of_equations
 variable typeREAL
constants   compact0
ct_zero   descriptionConstants
  dimensions3
  distributionDEFAULT
  group typeGF
  tagstensortypealias=”Scalar” prolongation=”None”
  timelevels1
 variable typeREAL

Uses header:

Symmetry.h

loopcontrol.h

Boundary.h

7 Schedule

This section lists all the variables which are assigned storage by thorn CTThorns/CT_MultiLevel. Storage can either last for the duration of the run (Always means that if this thorn is activated storage will be assigned, Conditional means that if this thorn is activated storage will be assigned for the duration of the run if some condition is met), or can be turned on for the duration of a schedule function.

Storage

 

Always:  
psi[3]  
residual[3] err[3] 
coeffs[3]  
copies[1]  
cell_integral[1]  
auxiliaries[1]  
rhs[1]  
constants[1]  
   

Scheduled Functions

CCTK_INITIAL

  ct_multilevel

  main multilevel function

 

 After: ct_scalarfield_setconfrho
  Language:c
 Options: global-late
 Type: function