ALGEBRAIC_MULTIGRID_PARAMETERS

Specifies parameters for the algebraic multigrid algorithm.

Type

AcuSolve Command

Syntax

ALGEBRAIC_MULTIGRID_PARAMETERS {parameters}

Qualifier

This command has no qualifier.

Parameters

pressure_negative_coupling_tolerance (real) >=0 <=1 [=0.6]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the pressure matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.6 sets the tolerance to use values of 60 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of pressure_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

pressure_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the pressure matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of pressure_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_pressure_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may increase the time necessary to obtain a solution on the lowest level matrix.

pressure_standard_interpolation (boolean) [=on]

Interpolation method used to build the coarse multigrid matrices from fine matrices or to transfer the solution from a fine level to a coarse multigrid level, and vice versa. With this option set to off, direct interpolation will be used. Each equation in the fine level matrix that is considered to be important in the coarsening process gets interpolated to build the coarse level matrix. In direct interpolation, just neighboring points within the one fine level equation are used to calculate the interpolation weights. In standard interpolation, in addition to the neighboring points, other coupled equations are also considered in the weight calculations. More information is incorporated in the standard interpolation, leading to better convergence. In most cases, standard interpolation is recommended.

pressure_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For pressure matrices, separation of weights is not recommended.

pressure_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the pressure_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

pressure_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when pressure_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

pressure_givens_scaling (boolean) [=on]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

pressure_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

pressure_eigenvalue_tolerance (real) >0 [=1.e-2]

Tolerance to stop the eigenvalue calculation iterations. Used with pressure_smoothing_type=chebyshev. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix. The Iterative Lanczos algorithm is used to calculate the maximum eigenvalue of the pressure matrix.

max_pressure_eigenvalue_iterations (integer) >=0 [=20]

Used with pressure_smoothing_type=chebyshev. Maximum number of iterations of the Lanczos algorithm for computing the largest eigenvalues at each multigrid level. The pressure_eigenvalue_tolerance and max_pressure_eigenvalue_iterations determine when iterations stop. Whichever constraint is met first stops the algorithm. In general, eigenvalues converge within 20 iterations. For cases where the eigenvalues do not converge, increasing the total number of iterations can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

pressure_smoothing_order (integer) >=1 [=2]

When pressure_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When pressure_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For pressure matrices, a value of two is found to give the best performance.

pressure_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When pressure_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

pressure_jacobi_relaxation_factor (real) >0 [=0.25]

Used when pressure_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

pressure_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as pressure and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

num_pressure_global_basis (integer) >=0 [=0]

This parameter was retired in the 13.0 release.

pressure_global_basis_tolerance (real) >0 [=1.e-6]

This parameter was retired in the 13.0 release.

max_pressure_global_basis_iterations (integer) >0 [=1000]

This parameter was retired in the 13.0 release.

num_pressure_initial_givens_rotations (integer) >=0 [=0]

This parameter was retired in the 13.0 release.

velocity_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the velocity matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of velocity_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

velocity_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the velocity matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of velocity_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_velocity_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

velocity_standard_interpolation (boolean) [=on]

Interpolation method used to build the coarse multigrid matrices from fine matrices or to transfer the solution from a fine level to a coarse multigrid level, and vice versa. With this option set to off, direct interpolation will be used. Each equation in the fine level matrix that is considered to be important in the coarsening process gets interpolated to build the coarse level matrix. In direct interpolation, just neighboring points within the one fine level equation is used to calculate the interpolation weights. In standard interpolation, in addition to the neighboring points, other coupled equations are also considered in the weight calculations. More information is incorporated in the standard interpolation, leading to better convergence. In most cases, standard interpolation is recommended.

velocity_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For velocity matrices, separation of weights is not recommended.

velocity_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the velocity_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

velocity_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when velocity_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

velocity_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

velocity_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

velocity_num_krylov_vectors (integer) >=0 [=30]

Used with velocity_smoothing_type=chebyshev. Number of Krylov vectors in the Arnoldi algorithm for computing the largest eigenvalues at each multigrid level. In general, eigenvalues converge within 30 Krylov vectors. For cases where the eigenvalues do not converge, increasing the number of Krylov vectors can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

velocity_smoothing_order (integer) >=1 [=2]

When velocity_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When velocity_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For velocity matrices, a value of two is found to give the best performance.

velocity_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When velocity_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

velocity_jacobi_relaxation_factor (real) >0 [=0.25]

Used when velocity_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

velocity_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as velocity and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

flow_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the flow matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of flow_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

