Add support for evolving complex GFs and (real and complex) GAs.

Only works with ICN or RK2 for now - in fact this commit may break the generic RK methods temporarily.

Note the documentation isn't quite right - there's no longer a seperate function for each different type...


git-svn-id: http://svn.cactuscode.org/arrangements/CactusNumerical/MoL/trunk@12 578cdeb0-5ea1-4b81-8215-5a3b8777ee0b

1 files changed, 1338 insertions, 206 deletions

diff --git a/doc/documentation.tex b/doc/documentation.tex
index d27c6ea..1b86f4b 100644
--- a/doc/documentation.tex
+++ b/doc/documentation.tex
@@ -280,8 +280,8 @@ to belong to the category with the highest priority.
 
 MoL needs to know the total number of GFs in each category \textit{at
   parameter time}. To do this, your thorn needs to use some
-accumulator parameters from MoL. As an example, here are the paramters
-from WaveMoL:
+accumulator parameters from MoL. As an example, here are the
+paramaters from WaveMoL:
 \begin{verbatim}
 shares: MethodOfLines
 
@@ -329,8 +329,8 @@ section~\ref{sec:molfns}.
 
 These functions are provided using function aliasing. For details on
 using function aliasing, see sections B10.5 and F2.2.3 of the
-UsersGuide. In this specific case, you simply add the following lines
-to your \texttt{interface.ccl}:
+UsersGuide. For the case of real GFs, you simply add the following
+lines to your \texttt{interface.ccl}:
 \begin{verbatim}
 ##########################################
 ### PROTOTYPES - DELETE AS APPLICABLE! ###
@@ -364,6 +364,13 @@ USES FUNCTION MoLChangeToSaveAndRestore
 USES FUNCTION MoLChangeToNone
 \end{verbatim}
 
+Note that the list of paramters and functions is not complete; only
+the case of real GFs is covered. MoL will evolve complex GFs and real
+and complex grid arrays. For these cases the functions and parameters
+have different names but the use and interfaces are identical. See the
+section on parameters and the section on functions (\ref{sec:molfns})
+for the precise names.
+
 Having done that, one routine (or group of routines) which we'll here
 call {\tt Thorn\_CalcRHS} must be defined. This does all the finite
 differencing that you'd usually do, applied to ${\bf q}$, and finds
@@ -512,198 +519,6 @@ variables back to the standard ADM variables in {\tt
   ADM\_BSSN\_StandardVariables}, and also update the time derivative
 of the lapse in {\tt ADM\_BSSN\_LapseChange}.
 
