numMethods/methodOfLines.h

Go to the documentation of this file.

/**
 *  @file      methodOfLines.h
 *  @brief     Descriptors for various methods of lines (MoL).
 *  @author    Mikica Kocic
 *  @copyright GNU General Public License (GPLv3).
 */

/////////////////////////////////////////////////////////////////////////////////////////
/** @defgroup g11 Numerical Methods                                                    */
/////////////////////////////////////////////////////////////////////////////////////////
                                                                                   /*@{*/
/** Interface used for MoL integration that prepares and finalizes integration steps.
  */
class IntegFace
{
    friend class MoLIntegrator;

    /** Calculate the dependent variables from the prime state variables
     *  which are needed for the integration.
     */
    virtual void integStep_Prepare( Int m ) = 0;

    /** Perform the additional steps after each integration step.
     */
    virtual void integStep_Finalize( Int mNext, Int mPrev ) = 0;

    /** Checkpoint handler (e.g., checking for eventual NaNs).
     */
    virtual bool integStep_CheckForNaNs( Int m, Int nFrom, Int nTo ) = 0;

    /** Prepare the right-hand side of the evolution equations.
     */
    virtual void integStep_CalcEvolutionRHS( Int m ) = 0;

    /** Fix the state variables at the left boundary.
     */
    virtual void applyLeftBoundaryCondition( Int m ) = 0;

    /** Fix the state variables at the right boundary.
     */
    virtual void applyRightBoundaryCondition( Int m ) = 0;
};

/** @struct MoLDescriptor
 *  A method of lines (MoL) descriptor.
 *
 *  <pre>
 *       partial_t Y = L[Y],  </pre>
 *
 *  using the following algorithm:
 *  <pre>
 *      Y^{(0)}   = Y^{m},
 *      Y^{(i+1)} = Sum_{j=0}^{i} ( alpha_{ij} Y^{(j)} ) +            <- integStep_MoL
 *                  Delta t beta_i L[Y^{(i)}],   for i = 0, ..., N-1, <- integStep_MoLInit
 *      Y^{m+1}   = Y^{(N)}.    </pre>
 *
 *  The variables `Y^{(i)}`, `i = 0, ..., N`, are intermediate.
 *
 *  The method is completely specified by `N`, and arrays alpha and beta
 *  in the structure MoLDescriptor.
 *
 *  @see <a href="http://cactuscode.org/documentation/thorns/CactusBase-MoL.pdf">
 *       Method of Lines - Cactus Code</a>
 *
 */
struct MoLDescriptor
{
    const char* name;  //!< A MoL evolution method name
    int N;             //!< Number of intermediate steps (N <= 8)
    Real alpha[8][8];  //!< Alpha coefficients
    Real beta[8];      //!< Beta coefficients
};

// Time evolution methods provided by MoL

MoLDescriptor ICN2 = //!< Iterative Crank-Nicolson, 2-iterations
{
    "Iterative Crank-Nicolson", 2,
    { {  1., 0. },
      {  0., 1. } },
    { 1./2., 1. }
};

MoLDescriptor ICN3 = //!< Iterative Crank-Nicolson, 3-iterations
{
    "Iterative Crank-Nicolson", 3,
    { {  1., 0., 0. },
      {  0., 1., 0. },
      {  0., 0., 1. } },
    { 1./2., 1./2., 1. }
};

MoLDescriptor RK1 = //!< Runge-Kutta, 1st order (the Euler method)
{
    "Runge-Kutta", 1,
    { { 1. } },
    { 1. }
};

MoLDescriptor RK2 = //!< Runge-Kutta, 2nd order
{
    "Runge-Kutta", 2,
    { {     1.,    0. },
      {  1./2., 1./2. } },
    { 1., 1./2. }
};

MoLDescriptor RK3 = //!< Runge-Kutta, 3rd order
{
    "Runge-Kutta", 3,
    { {     1.,    0.,    0. },
      {  3./4., 1./4.,    0. },
      {  1./3.,    0., 2./3. } },
    { 1., 1./4., 2./3. }
};

MoLDescriptor RK4 = //!< Runge-Kutta, 4th order
{
    "Runge-Kutta", 4,
    { {     1.,    0.,    0.,    0. },
      {     1.,    0.,    0.,    0. },
      {     1.,    0.,    0.,    0. },
      { -1./3., 1./3., 2./3., 1./3. } },
    { 1./2., 1./2., 1., 1./6. }
};
                                                                                   /*@}*/
/////////////////////////////////////////////////////////////////////////////////////////