flow_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the flow matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of flow_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_flow_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

flow_standard_interpolation (boolean) [=off]

flow_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For flow matrices, separation of weights is not recommended.

flow_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the flow_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

flow_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when flow_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

flow_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

flow_smoothing_type (enumerated) [=jacobi]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

flow_num_krylov_vectors (integer) >=0 [=30]

Used with flow_smoothing_type=chebyshev. Number of Krylov vectors in the Arnoldi algorithm for computing the largest eigenvalues at each multigrid level. In general, eigenvalues converge within 30 Krylov vectors. For cases where the eigenvalues do not converge, increasing the number of Krylov vectors can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

flow_smoothing_order (integer) >=1 [=2]

When flow_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When flow_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For flow matrices, a value of two is found to give the best performance.

flow_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When flow_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

flow_jacobi_relaxation_factor (real) >0 [=0.2]

Used when flow_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.2 means updated values will be calculated by adding 20 percent of new values to 80 percent of the old values.

flow_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as flow and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

temperature_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the temperature matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of temperature_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

temperature_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the temperature matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of temperature_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_temperature_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

temperature_standard_interpolation (boolean) [=on]

temperature_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For temperature matrices, separation of weights is not recommended.

temperature_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the temperature_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

temperature_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when temperature_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

temperature_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

temperature_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

temperature_num_krylov_vectors (integer) >=0 [=30]

Used with temperature_smoothing_type=chebyshev. Number of Krylov vectors in the Arnoldi algorithm for computing the largest eigenvalues at each multigrid level. In general, eigenvalues converge within 30 Krylov vectors. For cases where the eigenvalues do not converge, increasing the number of Krylov vectors can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

temperature_smoothing_order (integer) >=1 [=2]

When temperature_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When temperature_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For temperature matrices, a value of two is found to give the best performance.

temperature_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When temperature_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

temperature_jacobi_relaxation_factor (real) >0 [=0.25]

Used when temperature_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

temperature_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as temperature and turbulence, and this parameter greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

species_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the species matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of species_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

species_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the species matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of species_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_species_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

species_standard_interpolation (boolean) [=on]

species_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For species matrices, separation of weights is not recommended.

species_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the species_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

species_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when species_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

species_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

species_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

species_num_krylov_vectors (integer) >=0 [=30]

Used with species_smoothing_type=chebyshev. Number of Krylov vectors in the Arnoldi algorithm for computing the largest eigenvalues at each multigrid level. In general, eigenvalues converge within 30 Krylov vectors. For cases where the eigenvalues do not converge, increasing the number of Krylov vectors can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

species_smoothing_order (integer) >=1 [=2]

When species_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When species_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For species matrices, a value of two is found to give the best performance.

species_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When species_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

species_jacobi_relaxation_factor (real) >0 [=0.25]

Used when species_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

species_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as species and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

turbulence_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the turbulence matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of turbulence_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

turbulence_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the turbulence matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of turbulence_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_turbulence_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

turbulence_standard_interpolation (boolean) [=on]

turbulence_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For turbulence matrices, separation of weights is not recommended.

turbulence_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the turbulence_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

turbulence_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when turbulence_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

turbulence_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

turbulence_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

turbulence_num_krylov_vectors (integer) >=0 [=30]

Used with turbulence_smoothing_type=chebyshev. Number of Krylov vectors in the Arnoldi algorithm for computing the largest eigenvalues at each multigrid level. In general, eigenvalues converge within 30 Krylov vectors. For cases where the eigenvalues do not converge, increasing the number of Krylov vectors can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

turbulence_smoothing_order (integer) >=1 [=3]

When turbulence_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When turbulence_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For turbulence matrices, a value of two is found to give the best performance.

turbulence_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When turbulence_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

turbulence_jacobi_relaxation_factor (real) >0 [=0.25]

Used when turbulence_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

turbulence_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as temperature and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

mesh_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the mesh matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of mesh_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

mesh_positive_coupling_tolerance (real) >=0 <=1 [=1.0]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the mesh matrix are considered. Tolerance is the decimal fraction of the maximum value. With the default value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of mesh_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_mesh_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

mesh_standard_interpolation (boolean) [=on]

mesh_positive_negative_separate (boolean) [=on]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For mesh matrices, separation of weights is recommended.

mesh_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the mesh_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

mesh_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when mesh_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

mesh_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

mesh_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

mesh_eigenvalue_tolerance (real) >0 [=1.e-2]