-% \section{The gory details}
-% \label{sec:gory}
-
-% This section is more for people wishing to maintain and extend the
-% code. {\bf NEEDS TOTAL REWRITE FOR MOL2}
-
-% There are three essential parts to the MoL thorn. The first is the
-% registration process where the MoL thorn is told just how many GFs it
-% should be looking to integrate, and where they and their RHSs
-% are. This is split into three separate routines.
-% \begin{itemize}
-% \item {\tt MoL\_Init\_Register} Called by the MoL thorn at {\tt
-%     postinitial}.  Initializes the number of variables to the maximum
-%   possible number (given by {\tt CCTK\_NumVars()}). Sets up two arrays
-%   of pointers to GFs (CCTK\_Real**), one for the data ({\tt qindex})
-%   and one for the RHSs ({\tt qrhsindex}). It also sets up index arrays
-%   for the primitive and dependent variables.
-% \item {\tt MoL\_Register} This group lets MoL knows where all the data
-%   is and should contain all the user thorn calls to {\tt
-%     MoL\_RegisterVar()}. This just associates the index of the
-%   GFs to be evolved with their RHSs, and increments the number of
-%   variables to be evolved. Also contains the routines to register the
-%   primitive and dependent variables.
-% \item {\tt MoL\_End\_Register} This could be used to reallocate the
-%   index arrays to the correct size. For the moment I've decided that
-%   the tiny memory gain is outweighed by the possiblity of problems
-%   using realloc.
-% \end{itemize}
-
-% The second part of the MoL thorn sets up all the scratch space and the
-% parameters for the generalized RK routines. This is also scheduled at
-% postinitial. This contains the routines
-
-% \begin{itemize}
-% \item {\tt MoL\_SetupScratch} Sets up the scratch space. Sets the
-%   scalar {\tt mol\_num\_scratch} which is the size of the required
-%   scratch space from the defaults, then allocates the scratch arrays. 
-% \item {\tt MoL\_RKSetup} Sets up the $\alpha$ and $\beta$ arrays for
-%   the generalized Runge Kutta step. Note that as we're currently only
-%   storing the most recent RHS arrays the $\beta$ arrays are single
-%   index only.
-% \end{itemize}
-
-% The final part of the MoL thorn is the evolution step. This is again
-% split into a number of separate routines and groups. Firstly we
-% describe a single evolution step, and what MoL expects.
-
-% By a single evolution step we here mean the execution of everything
-% inside the schedule bin {\tt EVOL}. MoL expects that every GF that it
-% knows about is allocated, initialized and lives at the same instant of
-% computational time. MoL also expects the ghost zones and boundaries to
-% be set correctly. Wherever possible the first two are checked. MoL
-% expects that the driver has rotated the timelevels so that the last
-% set of complete, consistent data is stored in ${\bf q}\_p$. MoL also
-% knows that the dependent variables may or may not have been evolved by
-% the time the MoL evolution group is executed.
-
-% \begin{figure}[ht]
-% \begin{center}
-% \includegraphics[width=3cm]{MoLdia1}
-% \includegraphics[width=3cm]{MoLdia2}
-% \includegraphics[width=3cm]{MoLdia3}
-% \end{center}
-% \caption{How MoL treats the three different types of variables. The
-%   MoL step is performed at evolution after the driver has rotated the
-%   timelevels, which occurs right at the start of every {\tt
-%     CCTK\_EVOL} step. The physics thorns expect the most recent data
-%   to be at the current time level (the top solid line). So the first
-%   step for most types of variable is to copy or pointer switch the
-%   data from the previous time level (bottom solid line) where the most
-%   recent data exists after rotation. Figure (a) shows the {\it
-%     evolved} variables.  At each intermediate step the data is updated
-%   into the current time level and, if necessary, stored in scratch
-%   space.  Figure (b) shows the {\it primitive} variables. As these are
-%   set by the physics thorns into the current time level all that is
-%   required is the initial copy. Figure (c) shows the {\it dependent}
-%   variables for which we cannot know whether these variables are
-%   evolved before or after MoL at evolution, and hence whether the
-%   current data is already filled before MoL starts, we must store the
-%   current data in scratch space first, then do the copy from the
-%   previous level, and then at the end of the MoL step return the data
-%   to the initial state.}
-% \label{MoLvariables}
-% \end{figure}
-
-% MoL plays around with the timelevels during the intermediate
-% steps. This is required so that the latest level in the MoL evolution
-% is always stored in the same place so that the user thorns can easily
-% access them. This place is the current time level ${\bf q}$. This
-% ensures that MoL works correctly with all the standard boundary
-% condition routines and minimizes the effort of porting non timelevel
-% aware thorns (I hope!).
-
-% An outline of the schedule is as follows:
-% \begin{equation}
-%   \label{eq:schedoutline}
-%   \begin{array}[l]{l}
-%     \texttt{MoL\_StartStep} \\
-%     \texttt{MoL\_Step WHILE counter \{} \\
-%     \begin{array}[l]{l}
-%       \texttt{MoL\_CalcRHS \{ \}} \\
-%       \texttt{MoL\_Add} \\
-%       \texttt{MoL\_PostStep \{ \}} \\
-%     \end{array} \\
-%     \texttt{\}} \\
-%     \texttt{MoL\_EndStep \{ \}}
-%   \end{array}
-% \end{equation}
-
-% Each different type of variable is treated slightly differently by
-% MoL. Each is assumed to have at least 2 timelevels (although this is
-% checked, a fatal error occurs otherwise). Before entering the loop
-% over the intermediate steps MoL will first copy (pointer switch?) the
-% data into the current time levels. Before doing this the current
-% timelevel of any {\it dependent} variables is copied to scratch space,
-% as it may have already been updated. During the loop over the
-% intermediate steps only the {\it evolved} variables are directly
-% altered by MoL. When all user thorns have given their right hand side
-% GFs the evolved variables are updated into the current time level.
-% This data may also be copied to scratch space if required for later.
-% The primitive variables are assumed to be set by the user thorn,
-% either in the calculation of the RHS or during {\tt MoL\_PostStep} at
-% the end of each intermediate step. The dependent variables are assumed
-% to remain completely unchanged. After all the intermediate steps the
-% data in the current and previous timelevels is ``correct'' and
-% consistent for the evolved and the temporary variables. The data for
-% the current timelevel for the dependent variables is recovered from
-% scratch space. Precisely how the different variables are
-% treated is shown in figure~\ref{MoLvariables}.
-
-% \begin{itemize}
-% \item {\tt MoL\_StartStep} This ensures that the integer keeping
-%     track of where we are in the MoL step is set to the correct
-%     value. It also copies the previous data ${\bf q}_p$ into the
-%     current position ${\bf q}$ ready for the first step.
-% \item {\tt MoL\_Step} This is the main part of the thorn. The scheduler
-%   allows us to loop over this group the correct number of times to
-%   complete a single Cactus evolution step. Contained within this group
-%   are:
-%   \begin{itemize}
-%   \item {\tt MoL\_CalcRHS} The schedule group within which the user
-%     thorns will schedule their routines. These routines should
-%     calculate the GFs ${\bf L}({\bf q})$. The order these routines are
-%     scheduled within this group should not matter.
-%   \item {\tt MoL\_Add} This step performs the time integration
-%     depending on where in the MoL step we are. Updates directly into
-%     the current GF and copies to the scratch space if required.
-%   \item {\tt MoL\_PostStep} Another schedule group within which the
-%     user thorns can schedule such things as primitive variable
-%     recovery, boundary conditions, etc.
-%   \item {\tt MoL\_End} Just alters the scalar tracking the position in
-%     the MoL loop.
-%   \end{itemize}
-% \end{itemize}
-
-% Finally, there are the routines {\tt MoL\_FreeScratch} and {\tt
-%   MoL\_RKFree} which free up the memory that was explicitly taken. For
-% the moment these routines are scheduled at postevol.
-
-
-% \section{Adding new numerical integrators}
-% \label{sec:newmeth}
-
-% There are two obvious ways of adding new ODE integrators into MoL. The
-% first is to follow the route used in the efficient RK2 and ICN
-% methods. That is, you let the underlying infrastructure define the
-% scratch space but you do all the addition yourself. It's probably best
-% if you model your integrator on one of the efficient routines to start
-% with. 
-
-% The alternative is to use the generic integrator. To use this you just
-% need to add the correct set of $\alpha$ and $\beta$ coefficients so
-% that the generic routine can perform the additions. You'll also have
-% to set up the keyword parameters and so on.
-
-% \section{To do list}
-% \label{sec:todo}
-
-% \begin{itemize}
-% \item The documentation must be improved, especially inside the code
-%   itself. 
-% \item Errors are currently not handled well (if at all). This must be
-%   fixed.
-% \item A test suite is required. I'm not sure how to do this without
-%   using WaveMoL, but we could try.
-% \item In order to make the code work with a Mesh Refinement driver,
-%   the scratch spaces must be changed to be grid functions. This is
-%   currently impossible, but Tom Goodale will add the appropriate bits
-%   to the flesh to make it possible to do. At that point the entire
-%   code will probably be rewritten.
-% \end{itemize}
-
 \section{Functions provided by MoL}
 \label{sec:molfns}
 
