ply_fpt_header_module Module

Parameters for the FPT method

The Fast Polynomial Transformation implements the approach described in B. K. Alpert und V. Rokhlin, „A Fast Algorithm for the Evaluation of Legendre Expansions“, SIAM Journal on Scientific and Statistical Computing, Vol. 12, Nr. 1, pp. 158–179, Jan. 1991, doi: 10.1137/0912009.

It utilizes the Fast Fourier Transformation by first converting the Legendre modes into Chebyshev modes. The conversion between Legendre and Chebyshev modes is done approximately by approximating increasingly larger blocks away from the diagonal. This method is only available if the executable is linked against the FFTW.

As with the other projection methods, a factor can be specified to use more points in the nodal representation and achieve some de-aliasing. Because the FFT works especially well for powers of two, it is possible to choose the oversampling such, that the oversampled modes have count of the next larger power of 2. To achieve this, the option adapt_factor_pow2 has to be set to true, by default it is assumed to be false. Further it is possible to make use of lobattoPoints with this transformation method. If lobattoPoints = true, the points on the interval boundary will be included in the set of points in the nodal representation. This is for example necessary when positivity is to be preserved for the numerical fluxes. By default this setting is false.

All other options tune the transformation algorithm:

• blocksize defines the minimal block size that is to be approximated in the transformation matrix. It defaults to 64, which is the recommendation for double precision computations, but requires high polynomial degrees to attain any approximation at all. The (oversampled) number of nodes needs to be larger than two times the blocksize, to have at least one approximated block. As long as the number modes is below this threshold the method is not "fast" and a computational complexity of number of modes squared is required for the operation. Smaller values push the approximation closer to the diagonal. This can speed up the computation for smaller number of modes but also detoriates the accuracy of the transformation.
• approx_terms number of terms to use in the approximation of blocks, defaults to 18, which is recommended for double precision computations. In each block only approx_terms will be used to represent rows in the block. Smaller values make the transformation faster, but less accurate (if blocks are actually approximated).
• implementation selects the implementation for the transformation. There are two variants of the implementation: 'scalar' this is the default and treats the transformations with an outer loop over the independent operations. The 'vector' implementation on the other hand gathers multiple independent operations together and performs them all at once with an inner loop over blocks length striplen. While the 'vector' variant may exploit vector instructions, it utilizes a larger amount of temporary memory. The default setting for this option is 'scalar'.
• striplen determines the length for vectorized loops to be used in the matrix operation. It defaults to the vlen setting defined in tem_compileconf_module during compilation. Depending on the computing architecture, different values may provide more efficient computations.
• subblockingWidth defines striding in the multiplication of the diagonal elements in the transformation matrix. The default for this setting is 8.

The configuration table for the FPT table may, for example, look as follows:

  projection = {
    kind              = 'fpt',
    factor            = 1.5,
    adapt_factor_pow2 = true,
    lobattoPoints     = false,
    blocksize         = 16,
    approx_terms      = 12,
    implementation    = 'scalar',
    striplen          = 256,
    subblockingWidth  = 8
  }