Tolerance to stop the eigenvalue calculation iterations. Used with mesh_smoothing_type=chebyshev. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix. The Iterative Lanczos algorithm is used to calculate the maximum eigenvalue of the mesh matrix.

max_mesh_eigenvalue_iterations (integer) >=0 [=20]

Used with mesh_smoothing_type=chebyshev. Maximum number of iterations of the Lanczos algorithm for computing the largest eigenvalues at each multigrid level. The mesh_eigenvalue_tolerance and max_mesh_eigenvalue_iterations determine when iterations stop. Whichever constraint is met first stops the algorithm. In general, eigenvalues converge within 20 iterations. For cases where the eigenvalues do not converge, increasing the total number of iterations can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

mesh_smoothing_order (integer) >=1 [=2]

When mesh_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When mesh_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For mesh matrices, a value of two is found to give the best performance.

mesh_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When mesh_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

mesh_jacobi_relaxation_factor (real) >0 [=0.25]

Used when mesh_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

mesh_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as mesh and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

viscoelastic_negative_coupling_tolerance (real) >=0 <=1 [=0.5]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly negatively coupled variables for the viscoelastic matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.5 sets the tolerance to use values of 50 percent or greater of the most negative value. With a value of 1.0, negative coupling is ignored. Negative coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly negatively coupled if the negated value of the matrix entry exceeds the maximum negated value of the matrix multiplied by the negative coupling tolerance. The value of viscoelastic_negative_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

viscoelastic_positive_coupling_tolerance (real) >=0 <=1 [=0.3]

Tolerance within the algebraic multigrid (AMG) coarsening algorithm to determine when strongly positively coupled variables for the viscoelastic matrix are considered. Tolerance is the decimal fraction of the maximum value. The default value of 0.3 sets the tolerance to use values of 30 percent or greater of the most positive value. With a value of 1.0, positive coupling is ignored. Positive coupling tolerance is used when determining which entries from the fine matrix levels are retained at the coarser matrix levels. To select the coarse level grids for a matrix, only the values with a high contribution to the unknown equations are considered. Terms are considered to be highly positively coupled if the value of the matrix entry exceeds the maximum value of the matrix multiplied by the positive coupling tolerance. The value of viscoelastic_positive_coupling_tolerance can have significant influence on the structure of coarse level grids, influencing the convergence rate of the linear solution.

max_viscoelastic_final_matrix (integer) >=1 [=100]

Maximum number of entries present in the coarsest matrix of the AMG algorithm. With the default value of 100, coarsening will stop when the lowest level matrix is 10 by 10 or smaller. Increasing the size of this parameter may lead to longer duration of the solution calculation of the lowest level matrix.

viscoelastic_standard_interpolation (boolean) [=on]

viscoelastic_positive_negative_separate (boolean) [=off]

Determines if the positive and negative weights are separated during either standard or direct interpolation. In either direct or standard interpolation, weights are functions of off diagonal components of the fine level matrix and can be positive or negative. Interpolation can be conducted either separately for positive and negative weights, or these weights can be added together to have one interpolation. With this option set to on, summation of positive and negative weights will be calculated and used for interpolation. For viscoelastic matrices, separation of weights is not recommended.

viscoelastic_truncated_interpolation (boolean) [=on]

Determines if the small interpolation weights will be truncated when interpolating the fine level multigrid matrix to the coarse level matrix or when transferring the solution from the coarse matrix to the finer AMG matrix levels. This flag should be used together with the viscoelastic_truncation_tolerance to set the tolerance to determine the small weights. Truncation can be used with both direct and standard interpolation. A minor increase in the computational time to reach convergence can be observed if this flag is set to off.

viscoelastic_truncation_tolerance (real) >=0 <=1 [=0.1]

Sets the portion of the smallest interpolation weights to be truncated during interpolation from a fine level to a coarse level. Used when viscoelastic_truncated_interpolation=on. With a value of zero, no interpolation weights will be truncated. With a value of one, all weights will be truncated.

viscoelastic_givens_scaling (boolean) [=off]

Determines if two by two Givens matrix scaling is used for the multigrid smoothing process. With this option turned off, diagonal scaling is used.

viscoelastic_smoothing_type (enumerated) [=chebyshev]

Smoothing method used at each grid level after interpolation when values are from a fine matrix to a coarse matrix, or from a coarse matrix to a fine matrix.

Chebyshev: Chebyshev polynomial smoothing. Chebychev smoothing provides better performance, accurate convergence with less computational time, and is recommended for most matrices.
Jacobi: Jacobi smoothing. Jacobi smoothing is recommended for the fully coupled flow stagger.