@@ -763,7 +578,7 @@ CCTK_INT ierr = MoLRegisterEvolved(CCTK_INT EvolvedIndex,
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLRegisterSaveAndRestore()}
       Register Save and Restore variables.
@@ -836,7 +651,7 @@ CCTK_INT ierr = MoLRegisterConstrained(CCTK_INT ConstrainedIndex)
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLRegisterEvolved()}
       Register evolved variables.
@@ -907,7 +722,7 @@ CCTK_INT ierr = MoLRegisterSaveAndRestore(CCTK_INT SandRIndex)
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLRegisterEvolved()}
       Register evolved variables.
@@ -1015,7 +830,7 @@ ierr = MoLRegisterEvolvedGroup(EvolvedIndex, RHSIndex)
 
 
 \begin{FunctionDescription}{MoLRegisterConstrainedGroup}
-  \label{MoL-RegisterConstrainedGroup}
+  \label{MoLRegisterConstrainedGroup}
   
   Tells MoL that the given group is in the constrained category.
 
@@ -1086,7 +901,7 @@ ierr = MoLRegisterConstrainedGroup(ConstrainedIndex)
 
 
 \begin{FunctionDescription}{MoLRegisterSaveAndRestoreGroup}
-  \label{MoL-RegisterSaveAndRestoreGroup}
+  \label{MoLRegisterSaveAndRestoreGroup}
   
   Tells MoL that the given group is in the Save and Restore category.
 