viscoelastic_num_krylov_vectors (integer) >=0 [=30]

Used with viscoelastic_smoothing_type=chebyshev. Number of Krylov vectors in the Arnoldi algorithm for computing the largest eigenvalues at each multigrid level. In general, eigenvalues converge within 30 Krylov vectors. For cases where the eigenvalues do not converge, increasing the number of Krylov vectors can lead to better estimates of the eigenvalues at the expense of increased total computation time.

Note: Poor estimates of eigenvalues also increase solution time by slowing the convergence of the AMG algorithm.

viscoelastic_smoothing_order (integer) >=1 [=2]

When viscoelastic_smoothing_type=chebyshev, this parameter sets the polynomial order for the smoother. When viscoelastic_smoothing_type=jacobi this parameter sets the number of smoothing passes during the downward and upward multigrid cycles. For both Chebyshev and Jacobi methods, increasing the smoothing order will reduce the total number of linear solver iterations required to converge the system. However, the time per iteration will also increase. There should be a balance between the number of iterations and the time per iteration. For viscoelastic matrices, a value of two is found to give the best performance.

viscoelastic_chebyshev_max_min_ratio (real) >1 <=100 [=10]

When viscoelastic_smoothing_type=chebyshev, this parameter provides an estimate of the smallest eigenvalue by dividing the largest eigenvalue calculated by the Lanczos algorithm by this parameter. Chebyshev polynomial smoothing requires the ratio of the largest to the smallest eigenvalues of the matrix to calculate the polynomial coefficients. The smallest value may not be calculated. This parameter can be used to get an estimate. The default of 10 means that the smallest eigenvalue is one tenth of the largest.

viscoelastic_jacobi_relaxation_factor (real) >0 [=0.25]

Used when viscoelastic_smoothing_type=jacobi. Jacobi smoothing may not be stable and it should be relaxed. Conventional under relaxation is used to stabilize it. The default of 0.25 means updated values will be calculated by adding 25 percent of new values to 75 percent of the old values.

viscoelastic_setup_tolerance (real) >0 [=0]

The nonlinear convergence tolerance used to control when the AMG setup process is performed. If the residual is higher than this value, the AMG setup process is performed. If the residual is lower than this tolerance, the AMG algorithm uses the existing setup information that is stored in RAM. With the default value of zero, the AMG setup process will occur every time the equations are solved, regardless of the residual. As the simulation converges, the change in solution between time steps decreases, minimizing the need to execute the AMG setup process. If AMG is used for more than one equation, such as viscoelastic and turbulence, and this parameter is greater than zero, the memory requirements will be increased.

Note: For each equation, a different setup tolerance can be used. This value should not be changed unless a convergence tolerance is set for the problem that is less than the default value.

Description

This command specifies the parameters of the algebraic multigrid algorithm. This option can be used to speed up the linear solution on problems in which the solver takes a large number of iterations at each step. The AMG algorithm works by interpolating the full matrix equation down to smaller sized matrices that can be solved directly with very little effort. The solution on the coarse matrix is then propagated back up through the successively finer matrices until it reaches the full matrix. At this point, the AMG solution is used to precondition the standard solver used for each stagger. This operation carries a significant amount of additional compute expense to perform, but can provide significant acceleration of the solution in some cases. This method also carries additional memory overhead. For most applications, turning this feature on will lead to approximately 50 percent greater memory consumption than using the standard preconditioning.

For example, to specify the use of AMG on the pressure projection equation when performing the fully coupled flow solve, the following commands can be used:

STAGGER("flow"){
   ...
   pressure_projection                      = on
   pressure_algebraic_multigrid             = on
   ...
}
ALGEBRAIC_MULTIGRID_PARAMETERS {
   pressure_standard_interpolation          = on
   pressure_truncated_interpolation         = on
   pressure_negative_coupling_tolerance     = 0.6
   pressure_positive_coupling_tolerance     = 1
   pressure_truncation_tolerance            = 0.1
   max_pressure_final_matrix                = 100
   pressure_eigenvalue_tolerance            = 0.01
   max_pressure_eigenvalue_iterations       = 20
   pressure_smoothing_order                 = 2
   pressure_chebyshev_max_min_ratio         = 10
   pressure_jacobi_relaxation_factor        = 0.25
   pressure_smoothing_type                  = chebyshev
   pressure_positive_negative_separate      = off
   pressure_givens_scaling                  = on
   pressure_setup_tolerance                 = 0
}