@@ -1154,7 +969,7 @@ ierr = MoLRegisterSaveAndRestoreGroup(SandRIndex)
 
 
 \begin{FunctionDescription}{MoLChangeToEvolved}
-  \label{MoL-ChangeToEvolved}
+  \label{MoLChangeToEvolved}
 
   Sets a GF to belong to the evolved category, with the associated
   update GF. Not used for the initial setting.
@@ -1202,7 +1017,7 @@ CCTK_INT ierr = MoLChangeToEvolved(CCTK_INT EvolvedIndex,
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLRegisterEvolved()}
       Register evolved variables.
@@ -1279,7 +1094,7 @@ CCTK_INT ierr = MoLChangeToConstrained(CCTK_INT EvolvedIndex)
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLRegisterConstrained()}
       Register constrained variables.
@@ -1354,7 +1169,7 @@ CCTK_INT ierr = MoLChangeToSaveAndRestore(CCTK_INT SandRIndex)
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLRegisterSaveAndRestore()}
       Register Save and Restore variables.
@@ -1429,7 +1244,7 @@ CCTK_INT ierr = MoLChangeToNone(CCTK_INT RemoveIndex)
 
   \begin{SeeAlsoSection}
     \begin{SeeAlso}{CCTK\_VarIndex()}
-      Get the GF index.
+      Get the variable index.
     \end{SeeAlso}
     \begin{SeeAlso}{MoLChangeToEvolved()}
       Change a variable at runtime to be evolved.
@@ -1458,6 +1273,1323 @@ ierr = MoLChangeToNone(RemoveIndex)
 
 \end{FunctionDescription}
 
+
+
+\begin{FunctionDescription}{MoLRegisterEvolvedComplex}
+  \label{MoLRegisterEvolvedComplex}
+  
+  Tells MoL that the given \textbf{complex} GF is in the evolved
+  category with the associated update \textbf{complex} GF.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplex(CCTK_INT EvolvedIndex, 
+                                          CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplex(CCTK_INT EvolvedIndex,
+                                          CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{EvolvedIndex}
+      Index of the GF to be evolved.
+    \end{Parameter}
+    \begin{Parameter}{RHSIndex}
+      Index of the associated update GF.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplex()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplex()}
+      Register constrained variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToEvolvedComplex()}
+      Change a variable at runtime to be evolved.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterEvolvedComplex(CCTK_VarIndex("MyThorn::ComplexVar"),
+                                 CCTK_VarIndex("MyThorn::ComplexRHS"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(EvolvedIndex, "MyThorn::ComplexVar")
+call CCTK_VarIndex(RHSIndex, "MyThorn::ComplexRHS")
+ierr = MoLRegisterEvolvedComplex(EvolvedIndex, RHSIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterConstrainedComplex}
+  \label{MoLRegisterConstrainedComplex}
+  
+  Tells MoL that the given \textbf{complex} GF is in the constrained
+  category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplex(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplex(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{ConstrainedIndex}
+      Index of the constrained \textbf{complex} GF.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplex()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplex()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToConstrainedComplex()}
+      Change a variable at runtime to be constrained.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterConstrainedComplex(CCTK_VarIndex("MyThorn::ComplexVar"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(ConstrainedIndex, "MyThorn::ComplexVar")
+ierr = MoLRegisterConstrainedComplex(ConstrainedIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterSaveAndRestoreComplex}
+  \label{MoLRegisterSaveAndRestoreComplex}
+  
+  Tells MoL that the given \textbf{complex} GF is in the Save and
+  Restore category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplex(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplex(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{SandRIndex}
+      Index of the Save and Restore \textbf{complex} GF.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplex()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplex()}
+      Register constrained variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToSaveAndRestoreComplex()}
+      Change a variable at runtime to be Save and Restore.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterSaveAndRestoreComplex(CCTK_VarIndex("MyThorn::ComplexVar"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(SandRIndex, "MyThorn::ComplexVar")
+ierr = MoLRegisterSaveAndRestoreComplex(SandRIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterEvolvedComplexGroup}
+  \label{MoLRegisterEvolvedComplexGroup}
+  
+  Tells MoL that the given \textbf{complex} group is in the evolved
+  category with the associated update group.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplexGroup(CCTK_INT EvolvedIndex, 
+                                               CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplexGroup(CCTK_INT EvolvedIndex, 
+                                               CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{EvolvedIndex}
+      Index of the \textbf{complex} group to be evolved.
+    \end{Parameter}
+    \begin{Parameter}{RHSIndex}
+      Index of the associated update \textbf{complex} group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplexGroup()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplexGroup()}
+      Register constrained variables.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterEvolvedComplexGroup(CCTK_GroupIndex("MyThorn::ComplexVar"),
+                                      CCTK_GroupIndex("MyThorn::ComplexRHS"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(EvolvedIndex, "MyThorn::ComplexVar")
+call CCTK_GroupIndex(RHSIndex, "MyThorn::ComplexRHS")
+ierr = MoLRegisterEvolvedComplexGroup(EvolvedIndex, RHSIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterConstrainedComplexGroup}
+  \label{MoLRegisterConstrainedComplexGroup}
+  
+  Tells MoL that the given \textbf{complex} group is in the
+  constrained category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplexGroup(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplexGroup(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{ConstrainedIndex}
+      Index of the constrained \textbf{complex} group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplexGroup()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplexGroup()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToConstrainedComplex()}
+      Change a variable at runtime to be constrained.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterConstrainedGroupComplex(CCTK_VarIndex("MyThorn::ComplexVar"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(ConstrainedIndex, "MyThorn::ComplexVar")
+ierr = MoLRegisterConstrainedComplexGroup(ConstrainedIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterSaveAndRestoreComplexGroup}
+  \label{MoLRegisterSaveAndRestoreComplexGroup}
+  
+  Tells MoL that the given \textbf{complex} group is in the Save and
+  Restore category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplexGroup(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplexGroup(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{SandRIndex}
+      Index of the save and restore group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplexGroup()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplexGroup()}
+      Register constrained variables.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterSaveAndRestoreComplexGroup(CCTK_GroupIndex("MyThorn::ComplexVar"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(SandRIndex, "MyThorn::ComplexVar")
+ierr = MoLRegisterSaveAndRestoreComplexGroup(SandRIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+\begin{FunctionDescription}{MoLRegisterEvolvedArray}
+  \label{MoLRegisterEvolvedArray}
+  
+  Tells MoL that the given \textbf{array} GF is in the evolved
+  category with the associated update \textbf{array} GF.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedArray(CCTK_INT EvolvedIndex, 
+                                        CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedArray(CCTK_INT EvolvedIndex,
+                                        CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{EvolvedIndex}
+      Index of the \textbf{array} to be evolved.
+    \end{Parameter}
+    \begin{Parameter}{RHSIndex}
+      Index of the associated update \textbf{array}.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreArray()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedArray()}
+      Register constrained variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToEvolvedArray()}
+      Change a variable at runtime to be evolved.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterEvolvedArray(CCTK_VarIndex("MyThorn::MyArray"),
+                               CCTK_VarIndex("MyThorn::MyArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(EvolvedIndex, "MyThorn::MyArray")
+call CCTK_VarIndex(RHSIndex, "MyThorn::MyArray")
+ierr = MoLRegisterEvolvedArray(EvolvedIndex, RHSIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterConstrainedArray}
+  \label{MoLRegisterConstrainedArray}
+  
+  Tells MoL that the given \textbf{array} GF is in the constrained
+  category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedArray(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedArray(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{ConstrainedIndex}
+      Index of the constrained \textbf{array}.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedArray()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreArray()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToConstrainedArray()}
+      Change a variable at runtime to be constrained.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterConstrainedArray(CCTK_VarIndex("MyThorn::MyArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(ConstrainedIndex, "MyThorn::MyArray")
+ierr = MoLRegisterConstrainedArray(ConstrainedIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterSaveAndRestoreArray}
+  \label{MoLRegisterSaveAndRestoreArray}
+  
+  Tells MoL that the given \textbf{array} GF is in the Save and
+  Restore category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreArray(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreArray(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{SandRIndex}
+      Index of the Save and Restore \textbf{array}.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedArray()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedArray()}
+      Register constrained variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToSaveAndRestoreArray()}
+      Change a variable at runtime to be Save and Restore.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterSaveAndRestoreArray(CCTK_VarIndex("MyThorn::MyArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(SandRIndex, "MyThorn::MyArray")
+ierr = MoLRegisterSaveAndRestoreArray(SandRIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterEvolvedArrayGroup}
+  \label{MoLRegisterEvolvedArrayGroup}
+  
+  Tells MoL that the given \textbf{array} group is in the evolved
+  category with the associated update group.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedArrayGroup(CCTK_INT EvolvedIndex, 
+                                             CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedArrayGroup(CCTK_INT EvolvedIndex, 
+                                             CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{EvolvedIndex}
+      Index of the \textbf{array} group to be evolved.
+    \end{Parameter}
+    \begin{Parameter}{RHSIndex}
+      Index of the associated update \textbf{array} group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreArrayGroup()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedArrayGroup()}
+      Register constrained variables.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterEvolvedArrayGroup(CCTK_GroupIndex("MyThorn::MyArray"),
+                                    CCTK_GroupIndex("MyThorn::MyArrayRHS"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(EvolvedIndex, "MyThorn::MyArray")
+call CCTK_GroupIndex(RHSIndex, "MyThorn::MyArrayRHS")
+ierr = MoLRegisterEvolvedArrayGroup(EvolvedIndex, RHSIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterConstrainedArrayGroup}
+  \label{MoLRegisterConstrainedArrayGroup}
+  
+  Tells MoL that the given \textbf{array} group is in the constrained
+  category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedArrayGroup(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedArrayGroup(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{ConstrainedIndex}
+      Index of the constrained \textbf{array} group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedArrayGroup()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreArrayGroup()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToConstrainedArray()}
+      Change a variable at runtime to be constrained.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterConstrainedGroupArray(CCTK_VarIndex("MyThorn::MyArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(ConstrainedIndex, "MyThorn::MyArray")
+ierr = MoLRegisterConstrainedArrayGroup(ConstrainedIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterSaveAndRestoreArrayGroup}
+  \label{MoLRegisterSaveAndRestoreArrayGroup}
+  
+  Tells MoL that the given \textbf{array} group is in the Save and
+  Restore category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreArrayGroup(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreArrayGroup(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{SandRIndex}
+      Index of the save and restore group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedArrayGroup()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedArrayGroup()}
+      Register constrained variables.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterSaveAndRestoreArrayGroup(CCTK_GroupIndex("MyThorn::MyArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(SandRIndex, "MyThorn::MyArray")
+ierr = MoLRegisterSaveAndRestoreArrayGroup(SandRIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+\begin{FunctionDescription}{MoLRegisterEvolvedComplexArray}
+  \label{MoLRegisterEvolvedComplexArray}
+  
+  Tells MoL that the given \textbf{complex array} is in the evolved
+  category with the associated update \textbf{complex array}.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplexArray(CCTK_INT EvolvedIndex, 
+                                               CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplexArray(CCTK_INT EvolvedIndex,
+                                               CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{EvolvedIndex}
+      Index of the \textbf{complex array} to be evolved.
+    \end{Parameter}
+    \begin{Parameter}{RHSIndex}
+      Index of the associated update \textbf{complex array}.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplexArray()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplexArray()}
+      Register constrained variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToEvolvedComplexArray()}
+      Change a variable at runtime to be evolved.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterEvolvedComplexArray(CCTK_VarIndex("MyThorn::MyComplexArray"),
+                                      CCTK_VarIndex("MyThorn::MyComplexArrayRHS"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(EvolvedIndex, "MyThorn::MyComplexArray")
+call CCTK_VarIndex(RHSIndex, "MyThorn::MyComplexArrayRHS")
+ierr = MoLRegisterEvolvedComplexArray(EvolvedIndex, RHSIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterConstrainedComplexArray}
+  \label{MoLRegisterConstrainedComplexArray}
+  
+  Tells MoL that the given \textbf{complex array} is in the
+  constrained category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplexArray(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplexArray(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{ConstrainedIndex}
+      Index of the constrained \textbf{complex array}.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplexArray()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplexArray()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToConstrainedComplexArray()}
+      Change a variable at runtime to be constrained.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterConstrainedComplexArray(CCTK_VarIndex("MyThorn::MyComplexArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(ConstrainedIndex, "MyThorn::MyComplexArray")
+ierr = MoLRegisterConstrainedComplexArray(ConstrainedIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterSaveAndRestoreComplexArray}
+  \label{MoLRegisterSaveAndRestoreComplexArray}
+  
+  Tells MoL that the given \textbf{complex array} is in the Save and
+  Restore category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplexArray(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplexArray(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{SandRIndex}
+      Index of the Save and Restore \textbf{complex array}.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_VarIndex()}
+      Get the variable index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplexArray()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplexArray()}
+      Register constrained variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToSaveAndRestoreComplexArray()}
+      Change a variable at runtime to be Save and Restore.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterSaveAndRestoreComplexArray(CCTK_VarIndex("MyThorn::MyComplexArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_VarIndex(SandRIndex, "MyThorn::MyComplexArray")
+ierr = MoLRegisterSaveAndRestoreComplexArray(SandRIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterEvolvedComplexArrayGroup}
+  \label{MoLRegisterEvolvedComplexArrayGroup}
+  
+  Tells MoL that the given \textbf{complex array} group is in the
+  evolved category with the associated update group.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplexArrayGroup(CCTK_INT EvolvedIndex, 
+                                                    CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterEvolvedComplexArrayGroup(CCTK_INT EvolvedIndex, 
+                                                    CCTK_INT RHSIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{EvolvedIndex}
+      Index of the \textbf{complex array} group to be evolved.
+    \end{Parameter}
+    \begin{Parameter}{RHSIndex}
+      Index of the associated update \textbf{complex array} group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplexArrayGroup()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplexArrayGroup()}
+      Register constrained variables.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterEvolvedComplexArrayGroup(CCTK_GroupIndex("MyThorn::MyComplexArray"),
+                                           CCTK_GroupIndex("MyThorn::MyComplexArrayRHS"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(EvolvedIndex, "MyThorn::MyComplexArray")
+call CCTK_GroupIndex(RHSIndex, "MyThorn::MyComplexArrayRHS")
+ierr = MoLRegisterEvolvedComplexArrayGroup(EvolvedIndex, RHSIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterConstrainedComplexArrayGroup}
+  \label{MoLRegisterConstrainedComplexArrayGroup}
+  
+  Tells MoL that the given \textbf{complex array} group is in the constrained category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplexArrayGroup(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterConstrainedComplexArrayGroup(CCTK_INT ConstrainedIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{ConstrainedIndex}
+      Index of the constrained \textbf{complex array} group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplexArrayGroup()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterSaveAndRestoreComplexArrayGroup()}
+      Register Save and Restore variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLChangeToConstrainedComplexArray()}
+      Change a variable at runtime to be constrained.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterConstrainedGroupComplexArray(CCTK_VarIndex("MyThorn::MyComplexArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(ConstrainedIndex, "MyThorn::MyComplexArray")
+ierr = MoLRegisterConstrainedComplexArrayGroup(ConstrainedIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
+
+
+\begin{FunctionDescription}{MoLRegisterSaveAndRestoreComplexArrayGroup}
+  \label{MoLRegisterSaveAndRestoreComplexArrayGroup}
+  
+  Tells MoL that the given \textbf{complex array} group is in the Save
+  and Restore category.
+
+  \begin{SynopsisSection}
+    \begin{Synopsis}{C}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplexArrayGroup(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+    \begin{Synopsis}{Fortran}
+\begin{verbatim}
+CCTK_INT ierr = MoLRegisterSaveAndRestoreComplexArrayGroup(CCTK_INT SandRIndex)
+\end{verbatim}
+    \end{Synopsis}
+  \end{SynopsisSection}
+
+  \begin{ResultSection}
+    \begin{ResultNote}
+      Currently if there is an error, MoL will issue a level 0
+      warning. No sensible return codes exist.
+    \end{ResultNote}
+    \begin{Result}{\rm 0}
+      success
+    \end{Result}
+  \end{ResultSection}
+
+  \begin{ParameterSection}
+    \begin{Parameter}{SandRIndex}
+      Index of the save and restore group.
+    \end{Parameter}
+  \end{ParameterSection}
+
+  \begin{Discussion}
+    Should be called in a function scheduled in {\tt MoL\_Register}.
+  \end{Discussion}
+
+  \begin{SeeAlsoSection}
+    \begin{SeeAlso}{CCTK\_GroupIndex()}
+      Get the group index.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterEvolvedComplexArrayGroup()}
+      Register evolved variables.
+    \end{SeeAlso}
+    \begin{SeeAlso}{MoLRegisterConstrainedComplexArrayGroup()}
+      Register constrained variables.
+    \end{SeeAlso}
+  \end{SeeAlsoSection}
+
+  \begin{ExampleSection}
+    \begin{Example}{C}
+\begin{verbatim}
+ierr = MoLRegisterSaveAndRestoreComplexArrayGroup(CCTK_GroupIndex("MyThorn::MyComplexArray"));
+\end{verbatim}
+    \end{Example}
+    \begin{Example}{Fortran}
+\begin{verbatim}
+call CCTK_GroupIndex(SandRIndex, "MyThorn::MyComplexArray")
+ierr = MoLRegisterSaveAndRestoreComplexArrayGroup(SandRIndex)
+\end{verbatim}
+    \end{Example}
+  \end{ExampleSection}
+
+\end{FunctionDescription}
+
 \begin{thebibliography}{9}
 
 \bibitem{AlphaThorns_MoL_Thornburg93}